Gestructureerde uitvoer · oefening
Laat het model de vorm zien
Je programma weet nu precies hoe een geldige quiz eruitziet: QuizSet zegt het. Het model weet dat niet. Het krijgt alleen QUIZ_SYSTEM, een zin die het object in woorden beschrijft. Deze les stuurt het model dezelfde beschrijving waar je programma tegen controleert, zodat die twee niet uit elkaar kunnen groeien.
Een model kan zichzelf beschrijven
Elk pydantic-model kan zijn vorm uitschrijven als JSON Schema, een standaardformaat om JSON-documenten te beschrijven:
import json
from pydantic import BaseModel
class QuizQuestion(BaseModel):
question: str
choices: list[str]
answer_index: int
class QuizSet(BaseModel):
questions: list[QuizQuestion]
schema = QuizSet.model_json_schema()
print(type(schema).__name__)
print(schema["required"])
print(schema["$defs"]["QuizQuestion"]["properties"]["answer_index"])
dict
['questions']
{'title': 'Answer Index', 'type': 'integer'}
model_json_schema() geeft een dictionary terug. De properties ervan noemen de velden met hun JSON-types (string, integer, array voor een lijst), required noemt de velden die er moeten zijn, en $defs bevat de beschrijving van QuizQuestion, waar questions naar verwijst. Je hoeft zelf geen JSON Schema te schrijven; je moet weten dat het de eigen beschrijving van het model is, in een vorm die andere programma’s, en taalmodellen, begrijpen.
Bouw quiz_system_message
quiz_system_message() geeft het systeembericht terug met het schema toegevoegd na QUIZ_SYSTEM:
{"role": "system", "content": QUIZ_SYSTEM + "\n\nJSON schema:\n" + json.dumps(QuizSet.model_json_schema(), indent=2)}
json.dumps(..., indent=2) maakt van de dictionary JSON-tekst over ingesprongen regels, zoals in Python in de praktijk. Een model leest de tekst hoe dan ook; de ingesprongen vorm is wat een mens met het oog kan controleren. Bouw het schema in de functie, uit QuizSet. Als je in plaats daarvan de tekst van het schema zou plakken, zou een latere wijziging aan QuizSet het bericht de oude vorm laten beschrijven.
Verander daarna quiz_request: het eerste bericht wordt quiz_system_message() in plaats van {"role": "system", "content": QUIZ_SYSTEM}. Het notitiebericht, model en response_format blijven zoals ze zijn.
Wie het schema leest
Een live model leest het schema als deel van zijn prompt en gebruikt het om zijn antwoord vorm te geven. Het schema geeft het de exacte veldnamen en types, dus het hoeft minder te raden dan bij een beschrijving in woorden. Het blijft een instructie, geen garantie: het model kan het fout doen, en daarom valideert je programma toch elk antwoord.
Het gescripte model leest het schema niet. Het antwoordt uit zijn tabel met voorbereide antwoorden, net als eerder, en het systeembericht speelt geen rol bij welk antwoord het kiest. De uitvoer hieronder is dus dezelfde quiz als in les 6.
Er is een strengere manier om een schema te sturen, het responseformaat json_schema, waarmee je de dienst zelf vraagt het model aan het schema te houden. Je gebruikt het in hoofdstuk 5, via de openai-client, die dat request voor je uit QuizSet bouwt.
Voer het uit
Voer python structured.py uit. De demonstratie drukt de content van je systeembericht af. Als quiz_request het nog niet verstuurt, staat dat op de volgende regel. Daarna verstuurt ze een prompt waarvan het eerste antwoord met opzet ongeldig is, en dat behandelt de volgende les:
The system message from quiz_system_message:
You write multiple-choice quiz questions for a Python course. Reply with JSON only: an object with a questions list. Each question has question, choices (three or four strings) and answer_index (the position of the correct choice, counting from 0).
JSON 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"
}
},
"properties": {
"questions": {
"items": {
"$ref": "#/$defs/QuizQuestion"
},
"title": "Questions",
"type": "array"
}
},
"required": [
"questions"
],
"title": "QuizSet",
"type": "object"
}
A reply that fails validation, and one retry:
First reply: {"questions": [{"question": "What does len() return?", "choices": ["The number of items", "The last item", "The first item"], "answer_index": "abc"}]}
Run stopped at the next function to build: retry_request is built in Lesson 8.
Dat is het hele systeembericht dat het model bij elk quizrequest krijgt: de instructies in woorden, daarna de exacte vorm in JSON Schema.
Waarom bouwt quiz_system_message het schema elke keer uit QuizSet in plaats van het schema als geplakte tekst te bevatten?
Het quizrequest heeft nu het JSON-schema in zijn systeembericht. Wat garandeert dat over het antwoord van een live model?
Opdracht
Vervang in structured.py de onafgemaakte body van quiz_system_message(), en verander daarna quiz_request zodat die hem gebruikt.
quiz_system_message()geeft{"role": "system", "content": ...}terug, waarbij de content bestaat uitQUIZ_SYSTEM, daarna"\n\nJSON schema:\n", daarnajson.dumps(QuizSet.model_json_schema(), indent=2). Bouw het schema in de functie, uitQuizSet, in plaats van de tekst ervan te plakken.Vervang in
quiz_requesthet eerste bericht,{"role": "system", "content": QUIZ_SYSTEM}, doorquiz_system_message(). Laat de rest van de body zoals hij is.
Voer python structured.py uit om het systeembericht met het schema te zien, en controleer daarna je werk.