Erste Schritte mit OpenAI -strukturierten Ausgängen

Im August 2024 kündigte OpenAI eine leistungsstarke neue Funktion in ihrer API an - strukturierte Ausgaben. Mit dieser Funktion können Sie, wie der Name schon sagt, sicherstellen, dass LLMs Antworten nur in dem von Ihnen angegebenen Format generieren. Diese Fähigkeit erleichtert es erheblich, Anwendungen zu erstellen, die eine präzise Datenformatierung erfordern. 

In diesem Tutorial lernen Sie, wie Sie mit OpenAI -strukturierten Ausgängen beginnen, die neue Syntax verstehen und seine Schlüsselanwendungen untersuchen.

deterministische Antworten oder mit anderen Worten, Antworten in konsistenten Formatierung, sind für viele Aufgaben wie Dateneingabe, Informationsabruf, Fragenbeantwortung, mehrstufige Workflows usw. von entscheidender Bedeutung. Möglicherweise haben Sie erfahren, wie LLMs Ausgaben in sehr unterschiedlichen Formaten erzeugen können, auch wenn die Eingabeaufforderung gleich ist.

Betrachten Sie beispielsweise diese einfache Klassifizierung_Sentiment-Funktion, die von GPT-4O betrieben wird:

Ausgabe:

# 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")

Obwohl sich die ersten beiden Antworten im selben Ein-Wort-Format befanden, ist die letzte ein ganzer Satz. Wenn eine andere nachgeschaltete Anwendung von der Ausgabe des oben genannten Code abhängig wäre, wäre er abgestürzt, da sie eine Einzelwortantwort erwartet hätte.

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.

Wir können dieses Problem mit einem schnellen Engineering beheben, aber es handelt sich um einen zeitaufwändigen iterativen Prozess. Selbst mit einer perfekten Eingabeaufforderung können wir nicht zu 100% sicher sein, dass die Antworten in zukünftigen Anfragen unserem Format entsprechen. Es sei denn natürlich, wir verwenden strukturierte Ausgänge:

Ausgabe:

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")

Mit der neuen Funktion, klassifizieren_Sentiment_with_structured_outputs, sind die Antworten alle im selben Format.

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"}

Diese Fähigkeit, Sprachmodelle in einem starren Format zu erzwingen, ist erheblich und spart Ihnen unzählige Stunden schneller Ingenieurwesen oder Vertrauen in andere Open-Source-Tools.

Erste Schritte mit OpenAI -strukturierten Ausgängen

In diesem Abschnitt werden wir strukturierte Ausgänge anhand des Beispiels der Sentiment Analyzer -Funktion abbauen.

Einrichten Ihrer Umgebung

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

Python 3.7 oder später in Ihrem System installiert.

Ein OpenAI -API -Schlüssel. Sie können dies erhalten, indem Sie sich auf der OpenAI -Website anmelden.
• Einrichten der OpenAI -API

1. Installieren Sie das OpenAI -Python -Paket: Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus, um das OpenAI -Python -Paket auf der neuesten Version zu installieren oder zu aktualisieren:

2. Richten Sie Ihren API -Schlüssel ein: Sie können Ihre API -Taste als Umgebungsvariable oder direkt in Ihrem Code einstellen. Um es als Umgebungsvariable festzulegen, führen Sie

aus:

$ pip install -U openai

3. Überprüfen Sie die Installation: Erstellen Sie ein einfaches Python -Skript, um die Installation zu überprüfen:

$ export OPENAI_API_KEY='your-api-key'

# 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")

Führen Sie das Skript aus, um sicherzustellen, dass alles richtig eingerichtet ist. Sie sollten die im Terminal gedruckte Antwort des Modells sehen.

Zusätzlich zum OpenAI -Paket benötigen Sie die pydantische Bibliothek, um JSON -Schemas für strukturierte Ausgaben zu definieren und zu validieren. Installieren Sie es mit 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.

Mit diesen Schritten ist Ihre Umgebung jetzt so eingerichtet, dass sie OpenAIs strukturierte Ausgabemunktionen verwenden.

ein Ausgangsschema mit pydantischer

definieren

Um strukturierte Ausgänge zu verwenden, müssen Sie die erwartete Ausgangsstruktur mithilfe pydantischer Modelle definieren. Pydantic ist eine Datenvalidierungs- und Einstellungsverwaltungsbibliothek für Python, mit der Sie Datenmodelle mithilfe von Python-Annotationen definieren können. Diese Modelle können dann verwendet werden, um die Struktur der von den OpenAI -Modellen generierten Ausgaben durchzusetzen.

Hier ist ein Beispiel pydantisches Modell zum Angeben des Formats für unseren Überprüfungsgefühl Klassifikator:

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")

In diesem Beispiel:

sentimentResponse ist ein pydantisches Modell, das die erwartete Struktur der Ausgabe definiert.
Das Modell verfügt über ein einzelnes Feldgefühl, das nur einen von drei wörtlichen Werten annehmen kann: "positiv", "negativ" oder "neutral".

Wenn wir dieses Modell als Teil unserer OpenAI -API -Anfragen übergeben, sind die Ausgänge nur eines der Wörter, die wir zur Verfügung gestellt haben.

Mal sehen, wie.

Verwenden Sie den Parse Helper

Um unser pydantisches Schema in OpenAI -Anfragen durchzusetzen, müssen wir es lediglich an den Parameter response_format der Chat -Abschluss -API übergeben. Ungefähr hier ist es, was es aussieht:

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"}

Wenn Sie bemerken, verwenden wir anstatt Client.chat.completions.create zu verwenden. .Parse () ist eine neue Methode in der API der Chat -Abschlüsse, die speziell für strukturierte Ausgaben geschrieben wurde.

Lassen Sie uns nun alles zusammenstellen, indem Sie den Sentiment -Klassifizierer der Bewertungen mit strukturierten Ausgängen neu schreiben. Zunächst machen wir die erforderlichen Importe, definieren das pydantische Modell, die Systemaufforderung und eine Eingabeaufforderung Vorlage:

$ pip install -U openai

Dann schreiben wir eine neue Funktion, die die .Parse () Helfer -Methode verwendet:

$ export OPENAI_API_KEY='your-api-key'

Die wichtige Zeile in der Funktion ist response_format = sentimentResponse, was tatsächlich strukturierte Ausgänge ermöglicht.

testen wir es auf einer der Bewertungen:

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

Hier ist das Ergebnis ein Nachrichtenobjekt:

$ pip install pydantic

Abgesehen von seinem Inhaltsattribut, das die Antwort abholt, enthält es ein Attribut, das die analysierten Informationen als Klasse zurückgibt:

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

Wie Sie sehen, haben wir eine Instanz der SentimentResponse -Klasse. Dies bedeutet

# 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")

pydantische Modelle zur Definition komplexer Schemata

nisten

In einigen Fällen müssen Sie möglicherweise komplexere Ausgangsstrukturen definieren, die verschachtelte Daten beinhalten. Mit Pydantic können Sie Modelle ineinander nisten, sodass Sie komplizierte Schemata erstellen können, die eine Vielzahl von Anwendungsfällen verarbeiten können. Dies ist besonders nützlich, wenn Sie mit hierarchischen Daten zu tun haben oder wenn Sie eine bestimmte Struktur für komplexe Ausgaben durchsetzen müssen.

Betrachten wir ein Beispiel, in dem wir detaillierte Benutzerinformationen, einschließlich des Namens, der Kontaktdaten und einer Liste von Adressen extrahieren müssen. Jede Adresse sollte Felder für die Straße, die Stadt, den Staat und die Postleitzahl enthalten. Dies erfordert mehr als ein pydantisches Modell, um das richtige Schema zu erstellen.

Schritt 1: Definieren Sie die pydantischen Modelle

Erstens definieren wir die pydantischen Modelle für die Adresse und Benutzerinformationen:

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.

In diesem Beispiel:

Adresse ist ein pydantisches Modell, das die Struktur einer Adresse definiert.
userInfo ist ein pydantisches Modell, das eine Liste von Adressobjekten sowie Felder für den Namen, die E -Mail und die Telefonnummer des Benutzers enthält.

.

Schritt 2: Verwenden Sie die verschachtelten pydantischen Modelle in API -Aufrufen

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")

Als nächstes verwenden wir diese verschachtelten pydantischen Modelle, um die Ausgangsstruktur in einem OpenAI -API -Anruf durchzusetzen:

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"}

Der Beispieltext ist völlig unlesbar und es fehlen Räume zwischen wichtigen Informationen. Mal sehen, ob das Modell erfolgreich ist. Wir werden die JSON -Bibliothek verwenden, um die Antwort zu tun:

Wie Sie sehen können, hat das Modell die Informationen eines einzelnen Benutzers zusammen mit ihren beiden separaten Adressen basierend auf unserem bereitgestellten Schema korrekt erfasst.

Kurz gesagt, durch Verschachteln von pydantischen Modellen können Sie komplexe Schemata definieren, die hierarchische Daten verarbeiten und spezifische Strukturen für komplizierte Ausgänge durchsetzen.

Funktionsaufruf mit strukturierten Ausgängen

Eine der weit verbreiteten Funktionen neuerer Sprachmodelle ist das Aufrufen von Funktionen (auch Tool Calling). Mit dieser Fähigkeit können Sie Sprachmodelle mit benutzerdefinierten Funktionen verbinden und ihnen (Modelle) Zugriff auf externe Welt effektiv gewähren.

Einige häufige Beispiele sind:
• Echtzeitdaten abrufen (z. B. Wetter, Aktienkurse, Sportwerte)
• Berechnungen oder Datenanalyse
durchführen
• Abfragedatenbanken oder APIs
• Bilder oder andere Medien erzeugen
• Text zwischen Sprachen
übersetzen
• Steuern von Smart -Home -Geräten oder IoT -Systemen

Ausführen benutzerdefinierter Geschäftslogik oder Workflows

Wir werden nicht auf die Details der Funktionsweise des Funktionsanrufs eingehen, aber Sie können unser OpenAI -Funktionsanruf -Tutorial lesen.

Wichtig ist zu wissen, dass mit strukturierten Ausgängen die Verwendung von Funktionsaufrufen mit OpenAI -Modellen so viel einfacher wird. In der Vergangenheit müssten die Funktionen, die Sie an OpenAI -Modelle übergeben würden, komplexe JSON -Schemata schreiben und jeden Funktionsparameter mit Typ -Tipps umzusetzen. Hier ist ein Beispiel:

# 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")

Obwohl Get_Current_Weather-Funktion zwei Parameter hat, wird das JSON-Schema enorm und fehleranfällig, um manuell zu schreiben.

Dies wird in strukturierten Ausgängen gelöst, indem pydantische Modelle erneut verwendet werden:

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.

Erstens schreiben Sie die Funktion selbst und ihre Logik. Dann definieren Sie es erneut mit einem pydantischen Modell, das die erwarteten Eingabeparameter angibt.

Um das pydantische Modell in ein kompatibles JSON -Schema umzuwandeln, nennen Sie 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")

Hier finden Sie dieses Tool als Teil einer Anfrage:

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"}

Wir übergeben das pydantische Modell in einem kompatiblen JSON -Format an den Tools -Parameter der Chat -Vervollständigungs -API. Abhängig von unserer Abfrage entscheidet das Modell, ob das Tool aufgerufen werden soll oder nicht.

Da unsere Abfrage im obigen Beispiel "Was ist das Wetter in Tokio?" Laut, sehen wir einen Anruf in den Tool_Calls des zurückgegebenen Nachrichtenobjekts.

Denken Sie daran, das Modell ruft die Funktion get_weather nicht auf, sondern generiert Argumente dafür, basierend auf dem pydantischen Schema, das wir zur Verfügung gestellt haben:

$ pip install -U openai

Es liegt an uns, die Funktion mit den bereitgestellten Argumenten aufzurufen:

$ export OPENAI_API_KEY='your-api-key'

Wenn das Modell die Argumente für die Funktion generiert und gleichzeitig aufrufen soll, suchen Sie nach einem AI -Agenten. 

Wir haben ein separates Langchain -Agenten -Tutorial, wenn Sie interessiert sind.

Best Practices bei der Verwendung von OpenAI -strukturierten Ausgängen

Während der Verwendung strukturierter Ausgänge sind eine Reihe von Best Practices und Empfehlungen zu beachten. In diesem Abschnitt werden wir einige von ihnen skizzieren.

1. Verwenden Sie pydantische Modelle, um Ausgangsschemata zu definieren, da sie eine saubere und type-Sicherheit bieten, um erwartete Ausgangsstrukturen zu definieren.
2. Halten Sie Schemata einfach und spezifisch, um die genauesten Ergebnisse zu erzielen.
3. Verwenden Sie geeignete Datentypen (STR, Int, Float, Bool, List, Diktat), um Ihre Daten genau darzustellen.
4. Verwenden Sie wörtliche Typen für Enums, um spezifische zulässige Werte für Felder zu definieren.
5. Modellablehnungen. Bei Verwendung der neuen Methode .Parse () haben die Nachrichtenobjekte ein neues .refusal -Attribut, um eine Ablehnung anzuzeigen:

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

Ausgabe:

$ pip install pydantic

6. Geben Sie für jedes Feld in Ihren pydantischen Modellen klare und präzise Beschreibungen an, um die Genauigkeit der Modellausgabe zu verbessern:

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

Diese Praktiken werden einen großen Beitrag zur effektivsten Verwendung strukturierter Ausgaben in Ihren Anwendungen leisten.

Schlussfolgerung

In diesem Tutorial haben wir gelernt, wie man mit einer neuen OpenAI -API -Funktion beginnt: strukturierte Ausgänge. Wir haben gesehen, wie dieses Merkmal Sprachmodelle dazu zwingt, Ausgaben im von uns angegebenen Format zu erzeugen. Wir haben gelernt, wie man es in Kombination mit Funktionsaufrufen verwendet und einige Best Practices untersucht, um das Beste aus der Funktion zu machen.

Hier sind einige verwandte Quellen, um Ihr Verständnis zu verbessern:

• Mit dem OpenAI -API -Kurs
arbeiten
OpenAI Fundamentals Track
Entwickeln von LLM -Anwendungen mit Langchain -Kurs
Langchain gegen llamaindex: ein detaillierter Vergleich

Verdienen Sie eine Top -AI -Zertifizierung

. Struktur, die dann an die OpenAI -API übergeben wird, um das Antwortformat durchzusetzen. Strukturierte Ausgänge? Ausgänge?

Das obige ist der detaillierte Inhalt vonErste Schritte mit OpenAI -strukturierten Ausgängen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!