Explorer l'API OpenAI avec Python

Apprenons tous les services utiles d’OpenAI.

Qui n’a pas entendu parler d’OpenAI ? Le laboratoire de recherche en IA a changé le monde grâce à son célèbre produit, ChatGPT.

Cela a littéralement changé le paysage de la mise en œuvre de l’IA, et de nombreuses entreprises se précipitent désormais pour devenir la prochaine grande nouveauté.

Malgré une forte concurrence, OpenAI reste l'entreprise de référence pour tous les besoins commerciaux en matière d'IA générative, car elle dispose de l'un des meilleurs modèles et d'un support continu. La société propose de nombreux modèles d'IA générative de pointe avec diverses capacités de tâches : génération d'images, synthèse vocale et bien d'autres.

Tous les modèles proposés par OpenAI sont disponibles via des appels API. Avec du code Python simple, vous pouvez déjà utiliser le modèle.

Dans cet article, nous explorerons comment utiliser l'API OpenAI avec Python et diverses tâches que vous pouvez effectuer. J'espère que vous apprendrez beaucoup de cet article.

Configuration de l'API OpenAI

Pour suivre cet article, vous devez préparer quelques éléments.

La chose la plus importante dont vous avez besoin sont les clés API d'OpenAI, car vous ne pouvez pas accéder aux modèles OpenAI sans la clé. Pour acquérir l'accès, vous devez créer un compte OpenAI et demander la clé API sur la page du compte. Après avoir reçu la clé, enregistrez-la dans un endroit dont vous vous souviendrez, car elle n'apparaîtra plus dans l'interface OpenAI.

La prochaine chose que vous devez définir est d'acheter le crédit prépayé pour utiliser l'API OpenAI. Récemment, OpenAI a annoncé des changements dans le fonctionnement de sa facturation. Au lieu de payer à la fin du mois, nous devons acheter du crédit prépayé pour l'appel API. Vous pouvez visiter la page de tarification OpenAI pour estimer le crédit dont vous avez besoin. Vous pouvez également consulter leur page modèle pour comprendre de quel modèle vous avez besoin.

Enfin, vous devez installer le package OpenAI Python dans votre environnement. Vous pouvez le faire en utilisant le code suivant.

pip install openai

Ensuite, vous devez définir votre variable OpenAI Key Environment à l'aide du code ci-dessous.

import os

os.environ['OPENAI_API_KEY'] = 'YOUR API KEY'

Une fois tout réglé, commençons à explorer l’API des modèles OpenAI avec Python.

Générations de texte de l'API OpenAI

La star de l’API OpenAI est leur modèle Text Generations. Cette famille de grands modèles linguistiques peut produire une sortie de texte à partir de l'entrée de texte appelée invite. Les invites sont essentiellement des instructions sur ce que nous attendons du modèle, comme l'analyse de texte, la génération de brouillons de documents, et bien d'autres encore.

Commençons par exécuter un simple appel API Text Generations. Nous utiliserions le modèle GPT-3.5-Turbo d'OpenAI comme modèle de base. Ce n’est pas le modèle le plus avancé, mais les moins chers suffisent souvent pour effectuer des tâches liées au texte.

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Generate me 3 Jargons that I can use for my Social Media content as a Data Scientist content creator"}
  ]
)

print(completion.choices[0].message.content)

"Libérez la puissance de l'analyse prédictive pour prendre des décisions basées sur les données !"
"Plonger au plus profond de l'océan des données pour découvrir des informations précieuses."
"Transformer les données brutes en informations exploitables grâce à des algorithmes avancés."

L'appel d'API pour le modèle de génération de texte utilise le point de terminaison de l'API chat.completions pour créer la réponse textuelle à partir de notre invite.

Il existe deux paramètres requis pour la génération de texte : le modèle et les messages.

Pour le modèle, vous pouvez consulter la liste des modèles que vous pouvez utiliser sur la page du modèle associé.

Quant aux messages, on passe un dictionnaire avec deux couples : le rôle et le contenu. La clé de rôle spécifie l'expéditeur du rôle dans le modèle de conversation. Il existe 3 rôles différents : système, utilisateur et assistant.

En utilisant le rôle dans les messages, nous pouvons aider à définir le comportement du modèle et donner un exemple de la façon dont le modèle doit répondre à notre invite.

Étendons l'exemple de code précédent avec le rôle d'assistant pour donner des conseils sur notre modèle. De plus, nous explorerions certains paramètres du modèle de génération de texte afin d'améliorer leur résultat.

completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Generate me 3 jargons that I can use for my Social Media content as a Data Scientist content creator."},
        {"role": "assistant", "content": "Sure, here are three jargons: Data Wrangling is the key, Predictive Analytics is the future, and Feature Engineering help your model."},
        {"role": "user", "content": "Great, can you also provide me with 3 content ideas based on these jargons?"}
    ],
    max_tokens=150,
    temperature=0.7,
    top_p=1,
    frequency_penalty=0
)

print(completion.choices[0].message.content)

Bien sûr ! Voici trois idées de contenu basées sur les jargons fournis :

"Libérer la puissance du Data Wrangling : Un guide étape par étape pour les data scientists" – Créez un article de blog ou un didacticiel vidéo présentant les meilleures pratiques et les outils de data wrangling dans un projet de science des données réel.

"L'avenir de l'analyse prédictive : tendances et innovations en science des données" – Rédigez un article de leadership éclairé sur les tendances et technologies émergentes en matière d'analyse prédictive et sur la manière dont elles façonnent l'avenir de la science des données.

"Maîtriser l'ingénierie des fonctionnalités : techniques pour améliorer les performances des modèles" – Développer une série d'infographies ou de médias sociaux mettant en évidence différentes techniques d'ingénierie des fonctionnalités et leur impact sur l'amélioration de la précision et de l'efficacité des modèles d'apprentissage automatique.

Le résultat obtenu suit l’exemple que nous avons fourni au modèle. L'utilisation du rôle d'assistant est utile si nous souhaitons que le modèle suive un certain style ou un certain résultat.

Quant aux paramètres, voici des explications simples de chaque paramètre que nous avons utilisé :

max_tokens : ce paramètre définit le nombre maximum de mots que le modèle peut générer.
température : ce paramètre contrôle l'imprévisibilité de la sortie du modèle. Une température plus élevée donne des résultats plus variés et plus imaginatifs. La plage acceptable va de 0 à l’infini, bien que les valeurs supérieures à 2 soient inhabituelles.
top_p : également appelé échantillonnage de noyau, ce paramètre permet de déterminer le sous-ensemble de la distribution de probabilité à partir duquel le modèle tire sa sortie. Par exemple, une valeur top_p de 0,1 signifie que le modèle prend en compte uniquement les 10 % supérieurs de la distribution de probabilité pour l'échantillonnage. Ses valeurs peuvent aller de 0 à 1, des valeurs plus élevées permettant une plus grande diversité de sortie.
Frequency_penalty : cela pénalise les jetons répétés dans la sortie du modèle. La valeur de pénalité peut aller de -2 à 2, où les valeurs positives découragent la répétition des jetons, et les valeurs négatives font le contraire, encourageant l'utilisation répétée de mots. Une valeur de 0 indique qu'aucune pénalité n'est appliquée en cas de répétition.

Enfin, vous pouvez modifier la sortie du modèle au format JSON avec le code suivant.

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  response_format={ "type": "json_object" },
  messages=[
    {"role": "system", "content": "You are a helpful assistant designed to output JSON.."},
    {"role": "user", "content": "Generate me 3 Jargons that I can use for my Social Media content as a Data Scientist content creator"}
  ]
)

print(completion.choices[0].message.content)

{
"jargons": [
"Tirer parti de l'analyse prédictive pour obtenir des informations précieuses",
"Plonger dans les subtilités des algorithmes avancés d'apprentissage automatique",
"Exploiter la puissance du Big Data pour prendre des décisions fondées sur les données"
]
}

Le résultat est au format JSON et adhère à l'invite que nous avons saisie dans le modèle.

Pour une documentation complète sur l'API de génération de texte, vous pouvez les consulter sur leur page dédiée.

Générations d'images OpenAI

Le modèle OpenAI est utile pour les cas d'utilisation de génération de texte et peut également appeler l'API à des fins de génération d'images.

En utilisant le modèle DALL·E, nous pouvons générer une image comme demandé. Le moyen simple de l’exécuter consiste à utiliser le code suivant.

from openai import OpenAI
from IPython.display import Image

client = OpenAI()

response = client.images.generate(
  model="dall-e-3",
  prompt="White Piano on the Beach",
  size="1792x1024",
  quality="hd",
  n=1,
)

image_url = response.data[0].url
Image(url=image_url)

Pour les paramètres, voici les explications :

model : modèle de génération d'image à utiliser. Actuellement, l'API prend uniquement en charge les modèles DALL·E 3 et DALL·E 2.
invite : il s'agit de la description textuelle sur la base de laquelle le modèle générera une image.
taille : détermine la résolution de l'image générée. Il existe trois choix pour le modèle DALL·E 3 (1024x1024, 1024x1792 ou 1792x1024).
qualité : ce paramètre influence la qualité de l'image générée. Si du temps de calcul est nécessaire, « standard » est plus rapide que « hd. »
n : spécifie le nombre d'images à générer en fonction de l'invite. DALL·E 3 ne peut générer qu'une seule image à la fois. DALL·E 2 peut en générer jusqu'à 10 à la fois.

Il est également possible de générer une image de variation à partir de l'image existante, bien que cela ne soit disponible qu'avec le modèle DALL·E 2. L'API n'accepte également que les images PNG carrées de moins de 4 Mo.

from openai import OpenAI
from IPython.display import Image

client = OpenAI()

response = client.images.create_variation(
  image=open("white_piano_ori.png", "rb"),
  n=2,
  size="1024x1024"
)

image_url = response.data[0].url

Image(url=image_url)

L'image pourrait ne pas être aussi bonne que celle des générations DALL·E 3 car elle utilise l'ancien modèle.

Vision OpenAI

OpenAI est une entreprise leader qui fournit des modèles capables de comprendre la saisie d'images. Ce modèle est appelé modèle Vision, parfois appelé GPT-4V. Le modèle est capable de répondre aux questions compte tenu de l’image que nous avons donnée.

Essayons l'API du modèle Vision. Dans cet exemple, j'utiliserais l'image de piano blanc que nous générons à partir du modèle DALL·E 3 et la stockerais localement. De plus, je créerais une fonction qui prend le chemin de l'image et renvoie le texte de description de l'image. N'oubliez pas de remplacer la variable api_key par votre clé API.

from openai import OpenAI
import base64
import requests
def provide_image_description(img_path):

    client = OpenAI()

    api_key = 'YOUR-API-KEY'
    # Function to encode the image
    def encode_image(image_path):
      with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')
   
    # Path to your image
    image_path = img_path
   
    # Getting the base64 string
    base64_image = encode_image(image_path)
   
    headers = {
      "Content-Type": "application/json",
      "Authorization": f"Bearer {api_key}"
    }
   
    payload = {
      "model": "gpt-4-vision-preview",
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "text": """Can you describe this image? """
            },
            {
              "type": "image_url",
              "image_url": {
                "url": f"data:image/jpeg;base64,{base64_image}"
              }
            }
          ]
        }
      ],
      "max_tokens": 300
    }
   
    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)

    return response.json()['choices'][0]['message']['content']

Cette image présente un piano à queue placé sur une plage sereine. Le piano est blanc, indiquant une finition souvent associée à l'élégance. L'instrument est situé juste au bord du rivage, là où les douces vagues caressent légèrement le sable, créant une mousse qui touche juste la base du piano et du tabouret assorti. Les environs de la plage évoquent un sentiment de tranquillité et d'isolement avec un ciel bleu clair, des nuages duveteux au loin et une mer calme s'étendant jusqu'à l'horizon. Autour du piano sur le sable se trouvent de nombreux coquillages de différentes tailles et formes, soulignant la beauté naturelle et l'atmosphère sereine du cadre. La juxtaposition d'un instrument de musique classique dans un environnement naturel de plage crée une composition surréaliste et visuellement poétique.

Vous pouvez modifier les valeurs de texte dans le dictionnaire ci-dessus pour qu'elles correspondent aux exigences de votre modèle Vision.

Génération audio OpenAI

OpenAI fournit également un modèle pour générer de l'audio basé sur son modèle Text-to-Speech. Il est très simple à utiliser, même si le style de narration vocale est limité. En outre, le modèle prend en charge de nombreuses langues, que vous pouvez voir sur leur page de prise en charge linguistique.

Pour générer l'audio, vous pouvez utiliser le code ci-dessous.

from openai import OpenAI
client = OpenAI()

speech_file_path = "speech.mp3"
response = client.audio.speech.create(
  model="tts-1",
  voice="alloy",
  input="I love data science and machine learning"
)

response.stream_to_file(speech_file_path)

Vous devriez voir le fichier audio dans votre répertoire. Essayez d'y jouer et voyez s'il est à la hauteur de vos standards.

Actuellement, seuls quelques paramètres peuvent être utilisés pour le modèle Text-to-Speech :

model : le modèle de synthèse vocale à utiliser. Seuls deux modèles sont disponibles (tts-1 ou tts-1-hd), où tts-1 optimise la vitesse et tts-1-hd pour la qualité.
voice : le style de voix à utiliser où toute la voix est optimisée pour l'anglais. La sélection est alliage, écho, fable, onyx, nova et chatoyant.
response_format : le fichier au format audio. Actuellement, les formats pris en charge sont mp3, opus, aac, flac, wav et pcm.
speed : vitesse audio générée. Vous pouvez sélectionner des valeurs comprises entre 0,25 et 4.
input : le texte pour créer l'audio. Actuellement, le modèle ne prend en charge que 4 096 caractères maximum.

OpenAI Speech-to-Text

OpenAI fournit les modèles pour transcrire et traduire les données audio. En utilisant le modèle Whisper, nous pouvons transcrire l'audio de la langue prise en charge vers les fichiers texte et les traduire en anglais.

Essayons une simple transcription à partir du fichier audio que nous avons généré précédemment.

from openai import OpenAI
client = OpenAI()

audio_file= open("speech.mp3", "rb")
transcription = client.audio.transcriptions.create(
  model="whisper-1",
  file=audio_file
)

print(transcription.text)

J'adore la science des données et l'apprentissage automatique.

Il est également possible d'effectuer la traduction des fichiers audio vers la langue anglaise. Le modèle n’est pas encore disponible pour être traduit dans une autre langue.

from openai import OpenAI
client = OpenAI()

audio_file = open("speech.mp3", "rb")
translate = client.audio.translations.create(
  model="whisper-1",
  file=audio_file
)

Conclusion

Nous avons exploré plusieurs services modèles fournis par OpenAI, depuis les modèles de génération de texte, de génération d'images, de génération audio, de vision et de synthèse vocale. Chaque modèle a son paramètre API et ses spécifications que vous devez connaître avant de les utiliser.