Début avec les sorties structurées OpenAI

En août 2024, Openai a annoncé une nouvelle fonctionnalité puissante dans leurs sorties structurées. Avec cette fonctionnalité, comme son nom l'indique, vous pouvez vous assurer que LLMS générera des réponses uniquement dans le format que vous spécifiez. Cette capacité facilitera la création d'applications qui nécessitent une mise en forme précise des données. 

Dans ce didacticiel, vous apprendrez à démarrer avec les sorties structurées OpenAI, à comprendre sa nouvelle syntaxe et à explorer ses applications clés.

Importance des sorties structurées dans les applications AI

Les réponses déterministes, ou, en d'autres termes, les réponses en formatage cohérent, sont cruciales pour de nombreuses tâches telles que la saisie des données, la récupération des informations, la réponse aux questions, les flux de travail en plusieurs étapes, etc. Vous avez peut-être vécu comment les LLM peuvent générer des sorties dans des formats sauvagement différents, même si l'invite est la même.

Par exemple, considérez cette simple fonction Classify_Sentiment alimentée par GPT-4O:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Sortie:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Même si les deux premières réponses étaient dans le même format unique, la dernière est une phrase entière. Si une autre application en aval dépendait de la sortie du code ci-dessus, il aurait écrasé car il aurait été attendu d'une réponse à un seul mot.

Nous pouvons résoudre ce problème avec une ingénierie rapide, mais c'est un processus itératif qui prend du temps. Même avec une invite parfaite, nous ne pouvons pas être sûrs à 100% que les réponses seront conformes à notre format dans les demandes futures. À moins, bien sûr, que nous n'utilisons des sorties structurées:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Sortie:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Avec la nouvelle fonction, classify_sentiment_with_structured_output, les réponses sont toutes dans le même format.

Cette capacité de forcer les modèles de langage dans un format rigide est significative, ce qui vous permet d'économiser d'innombrables heures d'ingénierie rapide ou de recours à d'autres outils open source.

Début avec les sorties structurées OpenAI

Dans cette section, nous décomposons les sorties structurées en utilisant l'exemple de la fonction d'analyseur de sentiment.

Configuration de votre environnement

Prérequis

Avant de commencer, assurez-vous d'avoir ce qui suit:

• python 3.7 ou ultérieurement installé sur votre système.
• une clé API OpenAI. Vous pouvez l'obtenir en vous inscrivant sur le site Web d'Openai.

Configuration de l'API OpenAI

1. Installez le package Openai Python: ouvrez votre terminal et exécutez la commande suivante pour installer ou mettre à jour le package Openai Python dans la dernière version:

$ pip install -U openai

2. Configurez votre clé API: vous pouvez définir votre clé API en tant que variable d'environnement ou directement dans votre code. Pour le définir comme une variable d'environnement, exécutez:

$ export OPENAI_API_KEY='your-api-key'

3. Vérifiez l'installation: créez un script Python simple pour vérifier l'installation:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Exécutez le script pour vous assurer que tout est configuré correctement. Vous devriez voir la réponse du modèle imprimé dans le terminal.

En plus du package OpenAI, vous aurez besoin de la bibliothèque pyndante pour définir et valider les schémas JSON pour les sorties structurées. L'installez en utilisant PIP:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Avec ces étapes, votre environnement est maintenant configuré pour utiliser la fonction de sortie structurée d'Openai.

Définition d'un schéma de sortie à l'aide de pyndantique

Pour utiliser des sorties structurées, vous devez définir la structure de sortie attendue à l'aide de modèles pydantiques. Pydontic est une bibliothèque de validation des données et de gestion des paramètres pour Python, qui vous permet de définir des modèles de données à l'aide d'annotations de type Python. Ces modèles peuvent ensuite être utilisés pour appliquer la structure des sorties générées par les modèles d'Openai.

Voici un exemple de modèle pydatique pour spécifier le format de notre classificateur de sentiment de revue:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Dans cet exemple:

• SentimentResponse est un modèle pydatique qui définit la structure attendue de la sortie.
• Le modèle a un seul sentiment sur le terrain, qui ne peut prendre qu'une des trois valeurs littérales: "positive", "négative" ou "neutre".

Lorsque nous passons ce modèle dans le cadre de nos demandes d'API OpenAI, les sorties ne seront que l'un des mots que nous avons fournis.

Voyons comment.

Utilisation de l'assistant d'analyse

Pour appliquer notre schéma pyndante dans les demandes OpenAI, tout ce que nous avons à faire est de le transmettre au paramètre Response_Format de l'API de Chat Completion. En gros, voici à quoi il ressemble:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Si vous remarquez, au lieu d'utiliser client.chat.completions.create, nous utilisons la méthode client.beta.chat.completions.parse. .Parse () est une nouvelle méthode dans l'API de complétion de chat spécifiquement écrite pour les sorties structurées.

Maintenant, assemblons tout en réécrivant le classificateur de sentiment d'avis avec des sorties structurées. Tout d'abord, nous faisons les importations nécessaires, définissons le modèle pydante, l'invite du système et un modèle invite:

$ pip install -U openai

Ensuite, nous écrivons une nouvelle fonction qui utilise la méthode d'assistance .parse ():

$ export OPENAI_API_KEY='your-api-key'

La ligne importante de la fonction est Response_Format = SentimentResponse, ce qui permet réellement les sorties structurées.

Testons-le sur l'une des critiques:

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
   model="gpt-4o-mini",
   messages=[
       {"role": "system", "content": "You are a helpful assistant."},
       {"role": "user", "content": "Say hello!"}
   ],
   max_tokens=5
)
>>> print(response.choices[0].message.content.strip())
Hello! How can I

Ici, le résultat est un objet de message:

$ pip install pydantic

En dehors de son attribut .Content, qui récupère la réponse, il a un attribut .parsé qui renvoie les informations analysées en classe:

from pydantic import BaseModel
from typing import Literal
class SentimentResponse(BaseModel):
   sentiment: Literal["positive", "negative", "neutral"]

Comme vous pouvez le voir, nous avons une instance de la classe SentimentResponse. Cela signifie que nous pouvons accéder au sentiment en tant que chaîne au lieu d'un dictionnaire en utilisant l'attribut .Sentiment:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Modèles pydatiques nicheurs pour définir des schémas complexes

Dans certains cas, vous devrez peut-être définir des structures de sortie plus complexes qui impliquent des données imbriquées. Pydontic vous permet de nidifier les modèles les uns dans les autres, vous permettant de créer des schémas complexes qui peuvent gérer une variété de cas d'utilisation. Ceci est particulièrement utile lorsque vous traitez des données hiérarchiques ou lorsque vous devez appliquer une structure spécifique pour les sorties complexes.

Voyons un exemple où nous devons extraire des informations utilisateur détaillées, y compris leur nom, les coordonnées et une liste d'adresses. Chaque adresse doit inclure des champs pour la rue, la ville, l'État et le code postal. Cela nécessite plus d'un modèle pydatique pour construire le schéma correct.

Étape 1: Définissez les modèles pydatiques

Tout d'abord, nous définissons les modèles pydantes pour l'adresse et les informations de l'utilisateur:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Dans cet exemple:

• Adresse est un modèle pydatique qui définit la structure d'une adresse.
• UserInfo est un modèle pydatique qui comprend une liste d'objets d'adresse, ainsi que des champs pour le nom, le courrier électronique et le numéro de téléphone de l'utilisateur.

Étape 2: Utilisez les modèles pydatiques imbriqués dans les appels API

Ensuite, nous utilisons ces modèles pydatiques imbriqués pour appliquer la structure de sortie dans un appel API OpenAI:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

L'exemple de texte est totalement illisible et manque d'espaces entre des informations clés. Voyons si le modèle réussit. Nous utiliserons la bibliothèque JSON pour emporter la réponse:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Comme vous pouvez le voir, le modèle a correctement capturé les informations d'un seul utilisateur ainsi que leurs deux adresses distinctes basées sur notre schéma fourni.

En bref, en nichant des modèles pydatiques, vous pouvez définir des schémas complexes qui gérent les données hiérarchiques et appliquer des structures spécifiques pour les sorties complexes.

Fonction appelant avec des sorties structurées

L'une des fonctionnalités répandues des modèles de langage plus récents est les appels de fonction (également appelés appels à outils). Cette capacité vous permet de connecter des modèles de langage aux fonctions définies par l'utilisateur, ce qui leur donnait efficacement un accès (modèles) au monde extérieur.

Certains exemples courants sont:

• Récupération des données en temps réel (par exemple, temps, cours des actions, scores sportifs)
• effectuer des calculs ou une analyse des données
• Interroger des bases de données ou des API
• générer des images ou d'autres médias
• Traduction de texte entre les langues
• Contrôle des appareils domestiques intelligents ou des systèmes IoT
• Exécution de la logique commerciale ou des workflows personnalisés

Nous n'entrerons pas dans les détails du fonctionnement de l'appel de la fonction ici, mais vous pouvez lire notre tutoriel d'appel de fonction Openai.

Ce qui est important à savoir, c'est qu'avec des sorties structurées, l'utilisation d'appels de fonction avec des modèles OpenAI devient tellement plus facile. Dans le passé, les fonctions que vous adopteriez aux modèles OpenAI nécessiteraient d'écrire des schémas JSON complexes, décrivant chaque paramètre de fonction avec des conseils de type. Voici un exemple:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Même si la fonction get_current_weather a deux paramètres, son schéma JSON devient énorme et sujet aux erreurs pour écrire manuellement.

Ceci est résolu dans les sorties structurées en utilisant à nouveau des modèles pydantes:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Tout d'abord, vous écrivez la fonction elle-même et sa logique. Ensuite, vous le définissez à nouveau avec un modèle pydatique spécifiant les paramètres d'entrée attendus.

Ensuite, pour convertir le modèle pydante en un schéma JSON compatible, vous appelez pydantic_function_tool:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Voici comment utiliser cet outil dans le cadre d'une demande:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Nous passons le modèle pydantique dans un format JSON compatible au paramètre des outils de l'API de complétion de chat. Ensuite, selon notre requête, le modèle décide d'appeler ou non l'outil.

Puisque notre requête dans l'exemple ci-dessus est "Quelle est la météo à Tokyo?", Nous voyons un appel dans l'outil_Calls de l'objet de message renvoyé.

N'oubliez pas que le modèle n'appelle pas la fonction get_weather mais génère des arguments pour celui-ci en fonction du schéma pydatique que nous avons fourni:

$ pip install -U openai

C'est à nous d'appeler la fonction avec les arguments fournis:

$ export OPENAI_API_KEY='your-api-key'

Si vous souhaitez que le modèle génére les arguments pour la fonction et l'appellez en même temps, vous recherchez un agent d'IA. 

Nous avons un tutoriel séparé des agents de Langchain si vous êtes intéressé.

meilleures pratiques lors de l'utilisation de sorties structurées OpenAI

En utilisant des sorties structurées, il existe un certain nombre de meilleures pratiques et recommandations à garder à l'esprit. Dans cette section, nous décrirons certains d'entre eux.

1. Utilisez des modèles pydatiques pour définir les schémas de sortie, car ils fournissent un moyen propre et sécurisé de définir les structures de sortie attendues.
2. Gardez les schémas simples et spécifiques pour obtenir les résultats les plus précis.
3. Utilisez des types de données appropriés (Str, int, Float, Bool, List, Dict) pour représenter avec précision vos données.
4. Utilisez des types littéraux pour les énumérations afin de définir des valeurs autorisées spécifiques pour les champs.
5. Gire des refus du modèle. Lorsque vous utilisez la nouvelle méthode .parse (), les objets de message ont un nouvel attribut .refusal pour indiquer un refus:

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
   model="gpt-4o-mini",
   messages=[
       {"role": "system", "content": "You are a helpful assistant."},
       {"role": "user", "content": "Say hello!"}
   ],
   max_tokens=5
)
>>> print(response.choices[0].message.content.strip())
Hello! How can I

Sortie:

$ pip install pydantic

6. Fournissez des descriptions claires et concises pour chaque champ de vos modèles pydatiques pour améliorer la précision de sortie du modèle:

from pydantic import BaseModel
from typing import Literal
class SentimentResponse(BaseModel):
   sentiment: Literal["positive", "negative", "neutral"]

Ces pratiques contribueront grandement à faire l'utilisation la plus efficace des sorties structurées dans vos applications.

Conclusion

Dans ce tutoriel, nous avons appris à commencer avec une nouvelle fonctionnalité API OpenAI: Sorties structurées. Nous avons vu comment cette fonctionnalité oblige les modèles de langage à produire des sorties dans le format que nous spécifions. Nous avons appris à l'utiliser en combinaison avec des appels de fonction et exploré certaines meilleures pratiques pour tirer le meilleur parti de la fonctionnalité.

Voici quelques sources connexes pour améliorer votre compréhension:

• Travailler avec le cours OpenAI API
• Openai Fundamentals Track
• Developing LLM Applications avec Langchain Course
• Langchain contre Llamaindex: une comparaison détaillée

Gagnez une certification AI supérieure

démontrer que vous pouvez utiliser efficacement et responsable AI.get certifié, être embauché

Sorties structurées FAQS

Comment les modèles pydantiques fonctionnent-ils avec les modèles de DeSired? Structure, qui est ensuite transmise à l'API OpenAI pour appliquer le format de réponse.

Oui, les sorties structurées peuvent être utilisées avec la fonction des appels pour simplifier le processus de définition des paramètres de fonction et des avantages et des avantages attendus. de l'utilisation de sorties structurées?

Les avantages incluent des formats de réponse cohérents, un besoin réduit de post-traitement, une fiabilité améliorée dans les applications AI, et une intégration plus facile avec les systèmes existants.

Il y a des limites à des limites à des limites structurées. Sorties?

Bien que des sorties puissantes et structurées puissent limiter la flexibilité de l'IA dans les réponses et nécessiter une conception de schéma minutieuse pour équilibrer la structure avec le niveau de détail souhaité dans les sorties.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!