Den OpenAI-Client verwenden · Übung
Strukturierte Ausgabe über den Client
In Kapitel 4 hast du ein validiertes Quiz in vier Schritten bekommen: json_object anfordern, das Schema in die Systemnachricht schreiben, damit das Modell die Form kennt, die Antwort mit QuizSet.model_validate_json validieren und eine korrigierende Nachricht senden, wenn das fehlschlug. Der Client hat eine Hilfsfunktion, die die ersten drei in einem Aufruf erledigt, und sie verwendet ein strengeres Anfrageformat, das Kapitel 4 nur erwähnen konnte.
Die Parse-Hilfsfunktion
response = client.chat.completions.parse(model=MODEL, messages=messages, response_format=QuizSet)
quiz = response.choices[0].message.parsed
client.chat.completions.parse nimmt dieselben Argumente wie create, dazu response_format=QuizSet: die Pydantic-Modellklasse selbst, kein Dictionary. Ausgehend von dieser Klasse tut sie drei Dinge:
Sie baut aus
QuizSetein JSON Schema, wie esQuizSet.model_json_schema()in Kapitel 4 getan hat, und sendet es imresponse_formatder Anfrage alsjson_schema, das strengere Format. Mit"strict": truesorgt ein Anbieter, der das unterstützt, dafür, dass die Ausgabe des Modells genau dem Schema folgt.Sie sendet die Anfrage so, wie
createes tun würde.Sie validiert den Text der Antwort mit
QuizSetund legt das entstandeneQuizSet-Objekt inresponse.choices[0].message.parsedab.
Weil das Schema im Anfrageformat mitreist, muss der Prompt es nicht mehr tragen. quiz_messages kehrt zum einfachen QUIZ_SYSTEM zurück, ohne quiz_system_message() aus Kapitel 4. QUIZ_SYSTEM beschreibt das Quiz weiterhin in Worten, was einem Live-Modell hilft und wenig kostet.
Wie in Kapitel 4 liest das geskriptete Modell das Schema nicht: Es beantwortet den Quiz-Prompt aus seiner Tabelle, und SCRIPTED_MODEL.md beschreibt, wie es mit json_schema umgeht. Ein Live-Modell liest es, und mit strikter Ausgabe folgt es ihm.
Wenn es kein Quiz gibt
Statt eines Quiz kann dreierlei passieren, und parse_quiz_reply behandelt jeden Fall anders.
Das Modell lehnt ab. Ein Live-Modell kann eine Anfrage ablehnen, zum Beispiel eine, die es für unsicher hält. Dann ist message.parsed None, und message.refusal enthält die Erklärung des Modells als Text. Das geskriptete Modell lehnt nie ab. parse_quiz_reply macht aus einer Ablehnung einen Fehler, den der Aufrufer nicht übersehen kann: raise ValueError(f"The model refused: {message.refusal}"). parsed ist auch dann None, wenn eine Antwort gar keinen Inhalt hat. Dann ist auch refusal None, und dein Fehler lautet The model refused: None.
Die Antwort lässt sich nicht validieren. Dann löst parse selbst pydantic.ValidationError aus, denselben Fehler, den parse_quiz in Kapitel 4 ausgelöst hat. Du bekommst nie ein Antwortobjekt, also werden dir der Text der Antwort und ihre Token-Zahlen nicht zurückgegeben. parse_quiz_reply fängt nichts ab; das Projekt entscheidet, was bei einer ungültigen Antwort passiert.
Die Antwort wurde abgeschnitten, beim Token-Limit des Modells. Dann löst parse openai.LengthFinishReasonError aus. Kapitel 9 behandelt abgeschnittene Antworten.
Baue die beiden Funktionen
quiz_messages(note_text) gibt die Nachrichten für ein Quiz über eine Notiz zurück:
[{"role": "system", "content": QUIZ_SYSTEM}, note_message(note_text, QUIZ_PROMPT)]
note_message ist die Funktion aus Kapitel 2: Sie setzt die Notiz in <note>-Tags hinter den Prompt. Das geskriptete Modell vergleicht den Anfang dieser Nachricht, QUIZ_PROMPT, exakt; ein Live-Modell würde jede Formulierung akzeptieren.
parse_quiz_reply(messages, *, client):
Mache einen Aufruf:
client.chat.completions.parse(model=MODEL, messages=messages, response_format=QuizSet). Übergib sonst nichts.message = response.choices[0].message.Wenn
message.parsed is None, löseValueError(f"The model refused: {message.refusal}")aus.Andernfalls gib
message.parsedzurück.
QuizSet wird oben in der Datei aus quiz_models.py importiert.
Ausführen
Führe python client_calls.py aus. Die Demonstration fordert ein Quiz über notes/03-lists.md an und gibt es aus dem QuizSet aus, das deine Funktion zurückgegeben hat:
quiz = parse_quiz_reply(quiz_messages(note), client=client)
for question in quiz.questions:
print(f" {question.question} Answer: {question.choices[question.answer_index]}")
Dann ruft sie das mitgelieferte last_request() auf, das GET /v1/scripted/last-request abruft: den letzten Anfrage-Body, den deine Sandbox an llm-api gesendet hat, genau so, wie der Dienst ihn empfangen hat. Sie gibt das response_format dieses Bodys aus, das du nie geschrieben hast:
A quiz through the parse helper:
parse_quiz_reply returned a QuizSet with 3 questions:
For scores = [90, 72, 85], what is scores[-1]? Answer: 85
What does scores.append(60) return? Answer: None
Which line makes an independent copy of scores? Answer: backup = scores.copy()
The response_format the parse helper sent:
{
"type": "json_schema",
"json_schema": {
"schema": {
"$defs": {
"QuizQuestion": {
"properties": {
"question": {
"title": "Question",
"type": "string"
},
"choices": {
"items": {
"type": "string"
},
"title": "Choices",
"type": "array"
},
"answer_index": {
"title": "Answer Index",
"type": "integer"
}
},
"required": [
"question",
"choices",
"answer_index"
],
"title": "QuizQuestion",
"type": "object",
"additionalProperties": false
}
},
"properties": {
"questions": {
"items": {
"$ref": "#/$defs/QuizQuestion"
},
"title": "Questions",
"type": "array"
}
},
"required": [
"questions"
],
"title": "QuizSet",
"type": "object",
"additionalProperties": false
},
"name": "QuizSet",
"strict": true
}
}
Das ist das Anfrageformat json_schema. Sein json_schema enthält drei Dinge: den name des Schemas, abgeleitet vom Klassennamen; "strict": true; und das schema selbst, also QuizSet.model_json_schema() aus Kapitel 4 mit einer Ergänzung. Jedes Objekt darin hat jetzt "additionalProperties": false. Der strikte Modus verlangt das, und es verbietet Schlüssel, die das Modell nicht deklariert. QuizQuestion steht unter $defs, und "$ref": "#/$defs/QuizQuestion" verweist aus der Liste questions darauf.
Danach geht python client_calls.py weiter zur Demonstration von Lektion 5, die nur fertigen Code verwendet, und hält bei chat_turn an, der ersten Funktion des Projekts.
parse bekommt eine Antwort, in der answer_index den Wert "abc" hat. Was bekommt dein Code?
Warum verwendet quiz_messages das einfache QUIZ_SYSTEM statt quiz_system_message() aus Kapitel 4, das das Schema hinzugefügt hat?
Aufgabe
Ersetze in client_calls.py die unfertigen Rümpfe von quiz_messages(note_text) und parse_quiz_reply(messages, *, client).
quiz_messagesgibt[{"role": "system", "content": QUIZ_SYSTEM}, note_message(note_text, QUIZ_PROMPT)]zurück, ohne Schema in der Systemnachricht.parse_quiz_replymacht einen Aufruf,client.chat.completions.parse(model=MODEL, messages=messages, response_format=QuizSet), und liestmessage = response.choices[0].message.Wenn
message.parsedNoneist, löseValueError(f"The model refused: {message.refusal}")aus. Andernfalls gibmessage.parsedzurück.Fange nichts ab: Ein
ValidationErrorausparseerreicht den Aufrufer.
Führe python client_calls.py aus, um das Quiz und das Anfrageformat zu sehen, das die Hilfsfunktion gesendet hat, und prüfe dann deine Arbeit.