Comment intégrer les modèles OpenAI GPT dans votre projet Django

L’auteur a sélectionné le Programme d’Aide Directe pour recevoir un don dans le cadre du programme Write for Donations.

Introduction

Les modèles OpenAI GPT ont gagné en popularité en raison de leur large utilisation dans la génération de contenu textuel pour diverses tâches telles que la rédaction d’e-mails, la réponse à des FAQ de service client et la traduction de langues, pour n’en citer que quelques-unes.

Ces modèles GPT sont généralement utilisés via ChatGPT, un chatbot publié par OpenAI, ou via des API et des bibliothèques qui offrent un plus grand contrôle. Ce tutoriel vous guidera sur la manière de tirer parti de ces modèles en utilisant l’API OpenAI dans votre projet web Django. Vous apprendrez comment appeler l’API de complétion de chat en utilisant différents paramètres et comment formater et utiliser ses réponses.

À la fin de ce tutoriel, vous aurez créé un point de terminaison Django qui, lorsqu’il est appelé, envoie une demande à OpenAI pour construire une courte histoire en utilisant les mots fournis et renvoie sa réponse.

Prérequis

Pour compléter ce tutoriel, vous aurez besoin de:

1. Un projet Django existant. Si vous partez de zéro, vous pouvez configurer un projet Django en suivant le tutoriel sur comment configurer un environnement de développement Django.

2. Un compte OpenAI : Rendez-vous sur le site web de la plateforme OpenAI et recherchez le bouton « S’inscrire ». Après vous être inscrit, vous devez vérifier votre adresse e-mail et saisir des informations personnelles.

3. Une clé API OpenAI : Une fois votre compte configuré, connectez-vous et accédez à la section Clés API depuis votre tableau de bord. Cliquez sur « Créer une nouvelle clé secrète ». Votre clé API sera générée et ressemblera à quelque chose comme sk-abcdefghijklmnop. Assurez-vous de sauvegarder cette clé dans un endroit sécurisé, car vous ne pourrez pas la voir à nouveau.

4. Le package Python OpenAI : Si vous avez suivi le tutoriel dans le premier prérequis, vous devriez déjà avoir un environnement virtuel nommé env actif dans un répertoire nommé django-apps. Assurez-vous que votre environnement virtuel est actif en confirmant que son nom apparaît entre parenthèses au début de votre invite de terminal. S’il n’est pas actif, vous pouvez l’activer manuellement en exécutant la commande :

sammy@ubuntu:$ .env/bin/activate

Dans votre terminal depuis le répertoire django-apps. Une fois votre environnement activé, exécutez ce qui suit pour installer le package Python OpenAI :

(env)sammy@ubuntu:$ pip install openai

Étape 1 — Faire des appels à OpenAI

À cette étape, vous ajouterez votre clé d’API OpenAI au client OpenAI et effectuerez un appel API simple à l’API ChatCompletion. Vous examinerez également la réponse que vous recevez de l’API.

Pour commencer, ouvrez votre interpréteur Python :

(env)sammy@ubuntu:$ python

Tout d’abord, importez le client OpenAI et ajoutez votre clé d’API au client :

from openai import OpenAI
client = OpenAI(api_key="your-api-key")

Remplacez "votre-clé-d'API" par la clé d’API réelle que vous avez obtenue sur la plateforme OpenAI.

Maintenant, faisons un appel API à l’API ChatCompletion. Utilisez la méthode chat.completions.create() :

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "count 1 to 10"}])

Dans le code ci-dessus, nous avons spécifié le modèle à utiliser comme gpt-3.5-turbo, ajouté un unique objet message contenant le rôle utilisateur (les autres options sont système et assistant) et le contenu / la requête compter de 1 à 10.

Pour voir la réponse de l’appel API, vous pouvez imprimer le message de réponse, qui devrait contenir les nombres de 1 à 10 dans une jolie petite liste :

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

Sortie :

Output
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Félicitations ! Vous avez réussi à faire un appel API simple à OpenAI et à récupérer une réponse. Nous formaterons et utiliserons la réponse de l’API pour créer une courte histoire dans les prochaines étapes.

Étape 2 — Travailler avec des paramètres

Maintenant que vous avez réussi à effectuer un appel API simple vers l’API de ChatCompletion, explorons comment travailler avec des paramètres pour personnaliser le comportement du modèle. Il existe plusieurs paramètres disponibles qui vous permettent de contrôler la génération de texte. Nous examinerons les trois ci-dessous.

1. Température: Le paramètre de température détermine le degré d’aléatoire du contenu généré. Une valeur de température plus élevée, comme 0,8, donnera des réponses plus diverses et créatives, tandis qu’une valeur de température plus faible, comme 0,1, produira des réponses plus similaires. Par exemple:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Essayons à nouveau temperature=0,1 pour voir le texte nouvellement généré:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Le texte s’est avéré être le même. Maintenant, essayons temperature=0,8 deux fois:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)
cat, apple, guitar, sky, book
response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)

Output
1. Apple
2. Sunshine
3. Happiness
4. Love
5. Technology

2. Max tokens: Cela vous permet de limiter la longueur du texte généré. En définissant une valeur spécifique, vous vous assurez que la réponse ne dépasse pas un certain nombre de tokens. Les tokens sont proportionnels au nombre de mots dans la réponse. Par exemple:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=10)
print(response.choices[0].message.content)

Output
1. Apple
2. Car

Changement de la valeur à 20:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=20)
print(response.choices[0].message.content)

Output
1. Apple
2. Car
3. Music
4. Ocean
5. Love

3. Stream: Cela détermine si les réponses doivent être diffusées en continu ou renvoyées. Lorsqu’il est défini sur Vrai, la réponse de l’API sera diffusée, ce qui signifie que vous recevrez la sortie par petits morceaux au fur et à mesure de sa génération. C’est utile pour les longues conversations ou les applications en temps réel. Pour activer la diffusion, ajoutez le paramètre stream avec une valeur de Vrai à l’appel API. Par exemple:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], stream=True)
collected_messages = []
for chunk in response:
...   chunk_message = chunk.choices[0].delta.content
...   if chunk_message is not None:
...     collected_messages.append(chunk_message)
print(collected_messages)

Output
['', 'cat', '\n', 'book', '\n', 'computer', '\n', 'sun', '\n', 'water']

Dans le code ci-dessus, la variable chunk_message contient le contenu du message dans chaque fragment renvoyé par l’API. Avant de l’ajouter à la liste collected_messages, nous vérifions si le fragment est None car le contenu du dernier fragment est généralement None.

En utilisant ces paramètres, vous pouvez personnaliser le comportement du modèle et contrôler les réponses générées pour mieux adapter votre application ou projet. Expérimentez avec différentes valeurs pour obtenir les résultats souhaités.

Dans la prochaine étape, nous fournirons un contexte au modèle sous la forme d’un message système.

Étape 3 — Création d’un message système

Dans cette étape, nous allons combiner toutes les informations que nous avons apprises et créer un message système qui donne du contexte au modèle GPT, en lui indiquant son objectif et en spécifiant ses règles.

Tout d’abord, créons un module Python contenant une fonction pour gérer cette tâche. Fermez l’interpréteur et créez un nouveau fichier appelé story_generator.py dans le répertoire de votre projet Django.

(env)sammy@ubuntu:$ touch ~/my_blog_app/blog/blogsite/story_generator.py

Ensuite, vous pouvez ajouter la clé API OpenAI à vos variables d’environnement afin de ne pas l’ajouter directement au fichier Python:

(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"

Ouvrez story_generator.py et à l’intérieur, créez un client OpenAI et définissez une fonction appelée generate_story qui prend une collection de mots en entrée:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # Appeler l'API OpenAI pour générer l'histoire
    response = get_short_story(words)
    # Formater et renvoyer la réponse
    return format_response(response)

Dans cette fonction, nous appelons une fonction séparée, get_short_story, pour effectuer l’appel API à OpenAI pour l’histoire, puis une autre fonction, format_response, pour formater la réponse de l’API.

Maintenant, concentrons-nous sur la fonction get_short_story. Ajoutez ce qui suit à la fin de votre fichier story_generator.py:

def get_short_story(words):
    # Construire la sollicitation système
    system_prompt = f"""You are a short story generator.
    Write a short story using the following words: {words}.
    Do not go beyond one paragraph."""
    # Faire l'appel API
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{
            "role": "user",
            "content": system_prompt
        }],
        temperature=0.8,
        max_tokens=1000
    )

    # Renvoyer la réponse de l'API
    return response

Dans cette fonction, nous configurons d’abord la sollicitation système, qui informe le modèle de la tâche qu’il doit effectuer et spécifie la longueur de l’histoire. Nous passons ensuite cette sollicitation système à l’API ChatCompletion et renvoyons sa réponse.

Enfin, nous pouvons implémenter la fonction format_response. Ajoutez ce qui suit à la fin de votre fichier story_generator.py:

def format_response(response):
    # Extraire l'histoire générée de la réponse
    story = response.choices[0].message.content
    # Supprimer tout texte ou formatage indésirable
    story = story.strip()
    # Renvoyer l'histoire formatée
    return story

Vous pouvez maintenant tester ces fonctions en appelant la fonction generate_story, en passant une collection de mots comme argument, et en imprimant sa réponse. Ajoutez ce qui suit en bas de votre fichier story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Enregistrez maintenant et quittez le fichier. Exécutez le script pour voir l’histoire générée:

(env) sammy@ubuntu:$ python ~/my_blog_app/blog/blogsite/story_generator.py

Résultat:

In a cozy corner of a sunlit room, a fluffy cat named Whiskers lounged lazily next to a towering bookshelf. Amongst the rows of books, a curious computer hummed softly. As the sun streamed through the window, casting a warm glow, Whiskers noticed a small water stain on the shelf. Intrigued, the cat pawed at the book closest to the mark. As if guided by fate, the book opened to reveal a hidden compartment containing a glittering diamond necklace. With the secret now unveiled, Whiskers embarked on an unexpected adventure, where the sun, water, and the power of knowledge merged into a thrilling tale of mystery and discovery.

Plutôt intéressant ! Supprimons la ligne avec l’instruction print puisque nous allons appeler la fonction generate_story depuis une vue Django. Retirez la ligne surlignée de votre fichier story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

N’hésitez pas à expérimenter avec le prompt système et à ajouter plus de contexte et de règles pour améliorer les histoires générées.

Continuez à l’étape suivante pour intégrer le module story_generator dans votre projet Django.

Étape 4 – Intégration avec une vue back-end :

Vous devez créer une vue Django et une route URL pour intégrer le module story_generator dans votre projet Django. Dans la vue, vous extraierez les mots attendus de la requête, appellerez la fonction generate_story et retournerez la réponse.

Tout d’abord, ouvrez le fichier views.py dans le répertoire de votre application Django. Importez les modules nécessaires et ajoutez une fonction de vue appelée generate_story_from_words:

from django.http import JsonResponse
from .story_generator import generate_story

def generate_story_from_words(request):
    words = request.GET.get('words') # Extraire les mots attendus de la requête
    story = generate_story(words) # Appeler la fonction generate_story avec les mots extraits
    return JsonResponse({'story': story}) # Retourner l'histoire sous forme d'une réponse JSON

Ensuite, ouvrez le fichier urls.py et ajoutez un modèle d’URL pour la vue generate_story_from_words:

urlpatterns = [
    # Autres modèles d'URL...
    path('generate-story/', views.generate_story_from_words, name='generate-story'),
]

Maintenant, vous pouvez demander l’endpoint /generate-story/. Par exemple, pour tester avec curl, vous pouvez effectuer une requête GET à l’endpoint avec les mots attendus comme paramètre de requête. Ouvrez votre terminal et exécutez la commande suivante:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words=cat,book,computer,sun,water"

Assurez-vous de remplacer "http://votre_domaine" par le domaine réel où votre projet Django est hébergé. Les mots "chat, livre, ordinateur, soleil, eau" représentent les mots attendus avec lesquels vous souhaitez générer une histoire. Vous pouvez les changer par n’importe quels mots que vous préférez.

Après avoir exécuté la commande, vous devriez voir la réponse du serveur, qui contiendra l’histoire générée:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words="cat,book,computer,sun,water"

Sortie:

{"story": "Once upon a time, in a cozy little cottage nestled amidst a dense forest, a curious cat named Whiskers sat by the window, basking in the warm rays of the sun. As Whiskers lazily flicked his tail, his eyes caught sight of a dusty book lying on a nearby shelf. Intrigued, he carefully jumped onto the shelf, causing a cascade of books to tumble down, one opening up to reveal a hidden compartment. Inside, Whiskers discovered an ancient computer, its screen flickering to life as he brushed against the power button. Mesmerized by the glowing screen, Whiskers ventured into a world of virtual landscapes, where he roamed freely, chasing digital fish and pausing to admire breathtaking waterfalls. Lost in this newfound adventure, Whiskers discovered the wonders of both the tangible and virtual worlds, realizing that true exploration knows no bounds."}

Conclusion

Après avoir terminé ce tutoriel, vous avez appris comment intégrer les modèles OpenAI GPT dans votre projet Django en utilisant l’API OpenAI. Vous avez effectué des appels à l’API ChatCompletion, personnalisé le comportement du modèle en travaillant avec des paramètres tels que la température et le nombre maximal de jetons, et créé un système de suggestion pour fournir un contexte au modèle. Vous avez également intégré le module story_generator dans votre projet Django. Maintenant, vous pouvez générer des nouvelles en demandant l’endpoint /generate-story/ avec les mots attendus comme paramètre de requête.

Pour améliorer davantage votre projet Django, vous pouvez explorer les fonctionnalités supplémentaires de l’API OpenAI et expérimenter avec différents systèmes de suggestion et paramètres pour générer des histoires uniques et créatives.