Créez vos propres outils d’IA en Python à l’aide de l’API OpenAI —

Avec OpenAI prenant désormais en charge les modèles jusqu’à GPT-4 Turbo, les développeurs Python ont une incroyable opportunité d’explorer les fonctionnalités avancées d’IA. Ce didacticiel fournit un aperçu approfondi de la façon d’intégrer l’API ChatGPT dans vos scripts Python, vous guidant tout au long des étapes de configuration initiales et conduisant à une utilisation efficace de l’API.

L’API ChatGPT fait référence à l’interface de programmation qui permet aux développeurs d’interagir avec et d’utiliser des modèles GPT pour générer des réponses conversationnelles. Mais il s’agit en fait uniquement de l’API universelle d’OpenAI qui fonctionne pour tous leurs modèles.

Comme GPT-4 Turbo est plus avancé et trois fois moins cher que GPT-4, il n’y a jamais eu de meilleur moment pour exploiter cette puissante API en Python, alors commençons !

Configuration de votre environnement

Pour commencer, nous vous guiderons dans la configuration de votre environnement pour qu’il fonctionne avec l’API OpenAI en Python. Les étapes initiales comprennent l’installation des bibliothèques nécessaires, la configuration de l’accès à l’API, ainsi que la gestion des clés API et de l’authentification.

Installation des bibliothèques Python nécessaires

Avant de commencer, assurez-vous que Python est installé sur votre système. Nous vous recommandons d’utiliser un environnement virtuel pour que tout reste organisé. Vous pouvez créer un environnement virtuel avec la commande suivante :

python -m venv chatgpt_env

Activez l’environnement virtuel en exécutant :

• chatgpt_env\Scripts\activate (Les fenêtres)
• source chatgpt_env/bin/activate (macOS ou Linux)

Ensuite, vous devrez installer les bibliothèques Python requises, qui incluent la bibliothèque client OpenAI Python pour interagir avec l’API OpenAI et le package python-dotenv pour gérer la configuration. Pour installer les deux packages, exécutez la commande suivante :

pip install openai python-dotenv

Configuration de l’accès à l’API OpenAI

Pour faire une demande API OpenAI, vous devez d’abord vous inscrire sur la plateforme OpenAI et générer votre clé API unique. Suivez ces étapes:

1. Visitez OpenAI Page de clé API et créez un nouveau compte, ou connectez-vous si vous avez déjà un compte.
2. Une fois connecté, accédez à la section Clés API et cliquez sur Créer une nouvelle clé secrète.
3. Copiez la clé API générée pour une utilisation ultérieure. Sinon, vous devrez générer une nouvelle clé API si vous la perdez. Vous ne pourrez pas afficher les clés API via le site Web OpenAI.

Page des clés API d’OpenAI

Clé API générée qui peut être utilisée maintenant

Clé API et authentification

Après avoir obtenu votre clé API, nous vous recommandons de la stocker en tant que variable d’environnement pour des raisons de sécurité. Pour gérer les variables d’environnement, utilisez le package python-dotenv. Pour configurer une variable d’environnement contenant votre clé API, procédez comme suit :

1. Créez un fichier nommé .env dans le répertoire de votre projet.

2. Ajoutez la ligne suivante au .env fichier, remplacement your_api_key avec la clé API réelle que vous avez copiée plus tôt : CHAT_GPT_API_KEY=your_api_key.

3. Dans votre code Python, chargez la clé API depuis le .env fichier en utilisant le load_dotenv fonction du package python-dotenv :

  import openai
  from openai import OpenAI
  import os
  from dotenv import load_dotenv

  
  load_dotenv()
  client = OpenAI(api_key=os.environ.get("CHAT_GPT_API_KEY"))

Remarque : Dans la dernière version de la bibliothèque OpenAI Python, vous devez instancier un client OpenAI pour effectuer des appels d’API, comme indiqué ci-dessous. C’est un changement par rapport aux versions précédentesoù vous utiliseriez directement des méthodes globales.

Vous avez maintenant ajouté votre clé API et votre environnement est configuré et prêt à utiliser l’API OpenAI en Python. Dans les sections suivantes de cet article, nous explorerons l’interaction avec l’API et la création d’applications de chat à l’aide de cet outil puissant.

N’oubliez pas d’ajouter l’extrait de code ci-dessus à chaque section de code ci-dessous avant de l’exécuter.

Utiliser l’API OpenAI en Python

Après avoir chargé l’API depuis le .env fichier, nous pouvons réellement commencer à l’utiliser dans Python. Pour utiliser l’API OpenAI en Python, nous pouvons effectuer des appels API à l’aide de l’objet client. Nous pouvons ensuite transmettre une série de messages en entrée à l’API et recevoir un message généré par le modèle en sortie.

Création d’une simple requête ChatGPT

1. Assurez-vous d’avoir effectué les étapes précédentes : créer un environnement virtuel, installer les bibliothèques nécessaires et générer votre clé secrète OpenAI et .env fichier dans le répertoire du projet.

2. Utilisez l’extrait de code suivant pour configurer une requête ChatGPT simple :

  
  chat_completion = client.chat.completions.create(
      model="gpt-4",
      messages=[{"role": "user", "content": "query"}]
  )
  print(chat_completion.choices[0].message.content)

Ici, client.chat.completions.create est un appel de méthode sur le client objet. Le chat l’attribut accède aux fonctionnalités spécifiques au chat de l’API, et completions.create est une méthode qui demande au modèle d’IA de générer une réponse ou un achèvement basé sur l’entrée fournie.

Remplace le query avec l’invite que vous souhaitez exécuter, et n’hésitez pas à utiliser tout modèle GPT pris en charge au lieu du GPT-4 sélectionné ci-dessus.

Gestion des erreurs

Lors de l’envoi de requêtes, divers problèmes peuvent survenir, notamment des problèmes de connectivité réseau, des dépassements de limite de débit ou d’autres codes d’état de réponse non standard. Il est donc essentiel de gérer correctement ces codes d’état. Nous pouvons utiliser Python try et except blocs pour maintenir le flux du programme et une meilleure gestion des erreurs :

try:
    chat_completion = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "query"}],
        temperature=1,
        max_tokens=150  
    )
    print(chat_completion.choices[0].message.content)

except openai.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)

except openai.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")

except openai.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)

Remarque : vous devez avoir subventions de crédit disponibles pour pouvoir utiliser n’importe quel modèle de l’API OpenAI. Si plus de trois mois se sont écoulés depuis la création de votre compte, vos crédits gratuits ont probablement expiré et vous devrez acheter des crédits supplémentaires (un minimum de 5 $).

Voici maintenant quelques façons de configurer davantage vos requêtes API :

• Nombre maximum de jetons. Limitez la longueur de sortie maximale possible en fonction de vos besoins en réglant le max_tokens paramètre. Cela peut être une mesure d’économie, mais notez que cela empêche simplement le texte généré de dépasser la limite, sans pour autant raccourcir le résultat global.
• Température. Ajustez le paramètre de température pour contrôler le caractère aléatoire. (Des valeurs plus élevées rendent les réponses plus diversifiées, tandis que des valeurs plus faibles produisent des réponses plus cohérentes.)

Si un paramètre n’est pas défini manuellement, il utilise la valeur par défaut du modèle respectif, comme 0 à 7 et 1 pour GPT-3.5-turbo et GPT-4, respectivement.

Outre les paramètres ci-dessus, il existe de nombreux autres paramètres et configurations que vous pouvez effectuer pour utiliser les fonctionnalités de GPT exactement comme vous le souhaitez. Étudier Documentation de l’API d’OpenAI est recommandé à titre de référence.

Néanmoins, des invites efficaces et contextuelles sont toujours nécessaires, quel que soit le nombre de configurations de paramètres effectuées.

Techniques avancées d’intégration d’API

Dans cette section, nous explorerons les techniques avancées pour intégrer l’API OpenAI dans vos projets Python, en nous concentrant sur l’automatisation des tâches, l’utilisation des requêtes Python pour la récupération de données et la gestion des requêtes API à grande échelle.

Automatiser les tâches avec l’API OpenAI

Pour rendre votre projet Python plus efficace, vous pouvez automatiser diverses tâches à l’aide de l’API OpenAI. Par exemple, vous souhaiterez peut-être automatiser la génération de réponses par e-mail, les réponses du support client ou la création de contenu.

Voici un exemple de la façon d’automatiser une tâche à l’aide de l’API OpenAI :

def automated_task(prompt):
    try:
        chat_completion = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=250
        )
        return chat_completion.choices[0].message.content
    except Exception as e:
        return str(e)


generated_text = automated_task("Write an short note that's less than 50 words to the development team asking for an update on the current status of the software update")
print(generated_text)

Cette fonction accepte une invite et renvoie le texte généré en sortie.

Utiliser des requêtes Python pour la récupération de données

Vous pouvez utiliser le bibliothèque de demandes populaires pour interagir directement avec l’API OpenAI sans recourir à la bibliothèque OpenAI. Cette méthode vous donne plus de contrôle sur la requête get et une flexibilité sur vos appels API.

L’exemple suivant nécessite la bibliothèque de requêtes (si vous ne l’avez pas, exécutez pip install requests d’abord):

headers = {
    'Content-Type': 'application/json',
    'Authorization': f'Bearer {api_key}',
}

data = {
    'model': 'gpt-4',  
    'messages': [{'role': 'user', 'content': 'Write an interesting fact about Christmas.'}]
}

response = requests.post('https://api.openai.com/v1/chat/completions', headers=headers, json=data)
print(response.json())

Cet extrait de code montre l’envoi d’une requête POST à ​​l’API OpenAI, avec des en-têtes et des données comme arguments. La réponse JSON peut être analysée et utilisée dans votre projet Python.

Gestion des requêtes API à grande échelle

Lorsque vous travaillez sur des projets à grande échelle, il est important de gérer efficacement les requêtes API. Ceci peut être réalisé en incorporant des techniques telles que le traitement par lots, la limitation et la mise en cache.

• Traitement par lots. Combinez plusieurs requêtes en un seul appel API, à l’aide de l’outil n paramètre dans la bibliothèque OpenAI : n = number_of_responses_needed.
• Étranglement. Implémentez un système pour limiter la vitesse à laquelle les appels d’API sont effectués, en évitant une utilisation excessive ou une surcharge de l’API.
• Mise en cache. Stockez les résultats des requêtes API terminées pour éviter les appels redondants pour des invites ou des requêtes similaires.

Pour gérer efficacement les requêtes API, suivez votre utilisation et ajustez vos paramètres de configuration en conséquence. Pensez à utiliser le bibliothèque de temps pour ajouter des délais ou des délais d’attente entre les demandes si nécessaire.

L’application de ces techniques avancées dans vos projets Python vous aidera à tirer le meilleur parti de l’API OpenAI tout en garantissant une intégration API efficace et évolutive.

Applications pratiques : API OpenAI dans des projets du monde réel

L’intégration de l’API OpenAI dans vos projets réels peut offrir de nombreux avantages. Dans cette section, nous aborderons deux applications spécifiques : l’intégration de ChatGPT dans le développement Web et la création de chatbots avec ChatGPT et Python.

Intégrer ChatGPT dans le développement Web

L’API OpenAI peut être utilisée pour créer du contenu interactif et dynamique adapté aux requêtes ou aux besoins des utilisateurs. Par exemple, vous pouvez utiliser ChatGPT pour générer des descriptions de produits personnalisées, créer des articles de blog attrayants ou répondre aux questions courantes sur vos services. Avec la puissance de l’API OpenAI et un peu de code Python, les possibilités sont infinies.

Considérez cet exemple simple d’utilisation d’un appel API à partir d’un backend Python :

def generate_content(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return str(e)


description = generate_content("Write a short description of a hiking backpack")

Vous pouvez alors également écrire du code pour intégrer description avec votre HTML et JavaScript pour afficher le contenu généré sur votre site Web.

Créer des chatbots avec ChatGPT et Python

Les chatbots alimentés par l’intelligence artificielle commencent à jouer un rôle important dans l’amélioration de l’expérience utilisateur. En combinant les capacités de traitement du langage naturel de ChatGPT avec Python, vous pouvez créer des chatbots qui comprennent le contexte et répondent intelligemment aux entrées des utilisateurs.

Considérez cet exemple pour traiter les entrées de l’utilisateur et obtenir une réponse :

def get_chatbot_response(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return str(e)


user_input = input("Enter your prompt: ")
response = get_chatbot_response(user_input)
print(response)

Mais comme il n’y a pas de boucle, le script se terminera après une seule exécution, pensez donc à ajouter une logique conditionnelle. Par exemple, nous avons ajouté une logique conditionnelle de base dans laquelle le script continuera à rechercher les invites de l’utilisateur jusqu’à ce que l’utilisateur prononce la phrase vide « quitter » ou « quitter ».

Compte tenu de la logique mentionnée, notre code final complet pour exécuter un chatbot sur le point de terminaison de l’API OpenAI pourrait ressembler à ceci :

from openai import OpenAI
import os
from dotenv import load_dotenv


load_dotenv()
client = OpenAI(api_key=os.environ.get("CHAT_GPT_API_KEY"))

def get_chatbot_response(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return str(e)

while True:
    user_input = input("You: ")
    if user_input.lower() in ["exit", "quit"]:
        print("Chat session ended.")
        break
    response = get_chatbot_response(user_input)
    print("ChatGPT:", response)

Voici à quoi cela ressemble lorsqu’il est exécuté dans l’invite de commande Windows.

Espérons que ces exemples vous aideront à commencer à expérimenter l’IA ChatGPT. Dans l’ensemble, OpenAI a ouvert d’énormes opportunités aux développeurs pour créer de nouveaux produits passionnants à l’aide de leur API, et les possibilités sont infinies.

Limites et tarifs de l’API OpenAI

Bien que l’API OpenAI soit puissante, il existe quelques limitations :

• Stockage de données. OpenAI conserve vos données API pendant 30 jours et l’utilisation de l’API implique le consentement au stockage des données. Soyez attentif aux données que vous envoyez.

• Capacité du modèle. Les modèles de chat ont une limite maximale de jetons. (Par exemple, GPT-3 prend en charge 4 096 jetons.) Si une requête API dépasse cette limite, vous devrez tronquer ou omettre le texte.

• Tarifs. L’API OpenAI n’est pas disponible gratuitement et suit son propre système de tarification, distinct des frais d’abonnement du modèle. Pour plus d’informations sur les prix, reportez-vous à Détails des tarifs d’OpenAI. (Encore une fois, GPT-4 Turbo est trois fois moins cher que GPT-4 !)

Conclusion

Explorer le potentiel de l’API du modèle ChatGPT en Python peut apporter des avancées significatives dans diverses applications telles que le support client, les assistants virtuels et la génération de contenu. En intégrant cette puissante API dans vos projets, vous pouvez exploiter les capacités des modèles GPT de manière transparente dans vos applications Python.

Si vous avez apprécié ce tutoriel, vous apprécierez peut-être également ceux-ci :