Azure OpenAI : Un guide de démarrage étape par étape

Configuration d'Azure OpenAI

Dans cette section, je vous montre comment configurer Azure OpenAI. Je suppose que vous avez une certaine expérience de l'utilisation d'Azure. 

Notez que les interfaces utilisateurs changent fréquemment. Ainsi, la présentation et le texte des différentes sections et titres des instructions et des captures d'écran peuvent changer au fil du temps ou d'une région à l'autre.

Étape 1 : Créez un compte Azure

Allez sur la page d'accueil d'Azure OpenAIet sélectionnez Sign in en haut à droite. Connectez-vous avec votre compte Microsoft. Si vous n'avez pas de compte Microsoft, sélectionnez l'option de création d'un nouveau compte sur la page de connexion et créez un compte Microsoft. 

Ensuite, créez un compte Azure en suivant les étapes ci-dessous :

1. Se connecter à l'aide de votre compte Microsoft sur le portail Azure. Sélectionnez l'option Démarrer avec un essai gratuit d'Azure.

Le portail Microsoft Azure.

2. Sur la page suivante, sélectionnez l'option de création d'un compte Azure gratuit avec 200 $ de crédits gratuits.

Choisissez un type de compte Azure.

3. Complétez vos informations personnelles dans le formulaire.

Créez un compte Azure gratuit.

4. Vérifiez votre identité à l'aide d'une carte de crédit ou de débit. Notez qu'il peut y avoir des frais de garde temporaires (généralement quelques centimes ou l'équivalent) débités de votre compte. 

Vérifiez votre compte Azure (capture d'écran de l'auteur) 

5. Après avoir vérifié vos informations de paiement, sélectionnez Go to Azure Portal. Il vous redirige vers le Centre de démarrage rapide.
6. Notez que les 200 dollars de crédits gratuits ne peuvent pas être utilisés pour les services Azure OpenAI. Les modèles Azure OpenAI ne sont accessibles qu'avec un compte payant. Pour mettre à niveau votre compte vers un abonnement à la carte, retournez sur le portail Azure et sélectionnez Upgrade dans la barre supérieure.

Mettez à jour votre compte Azure.

7. Complétez les détails sur la page de mise à niveau et sélectionnez Passer au paiement au fur et à mesure.

Après avoir obtenu un compte payant, vous pouvez accéder aux modèles OpenAI. 

Étape 2 : Accédez à Azure OpenAI dans le portail Azure

1. Retournez sur le portail Azure, qui affiche une variété de services, tels que les services d'intelligence artificielle, les machines virtuelles, les comptes de stockage, etc. 

Portail Azure affichant les services disponibles.

2. Sélectionnez Azure AI services et accédez à la page d'accueil des AI services. Azure propose divers services basés sur l'IA, tels que la reconnaissance faciale, la détection d'anomalies, la parole, la vision par ordinateur, OpenAI, etc. 

Services Azure AI.

3. Dans le compte Compte Azure OpenAI sélectionnez l'onglet Vue option.
4. Vous accédez à la pageAzure OpenAI , qui affiche la liste des instances OpenAI de votre compte. Sélectionnez Create Azure OpenAI pour créer une nouvelle instance. Vous pouvez également sélectionner Create sur la page précédente.
5. Saisissez les détails ci-dessous :
• Sous Abonnementsélectionnez le nom de votre abonnement payant.
• Sous Groupe de ressourcessélectionnez Créer un nouveau:
• Saisissez un nom pour le nouveau groupe de ressources. 

Créez une nouvelle instance Azure OpenAI.

• • • Sous Région, sélectionnez la région la plus proche.
    • Sous Nomentrez un nom unique.
    • Sous le Prixchoisissez Standard S0.
    • Sélectionnez Suivant pour continuer.

6. Dans la section Réseau, sélectionnez "Tous les réseaux, y compris Internet, peuvent accéder à cette ressource". Passez ensuite à l'étape suivante.
7. Dans la sectionTags, saisissez des paires nom-valeur pour catégoriser cette instance. Cela permet de consolider la facturation. Cette étape est facultative. 
8. Dans la section suivante, sélectionnez Réviser + soumettre, vérifiez les valeurs et sélectionnez Créer. Ceci déploie une nouvelle instance d'OpenAI. 
9. Après quelques instants, le message suivant s'affiche : "Votre déploiement est terminé." Sur cette page, sélectionnez Go to resource.
10. Sur la page de la ressource, sélectionnez le nom de la ressource sous la rubrique Ressources sous l'onglet Ressources.

Étape 3 : Configurer l'accès à l'API

La page des ressources affiche les détails de l'instance. 

L'ongletDevelop affiche les clés API et les URL des points de terminaison de l'API pour cette instance. Les clés ont été générées automatiquement pour vous. 

• Copiez les clés et le point final dans un fichier texte.

Vous obtenez deux clés API. Cela vous permet d'utiliser la deuxième clé au cas où la première serait compromise. Vous pouvez également utiliser la deuxième touche tout en régénérant la première. Cela vous permet d'effectuer une rotation périodique des clés sans subir de temps d'arrêt. 

Clés API de l'instance Azure OpenAI

• Dans le Moniteur vérifiez les mesures d'utilisation de cette instance.
• Dans le Commencer sélectionnez Explorez le portail Azure AI Foundry portail pour ouvrir l'aire de jeu AI sur une nouvelle page.

Terrain de jeu Azure OpenAI.

• Sélectionnez le Chat dans le menu de gauche. dans le menu de gauche.
• Sous Déploiementsélectionnez Créer un nouveau déploiement.
• Sélectionnez A partir des modèles de base dans la fenêtre contextuelle du nouveau déploiement
• Une fenêtre contextuelle s'affiche pour vous permettre de sélectionner le modèle. 
• Dans la barre de recherche, tapez "gpt-3". 
• Sélectionnez gpt-35-turbo dans la liste. Il s'agit d'un modèle économique optimisé pour les complétions par chat. Après avoir obtenu une configuration fonctionnelle, passez à un modèle plus avancé (et plus cher) si nécessaire.
• Sélectionner Confirmez.
• Dans le modèle Déployer le modèle sélectionnez Personnaliser.
• Réduisez la limite de taux de jetons par minute à une valeur faible (par exemple, 12 demandes par minute) pour les tests manuels. Augmentez ce chiffre plus tard, au fur et à mesure que vous mettez le modèle en production. 
• Désactiver les quotas dynamiques. Vous n'en avez pas besoin jusqu'à ce que le déploiement reçoive un trafic important. 
• Sélectionnez Déployer.

Déployez un nouveau modèle dans l'aire de jeu.

C'est tout ! Dans la section suivante, nous verrons comment accéder à ce déploiement du modèle OpenAI gpt-35-turbo. 

Régénération des clés API

Il est conseillé de régénérer périodiquement les clés d'accès à l'API. Cela permet de s'assurer que le compte n'est pas compromis si d'anciennes clés sont divulguées par inadvertance. Les étapes ci-dessous décrivent comment régénérer les clés :

• Sous Gestion des ressources, dans le menu de gauche, sélectionnez Clés et point de terminaison.
• Régénérer chaque clé individuellement. 

Clés API de l'instance Azure OpenAI.

Utiliser Azure OpenAI dans les applications

Après avoir configuré Azure OpenAI et déployé un modèle, nous verrons comment y accéder de manière programmatique. 

Étape 1 : Mise en place de votre environnement de développement

Je vais vous montrer comment utiliser Python pour vous connecter à Azure OpenAI. Installez les bibliothèques nécessaires :

$ pip install openai

Si vous utilisez un ordinateur portable, exécutez la commande suivante. Note : J'utilise un cahier DataLab.

!pip install openai

Importez les paquets nécessaires dans le shell Python ou dans le notebook :

import os
from openai import AzureOpenAI

Le module AzureOpenAI permet d'accéder aux services OpenAI dans Azure. Ce module est différent du module OpenAI utilisé pour accéder à l'API OpenAI autonome.

Avant d'utiliser Azure OpenAI, définissez la clé API et le point de terminaison dans votre environnement. La section précédente a montré comment trouver ces valeurs. En principe, vous pouvez les définir dans l'environnement de programmation, mais je vous recommande de ne jamais le faire. N'exposez jamais les clés d'API dans le programme. 

Définir les clés de l'API à l'aide du terminal

Pour exécuter Python localement, définissez la variable d'environnement dans le fichier de configuration du shell. Je vais vous montrer comment le configurer pour le shell Bash. 

• Modifiez le fichier .bashrc dans un éditeur de texte .
• A la fin du fichier, ajoutez ces deux lignes :
• export AZURE_OPENAI_API_KEY=MY_API_KEY'
• export AZURE_OPENAI_ENDPOINT=MY_ENDPOINT'
• Enregistrez et fermez le fichier.
• Rechargez les modifications dans le terminal à l'aide de la commande source ~/.bashrc.
• Pour d'autres shells, comme sh ou zsh, le processus peut être légèrement différent.
• Ouvrez (ou rouvrez) le shell Python dans la même session de terminal. 

Importez la clé de l'API et les valeurs du point de terminaison dans le terminal Python :

azure_openai_api_key = os.getenv["AZURE_OPENAI_API_KEY"]
azure_openai_endpoint = os.getenv["AZURE_OPENAI_ENDPOINT"]

Définir des clés API à l'aide de carnets en ligne (DataLab)

DataLab vous permet de définir directement des variables d'environnement pour un ordinateur portable.

• Dans la barre de menus supérieure, sélectionnez Environnement et choisissez Variables d'environnement dans la liste déroulante. 
• Sélectionnez l'option permettant d'ajouter des variables d'environnement. 
• Ajoutez deux variables, AZURE_OPENAI_API_KEY et AZURE_OPENAI_ENDPOINT, et leurs valeurs respectives .
• Donnez un nom à cet ensemble de valeurs d'environnement et enregistrez les modifications. 

Dans le carnet de notes, extrayez ces valeurs comme indiqué ci-dessous :

azure_openai_api_key = os.environ["AZURE_OPENAI_API_KEY"]
azure_openai_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]

Étape 2 : Effectuez votre premier appel API vers Azure OpenAI

Vous pouvez maintenant utiliser la fonction AzureOpenAI() pour créer un objet client qui acceptera les demandes. Cette fonction utilise les paramètres suivants :

• api_version: La version de l'API Azure OpenAI. Vérifiez la dernière version à partir de la documentation Azure. 
• api_key: la clé de l'API Azure OpenAI. Vous pouvez obtenir cette information à partir des variables d'environnement que vous avez définies précédemment. Ne le définissez pas manuellement ici. 
• azure_endpointl'URL du point de terminaison de l'API Azure OpenAI (obtenez cette valeur à partir de l'environnement). 

client = AzureOpenAI(
    api_version="2024-06-01",
    api_key=azure_openai_api_key,
    azure_endpoint=azure_openai_endpoint
)

Utilisez cet objet client pour des tâches telles que l'achèvement d'un chat à l'aide de la fonction .chat.completions.create(). Cette fonction accepte les paramètres suivants :

• model: Le nom du modèle. Dans les versions antérieures de l'API OpenAI, il s'agissait du paramètre engine. Notez que le paramètre model doit correspondre au modèle spécifié lors du déploiement (sur le portail Azure AI Foundry). Si vous essayez d'utiliser un modèle différent de celui qui a été déployé, une erreur se produit, comme indiqué ci-dessous : 

NotFoundError: Error code: 404 - {'error': {'code': 'DeploymentNotFound', 'message': 'The API deployment for this resource does not exist. If you created the deployment within the last 5 minutes, please wait a moment and try again.'}}

• messages: Ce paramètre spécifie la conversation entre l'utilisateur et le modèle. Il se compose d'un ensemble d'objets de message. Chaque objet message possède une paire clé-valeur désignée par role (soit system, user, ou assistant) et content(le texte du message). Ces objets de message fournissent le contexte de l'interaction et guident les réponses du modèle. 

Ci-dessous, je donne des exemples de paires clé-valeur (role, content ) pour différentes valeurs de role:

• user: l'invite saisie par l'utilisateur final. 

Exemple : {“role”: “user”, “content”: “explain the difference between rational and irrational numbers”}

• system: la description du rôle que l'OpenAI est censée jouer dans l'interaction. 

Exemple : {“role”: “system”, “content”: “you are a helpful teacher to guide elementary mathematics students”}

• assistant: la réponse attendue de la part de l'OpenAI. 

Exemple : {“role”: “assistant”, “content”: “the difference between rational and irrational numbers is … an example explanation …”}

Le rôle de assistant n'est nécessaire que lorsque des données de formation sont fournies pour affiner le modèle. Lorsque vous utilisez le site client pour des tâches telles que l'achèvement d'un chat, seuls les rôles user et system sont suffisants. Pour de nombreuses tâches simples, le rôle de user suffit.

• max_tokensCe paramètre détermine le nombre maximal de jetons qui peuvent être utilisés pour traiter (à la fois l'entrée et la sortie) l'appel API. Les jetons que vous utilisez vous sont directement facturés. La valeur par défaut est 16. Cette valeur est suffisante pour les cas d'utilisation simples ; ce paramètre peut donc être omis. 

simple_completion = client.chat.completions.create(
    model="gpt-35-turbo",  
    messages=[
        {
            "role": "user",
            "content": "Explain the difference between OpenAI and Azure OpenAI in 20 words",
        },
    ],
)

Imprimez le résultat de la tâche d'achèvement du chat :

print(simple_completion.to_json())

Le résultat est un objet JSON contenant diverses paires clé-valeur. Il comprend les résultats du modèle, comme le montre l'exemple ci-dessous. Notez que assistant est le rôle attribué par défaut au modèle.

"message": {
   "content": "OpenAI is a research organization focused on advancing AI, while Azure OpenAI is a collaboration between Microsoft and OpenAI.",
   "role": "assistant"
},

Étape 3 : Utiliser les modèles OpenAI pour différentes tâches

Pour accéder à un modèle avec Azure OpenAI, vous devez d'abord déployer le modèle. Dans la section précédente, vous avez déployé le modèle gpt-35-turbo. Pour utiliser un autre modèle :

• Retournez sur le site Azure AI Foundry et déployez un modèle différent, comme expliqué dans la section précédente. Choisissez parmi différents modèles tels que GPT-3.5, GPT-4o, o1 et o1-mini, o3 et o3-mini, et bien d'autres encore.
• Réécrivez les invites ci-dessus (dans la fonction chat.completions.create() ) en utilisant le nom du nouveau modèle .

Dans les versions antérieures d'OpenAI, il était courant d'utiliser différents modèles pour différentes tâches. Il existait des modèles dédiés à la génération de code, au NLP, etc. Les modèles modernes tels que GPT-3.5 et GPT-4 peuvent effectuer toutes les tâches génératives basées sur le texte. Ainsi, bon nombre des anciens modèles spécifiques à une tâche (comme les modèles davinci pour la génération de codes) ont été progressivement abandonnés .

Nous allons maintenant examiner comment utiliser l'API pour diverses tâches simples telles que la réponse à des questions et le résumé de texte. Dans les tâches d'exemple ci-dessous, nous utilisons le même modèle - GPT-3.5. Vous pouvez également choisir l'un des modèles GPT-4. 

Comme il s'agit de tâches basées sur du texte, commençons par déclarer un bloc de texte sur lequel nous allons travailler. J'ai arbitrairement copié un avis sur une paire de bottes provenant d'un site de commerce électronique. Attribuez le texte de cette revue à une variable text. Assurez-vous d'échapper à tout caractère de guillemet simple ou double dans le texte. 

text = 'Comfort and Quality wise the boots are absolutely excellent. A 10 miles hike along the city Streets and the alps nearby felt like a smooth sail. The most plus it was quite well ventilated cause of the heavy duty Gore-tex material. After 12 hours when I removed it, there was just very little bit of perspiration (My foot sweats a lot) and absolutely no foul smell. Speaking of the Gore-Tex I would say, I sported this on a heavy rainy day after buying it in India, I was fearing the boot, though not very much like normal boots, would still be drenching with water, instead it was very little soaked. And some 5-6 hours later it was completely dry (Kept inside a closed room in the night). The only disadvantage I think is, that it fits my foot perfectly according to the size I chose, and there is no slight pain from 7 AM till 8 PM due to the shoe weight (of course its 1.2 KG, even though it doesn\'t feel like)' 

Résumé de texte 

Pour résumer le texte ci-dessus :

• Utilisez l' objet client créé précédemment.
• Passez les rôles appropriés dans le paramètre messages comme indiqué dans l'exemple ci-dessous :

summary_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {
         "role": "system",
         "content": "You are a helpful assistant for summarizing text"
        },
        {
            "role": "user",
            "content": f"Summarize this text in 10 words: {text}",
        },
    ],
)

Remarquez que nous passons le texte en tant que variable dans l'invite dans l'extrait ci-dessus.

print(summary_completion.to_json())

La sortie contient le résumé du texte long par l'assistant, comme le montre cet extrait : 

"message": {
   "content": "Excellent comfort and quality, well-ventilated, quick-drying, lightweight boots, minimal perspiration, no foul smell.",
   "role": "assistant"
},

Réponse aux questions

Pour répondre aux questions (basées sur le texte d'entrée ci-dessus), nous modifions l'invite pour transmettre la question sous la forme d'une variable de type chaîne de caractères. Comme précédemment, l'invite comprend également le texte en tant que variable. Le modèle répond à la question sur la base du texte donné. 

question = 'Are these shoes heavy?'

qna_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for answering questions"
        },
        {
            "role": "user",
            "content": f"Answer this question: {question} in 10 words based on this text: {text}",
        },
    ],
)

Convertissez la sortie en JSON et imprimez-la :

print(qna_completion.to_json())

Le résultat comprend la réponse de l'assistant à la question :

"message": {
   "content": "Lightweight. Not heavy. Comfortable for long hikes. Well-ventilated Gore-tex material.",
   "role": "assistant"
},

Cas d'utilisation d'Azure OpenAI

Examinons maintenant les différents cas d'utilisation du service Azure OpenAI.

Traitement du langage naturel (NLP)

En tant que modèle de langage, les modèles à usage général de l'OpenAI, tels que GPT-3 et GPT-4, excellent dans les tâches NLP, telles que :

• Résumé de texte: Fournissez à l'API un texte volumineux en entrée et demandez-lui de le résumer en fonction de vos besoins. Dans l'exemple précédent, nous avons résumé le long commentaire d'un client en un résumé de 10 mots.
• Classification des textes: Étant donné un document (ou un ensemble de documents) et un ensemble d'étiquettes prédéfinies, OpenAI peut classer le(s) document(s) dans l'étiquette la plus appropriée. 
• Analyse des sentiments: L'API peut analyser un texte en entrée pour en évaluer le sentiment. Par exemple, il peut classer un avis de client comme positif, négatif ou neutre.

Dans l'exemple suivant, nous effectuons une analyse des sentiments pour classer le texte de l'avis du client (défini précédemment).

sentiment_classification = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for classifying customer reviews into one of the following categories: very positive, positive, neutral, negative, very negative"
        },
        {
            "role": "user",
            "content": f"Classify this review: {text}",
        },
    ],
    #max_tokens=16
)

print(sentiment_classification.to_json())

La sortie contient un extrait ressemblant à l'extrait ci-dessous. Il contient la classification de la révision par l'assistant :

"message": {
   "content": "This review can be classified as very positive.",
   "role": "assistant"
},

Génération de codes

Les modèles OpenAI peuvent générer du code dans différents langages de programmation. Les versions précédentes d'OpenAI disposaient de modèles spécifiques aux codes, tels que Codex et code-davinci, qui étaient adaptés à la génération de codes .

Cependant,les versions plus récentes d'OpenAI, telles que GPT-3.5 et GPT-4, génèrent du code sans ajustement. Les modèles de base sont pré-entraînés sur des ensembles de données basés sur le codage. Ainsi, Codex, code-davinci et de nombreux autres modèles hérités ont été supprimés et ne sont plus disponibles pour de nouveaux déploiements. 

Les modèles OpenAI peuvent aider à écrire du code dans divers langages de programmation courants. Interagir avec le modèle en langage naturel afin de donner des instructions pour des tâches de programmation telles que : 

• Générer le code: À partir d'un texte ou d'un commentaire, le modèle peut générer un extrait de code. Le programmeur peut combiner plusieurs de ces extraits pour en faire un programme fonctionnel. Cela permet d'automatiser les tâches répétitives telles que l'écriture de code standard. 
• Debug: Le modèle peut analyser les erreurs et les messages d'avertissement pour expliquer le problème en langage naturel et faire des suggestions sur la manière de le résoudre. 
• Optimisez: Les modèles OpenAI peuvent aider à remanier le code en structures plus propres et à utiliser des algorithmes plus efficaces pour des tâches courantes telles que le tri. 
• Expliquez: Les modèles OpenAI peuvent également expliquer les extraits de code qu'ils génèrent. Ces explications permettent d'adapter le code généré aux besoins du développeur. Ils peuvent également aider les nouveaux programmeurs à comprendre les concepts de programmation. 

Prenons un exemple simple d'écriture d'une fonction Python pour ouvrir et lire un fichier. Il s'agit d'une tâche assez courante qui peut être facilement automatisée. Nous demandons à OpenAI de générer et d'expliquer le code. Utilisez l' objet client créé précédemment.

code_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for generating programming code"
        },
        {
            "role": "user",
            "content": "Write and explain a Python function to open and read a file",
        },
    ],
)

Imprimez la sortie : 

print(code_completion.to_json())

Remarquez que l'objet JSON de sortie contient la sortie de l'assistant qui ressemble à l'extrait ci-dessous : 

"content": "Below is a Python function that opens a file, reads its contents, and returns the content as a string:\n\n```python\ndef read_file(file_path):\n    try:\n        with open(file_path, 'r') as file:\n …

Génération d'images avec DALL-E

Les exemples précédents étaient tous basés sur du texte. Ils ont utilisé OpenAI comme un grand modèle linguistique (LLM), qui est généralement construit à l'aide de l'architecture de transformateur. En plus des LLM, OpenAI inclut des modèles basés sur des diffuseurs, comme DALL-E, qui génèrent des images à partir d'un message d'entrée. 

Pour utiliser DALL-E, fournissez une invite textuelle avec une description détaillée de l'image que vous souhaitez voir. Sur la base de cette description, DALL-E génère une image de haute qualité. Cette fonction est utile pour des tâches telles que la création d'illustrations, la conception de produits, l'élaboration de croquis pour des campagnes de marketing, etc. 

DALL-E n'est pas encore disponible dans toutes les régions géographiques. S'il est disponible dans votre région, créez un nouveau déploiement (comme expliqué plus haut dans ce tutoriel) mais en utilisant le modèle DALL-E-3 au lieu de GPT-3. Accédez au modèle DALL-E en utilisant le même objet client que celui décrit précédemment. Utilisez la méthode client.images.generate() pour générer une image :

• Définissez le nom du modèle comme dalle3 à l'aide du paramètre model .
• Décrivez l'image souhaitée à l'aide du paramètre prompt .
• Vous pouvez également spécifier une valeur pour n, qui est le nombre d'images à générer.

result = client.images.generate(
    model="dalle3", 
    prompt="An owl wearing a Christmas hat",
    n=1
)

Extraire l'objet de réponse JSON de la réponse du modèle : 

import json
json_response = json.loads(result.model_dump_json())

Déclarez le répertoire de l'image. Notez que le répertoire images doit exister sous le répertoire de travail actuel (à partir duquel vous avez démarré le shell Python) .

image_dir = os.path.join(os.curdir, 'images')

Indiquez le chemin d'accès à l'image dans ce répertoire :

image_path = os.path.join(image_dir, 'generated_image.png')

Extraire l'URL de l'image générée à partir de l'objet de réponse JSON, télécharger l'image (en tant que flux) et l'écrire dans le fichier image :

image_url = json_response["data"][0]["url"]  
generated_image = requests.get(image_url).content  
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

Affichez l'image :

from PIL import Image

image = Image.open(image_path)
image.show()

Meilleures pratiques pour l'utilisation d'Azure OpenAI

L'utilisation du service Azure OpenAI est simple, mais comme pour toute technologie, il y a quelques bonnes pratiques à suivre pour en tirer le meilleur parti. Passons-les en revue dans cette section.

Suivi et gestion de l'utilisation de l'API

Azure OpenAI est l'un des services Azure les plus coûteux. Même les crédits gratuits disponibles pour les nouveaux comptes ne sont pas utilisables pour l'API OpenAI. Il est donc essentiel de procéder à un cursus d'utilisation, même pour les nouveaux utilisateurs. L'utilisation non contrôlée de l'API peut entraîner des factures d'un montant inattendu.

Les frais d'OpenAI sont basés sur l'utilisation et la consommation de jetons. Les jetons représentent des unités de texte traitées par le modèle, tant en entrée qu'en sortie. Le traitement d'un document textuel volumineux consomme plus de jetons que la génération d'une réponse plus longue. Plus vous utilisez de jetons, plus vous payez. Par conséquent, soyez économe avec les informations que vous donnez au modèle ou que vous lui demandez de générer. 

Utilisez le paramètre max_tokens pour limiter le nombre de jetons consommés dans cette demande. Pour les modèles de production, expérimentez pour déterminer le nombre de jetons dont vos demandes ou vos utilisateurs ont généralement besoin et limitez l'utilisation en conséquence. Augmentez la limite au cas par cas. 

Pour surveiller les paramètres de base :

• A partir de Azure AI Services | Azure OpenAI sélectionnez la ressource à surveiller.
• Sur la page des ressources, sélectionnez l'option Moniteur pour afficher diverses mesures, telles que le nombre de requêtes HTTP et le nombre de jetons traités par modèle et par déploiement.

Tableau de bord Azure OpenAI.

Vous pouvez également consulter des indicateurs plus détaillés :

• A partir de la page Surveillance dans le menu de gauche, sélectionnez Métriques.

Mesures détaillées d'Azure OpenAI.

• Dans la section Sélectionnez un champ d'application sélectionnez l'instance OpenAI (cochez la case)
• Sélectionnez Appliquer.

Sur les métriques vous pouvez consulter la page

• Sélectionnez la fenêtre temporelle en haut à droite. 
• Dans la barre de menus située en haut du graphique (initialement vide), sélectionnez la mesure appropriée dans le menu déroulantMetric. Vous avez le choix entre différentes mesures telles que :
• Demandes Azure OpenAI, 
• Statistiques sur l'utilisation des jetons (jetons actifs, jetons générés, etc.)
• Performance des appels API (temps de réponse au premier octet, etc.), et plus encore. 

Exemple de surveillance Azure OpenAI.

Enfin, fixez toujours des limites budgétaires pour les comptes API et configurez les paramètres pour recevoir des alertes par courrier électronique lorsque vous franchissez un seuil budgétaire. 

Affiner les modèles

Les modèles de base d'OpenAI sont entraînés sur d'énormes ensembles de données couvrant de nombreux domaines différents. D'une manière générale, il existe trois façons différentes d'obtenir les résultats souhaités à partir des modèles LLM : 

• Ingénierie rapide: Dans la plupart des cas, l'ajout d'instructions spécifiques à l'invite suffit. C'est ce qu'on appelle l'ingénierie rapide. 
• Apprentissage à quelques coups: Dans les cas où l'ingénierie de l'invite est insuffisante,ajoute quelques exemples à l'invite pour aider le modèle à comprendre les réponses souhaitées par l'utilisateur. C'est ce que l'on appelle l'apprentissage à partir de quelques exemples, dans lequel le modèle apprend sur la base d'un petit nombre d'exemples. 
• Affinage du site: Parfois, vous souhaitez discuter avec le modèle d'un domaine très spécialisé, par exemple d'un manuel de réparation d'équipement spécialisé. La production de textes sur ce sujet implique l'utilisation d'un jargon et de modèles linguistiques spécifiques au domaine, qui ne font probablement pas partie des ensembles de données publics (sur lesquels les modèles de base ont été entraînés). 

Vous pouvez affiner un modèle de base si l'apprentissage à quelques coups et l'ingénierie rapide ne permettent pas d'obtenir les bonnes réponses. 

Le réglage fin consiste à réentraîner un modèle de base pré-entraîné sur un ensemble de données spécialisé. Dans la pratique, seules quelques couches du modèle de base (et non le modèle entier) sont réentraînées sur les nouvelles données. Le tutoriel sur le réglage fin d'Azure explique les étapes du réglage fin d'un modèle OpenAI populaire. 

N'oubliez pas que pour affiner avec succès un modèle de base, vous avez besoin de grands volumes de données pertinentes et de haute qualité, avec des milliers d'exemples d'entraînement. En outre, le réglage fin implique invariablement des coûts initiaux importants pour former le modèle. En outre, le modèle affiné doit être hébergé à vos frais avant d'être déployé. 

Sécuriser vos clés API

Les clés d'API exposées publiquement peuvent être utilisées de manière abusive pour accéder à des informations sensibles, effectuer des tâches dangereuses et/ou illégales, ou faire des demandes non autorisées, ce qui entraîne une facture importante pour le propriétaire du compte. Il est donc essentiel de gérer les clés d'API de manière sécurisée plutôt que de les coder en dur dans le code source. Pour ce faire, plusieurs approches sont possibles : 

• Pour les services cloud, utilisez des outils de gestion des clés comme AWS Secrets Manager et Azure Key Vault.
• Utilisez les fichiers .env pour stocker les clés au format clé-valeur. Ajoutez ce fichier à la liste .gitignore pour vous assurer qu'il ne sera pas transféré dans le dépôt de code .
• Pour les services basés sur le bloc-notes Jupyter, utilisez l'option permettant de stocker les clés dans le cadre de l'environnement. Cette méthode a été décrite plus haut dans ce tutoriel. 

Je vous conseille de restreindre les autorisations pour lesquelles les clés peuvent être utilisées. Il est également utile de procéder à une rotation ou à une régénération périodique des clés afin que les anciennes clés ne puissent pas être utilisées à mauvais escient en cas de fuite.

Conclusion 

Dans ce tutoriel, nous avons abordé la création d'un compte Azure, la mise en place des services OpenAI, la création d'une nouvelle instance OpenAI et le déploiement d'un modèle. Nous avons ensuite vu des exemples d'utilisation de modèles OpenAI pour des tâches pratiques. Nous avons également expliqué comment surveiller l'utilisation et les performances des ressources Azure OpenAI. 

Pour une compréhension plus approfondie de Microsoft Azure, suivez le cursus DataCamp Azure Fundamentals. Pour en savoir plus sur les concepts fondamentaux de l'OpenAI, suivez le cursus DataCamp OpenAI Fundamentals.