Tutoriel de l'API GPT-4.5 : Commencer avec l'API d'OpenAI

Qu'est-ce que GPT 4.5 ?

GPT-4.5 est le dernier modèle linguistique d'OpenAI, conçu pour améliorer la fluidité des conversations, la connaissance du contexte et l'exactitude des faits. Il s'appuie sur les modèles précédents en offrant des réponses plus naturelles, une meilleure adaptation au ton et moins d'hallucinations. hallucinationsIl est donc bien adapté à des applications telles que les chatbots, la génération de contenu et l'automatisation des tâches.

Cependant, contrairement aux modèles de la série o d'OpenAI, le GPT-4.5 ne repose pas sur un raisonnement étape par étape, et n'est donc pas le meilleur choix pour la résolution de problèmes complexes dans des domaines tels que les mathématiques ou la programmation. Si vous avez besoin d'un modèle de raisonnement pour votre application, vous pouvez lire ce tutoriel sur OpenAI O1 API.

Pour un examen plus approfondi des points forts et des limites de GPT-4.5, ainsi que des comparaisons de performances, consultez notre analyse complète de GPT-4.5.

GPT-4.5 API : Comment se connecter à l'API d'OpenAI

Dans cette section, nous allons parcourir les étapes pour se connecter à l'API OpenAI, notamment la création d'une clé API et la configuration de votre environnement Python.

Création d'une clé API

Pour utiliser l'API OpenAI, nous devons créer une clé API. Cette clé est utilisée pour authentifier notre client Python auprès de l'API.

1. Naviguez jusqu'à la page page de la clé API OpenAI.

2. Vous devrez vous connecter ou créer un compte OpenAI si vous n'en avez pas déjà un.

3. Cliquez sur le bouton "Créer une nouvelle clé secret".

4. Vous pouvez lui donner un nom, mais il est préférable de laisser les options par défaut.

5. Cliquez sur le bouton "Créer une clé secrète".

6. Lorsque la clé s'affiche, copiez-la. Vous ne pourrez plus le revoir par la suite. Si vous le perdez, vous pouvez toujours le supprimer et en créer un nouveau.

7. Créez un fichier nommé .env dans le même dossier que celui où vous écrirez le code Python et collez-y la clé au format suivant :

OPENAI_API_KEY=<paste_your_key_here>

Prix de l'API

L'API OpenAI n'est pas gratuite. Selon le modèle que vous utilisez, vous devrez payer des frais différents. Tous les détails concernant les prix peuvent être trouvés sur leur page de tarification.

Ces frais sont différents des abonnements pour l'utilisation du ChatGPT sur son interface en ligne. Lorsque nous utilisons l'API, nous payons par message au lieu de payer un montant fixe chaque mois. Pour un usage régulier, il peut s'agir d'un moyen beaucoup plus économique d'accéder à leurs modèles.

Dans ce tutoriel, nous allons utiliser leur dernier modèle, GPT-4.5. Il s'agit du modèle généraliste le plus avancé.

Les prix ne sont pas fixés par message mais par jeton. Lorsque nous envoyons un message à un LLM, il est décomposé en jetons. Il n'existe pas de formule fiable pour convertir les mots en jetons, mais pour se faire une idée, on peut estimer qu'un jeton représente plus ou moins les 3/4 d'un mot.

Cela signifie que la tarification ci-dessus correspond approximativement à 750 000 mots. 

Pour utiliser l'API, nous devons ajouter des crédits à notre compte. Vous pouvez le faire sur la page de facturation d'OpenAI.

Configuration de l'environnement Python 

OpenAI fournit un client Python qui facilite l'interaction avec son API. Pour l'utiliser, nous devons l'installer, ainsi que quelques autres paquets pour nous aider à charger la clé que nous avons créée précédemment.

Nous utiliserons Anaconda pour créer un environnement Python afin d'installer les dépendances nécessaires. C'est une façon plus propre de procéder, car elle évite les conflits potentiels avec d'autres paquets Python que nous pourrions avoir.

Après avoir installé Anaconda, nous pouvons créer l'environnement à l'aide de la commande terminal :

conda create -n gpt45 -y python=3.9

Cette commande crée un environnement nommé gpt45 qui utilise la version 3.9 de Python. L'option -y est utilisée pour répondre automatiquement par l'affirmative à toutes les questions du processus de création.

Ensuite, nous activons l'environnement à l'aide de :

conda activate gpt45

Enfin, nous avons installé les dépendances nécessaires.

• pip install openai: Installez la bibliothèque OpenAI Python.
• pip install python-dovenv: Installez un paquet pour charger la clé API à partir du fichier .env que nous avons créé précédemment.

Faire notre première demande d'API

Nous sommes prêts à commencer à écrire du code Python pour effectuer des requêtes à l'API OpenAI.

Commencez par créer un fichier nommé script.py. C'est ici que nous allons écrire le code.

Ensuite, nous importons les paquets :

from openai import OpenAI
from dotenv import load_dotenv
import os

Ensuite, nous chargeons la clé API et initialisons le client :

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
client = OpenAI(api_key=api_key)

Enfin, nous envoyons un message. Pour commencer, nous enverrons simplement "Hello" :

completion = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=[
        {
            "role": "user",
            "content": "Hello"
        }
    ]
)
print(completion.choices[0].message.content)

Le paramètre model est utilisé pour spécifier le modèle que nous voulons utiliser. Pour essayer d'autres modèles, remplacez-le par un autre.

Nous pouvons exécuter le script en utilisant :

python script.py

Voici le résultat :

Hello! How can I help you today?

Créer un Chatbot GPT-4.5 avec Python

Dans cette section, nous allons nous appuyer sur notre script précédent pour créer un chatbot interactif qui nous permettra de parler avec GPT-4.5 dans le terminal.

Pour ce faire, nous devons modifier notre script en :

1. Prendre l'avis de l'utilisateur.
2. Gardez une trace de la conversation et envoyez les messages précédents ainsi que le nouveau cursus.
3. Répétez cette opération jusqu'à ce que l'utilisateur quitte le système.

Laisser l'utilisateur saisir une invite

Pour lire la saisie de l'utilisateur sur le terminal, nous utilisons la fonction input(). Lorsqu'il est appelé, il attend que l'utilisateur saisisse du texte et renvoie ce texte.

prompt = input("> ")
print(prompt)

Voici à quoi cela ressemble lorsque nous lançons le programme dans le terminal :

> Hello
Hello

La boucle de chat

Pour mettre en œuvre le chat, nous utiliserons une boucle qui s'exécute jusqu'à ce que l'invite soit égale à "exit". Il s'agit de la logique de la boucle principale :

while True:
  prompt = input("> ")
  if prompt == "exit":
    exit()
  # Prompt processing goes here

Traitement de l'invite

Le modèle ne conserve pas l'historique des messages que nous avons envoyés précédemment. Il traite chaque message comme s'il s'agissait d'un nouveau message. Par conséquent, pour obtenir un comportement de chat, nous devons fournir tous les messages qui ont été envoyés jusqu'à présent ainsi que la nouvelle invite. Nous y parvenons en conservant l'historique des discussions.

Les messages des utilisateurs doivent avoir le format suivant :

{
  "role": "user",
  "content": <user prompt>
}

La réponse du modèle doit avoir le rôle "assistant".

{
  "role": "assistant",
  "content": <model answer>
}

Dans cette optique, voici la mise en œuvre complète du chat :

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

client = OpenAI(api_key=api_key)

# Initialize the chat history
chat_history = []
while True:
    prompt = input("> ")
    if prompt == "exit":
        exit()
    # Add the user message to the chat history
    chat_history.append({
        "role": "user",
        "content": prompt,
    })
    # Send the full chat history
    completion = client.chat.completions.create(
        model="gpt-4.5-preview", messages=chat_history
    )
    # Display the answer
    answer = completion.choices[0].message.content
    print(answer)
    # Add the answer to the chat history
    chat_history.append({
        "role": "assistant",
        "content": answer,
    })

Exemple de chat

Pour essayer le chat, nous pouvons le lancer à l'aide de la commande :

python script.py

Ensuite, nous pouvons commencer à discuter en entrant notre message dans le terminal. Voici un exemple de chat :

L'exemple montre deux invites. Tout d'abord, nous demandons au modèle de nous montrer un exemple de boucle for en Python. Ensuite, pour vérifier que l'historique du chat est envoyé correctement, nous lui demandons de faire la même chose en Javascript.

Comme nous fournissons l'historique du chat, le mode peut comprendre ce que nous entendons par "faire la même chose" et nous donne un exemple de boucle for en Javascript.

Conclusion

Dans ce tutoriel, nous avons exploré comment configurer et discuter avec le modèle GPT-4.5 d'OpenAI à l'aide de Python. Nous avons appris à créer une clé API OpenAI et à l'utiliser dans notre environnement Python, ce qui nous permet d'interagir avec GPT-4.5 en dehors de la plateforme OpenAI basée sur l'abonnement.

Nous avons abordé la mise en place d'un environnement Python à l'aide d'Anaconda, l'installation des paquets nécessaires et la réalisation de notre première requête à l'API OpenAI.

Enfin, nous avons construit un chatbot interactif simple basé sur un terminal en conservant l'historique des conversations.