0%

De OpenAI-client gebruiken · oefening

Gestructureerde uitvoer via de client

Hoofdstuk 4 kreeg een gevalideerde quiz in vier stappen: om json_object vragen, het schema in het systeembericht zetten zodat het model de vorm kent, het antwoord valideren met QuizSet.model_validate_json, en één corrigerend bericht sturen als dat mislukte. De client heeft een hulpfunctie die de eerste drie in één aanroep doet, en die gebruikt een strenger requestformaat dat hoofdstuk 4 alleen kon noemen.

De parse-hulpfunctie

response = client.chat.completions.parse(model=MODEL, messages=messages, response_format=QuizSet)
quiz = response.choices[0].message.parsed

client.chat.completions.parse neemt dezelfde argumenten als create, plus response_format=QuizSet: de pydantic-modelklasse zelf, geen dictionary. Met die klasse doet de functie drie dingen:

  1. Hij bouwt een JSON Schema uit QuizSet, zoals QuizSet.model_json_schema() in hoofdstuk 4 deed, en stuurt het in het response_format van het request mee als json_schema, het strengere formaat. Met "strict": true zorgt een aanbieder die dat ondersteunt ervoor dat de uitvoer van het model precies het schema volgt.

  2. Hij verstuurt het request zoals create dat zou doen.

  3. Hij valideert de tekst van het antwoord met QuizSet en zet het resulterende QuizSet-object in response.choices[0].message.parsed.

Omdat het schema in het requestformaat meereist, hoeft de prompt het niet meer te bevatten. quiz_messages gaat terug naar de gewone QUIZ_SYSTEM, zonder quiz_system_message() uit hoofdstuk 4. QUIZ_SYSTEM beschrijft de quiz nog steeds in woorden, wat een live model helpt en weinig kost.

Net als in hoofdstuk 4 leest het gescripte model het schema niet: het beantwoordt de quizprompt vanuit zijn tabel, en SCRIPTED_MODEL.md beschrijft hoe het met json_schema omgaat. Een live model leest het wel, en met strikte uitvoer volgt het dat schema ook.

Als er geen quiz komt

Er kunnen drie dingen gebeuren in plaats van een quiz, en parse_quiz_reply behandelt elk ervan anders.

Het model weigert. Een live model kan een vraag afwijzen, bijvoorbeeld een vraag die het onveilig vindt. Dan is message.parsed None en bevat message.refusal de uitleg van het model als tekst. Het gescripte model weigert nooit. parse_quiz_reply maakt van een weigering een fout die de aanroeper niet kan missen: raise ValueError(f"The model refused: {message.refusal}"). parsed is ook None als een antwoord helemaal geen content heeft. Dan is refusal ook None, en luidt je fout The model refused: None.

Het antwoord valideert niet. Dan werpt parse zelf pydantic.ValidationError op, dezelfde fout die parse_quiz in hoofdstuk 4 opwierp. Je krijgt nooit een responseobject, dus de tekst van het antwoord en de tokenaantallen krijg je niet terug. parse_quiz_reply vangt niets af; het project beslist wat er met een ongeldig antwoord gebeurt.

Het antwoord werd afgekapt bij de tokenlimiet van het model. Dan werpt parse openai.LengthFinishReasonError op. Hoofdstuk 9 behandelt afgekapte antwoorden.

Bouw de twee functies

quiz_messages(note_text) geeft de berichten terug voor een quiz over een notitie:

[{"role": "system", "content": QUIZ_SYSTEM}, note_message(note_text, QUIZ_PROMPT)]

note_message is de functie uit hoofdstuk 2: die zet de notitie tussen <note>-tags na de prompt. Het gescripte model herkent het begin van dat bericht, QUIZ_PROMPT, alleen als het precies overeenkomt; een live model zou elke formulering accepteren.

parse_quiz_reply(messages, *, client):

  1. Doe één aanroep: client.chat.completions.parse(model=MODEL, messages=messages, response_format=QuizSet). Geef verder niets mee.

  2. message = response.choices[0].message.

  3. Als message.parsed is None, werp dan ValueError(f"The model refused: {message.refusal}") op.

  4. Geef anders message.parsed terug.

QuizSet wordt bovenaan het bestand geïmporteerd uit quiz_models.py.

Voer het uit

Voer python client_calls.py uit. De demonstratie vraagt om een quiz over notes/03-lists.md en drukt die af vanuit de QuizSet die je functie teruggaf:

quiz = parse_quiz_reply(quiz_messages(note), client=client)
for question in quiz.questions:
    print(f"  {question.question} Answer: {question.choices[question.answer_index]}")

Daarna roept de demonstratie de meegeleverde last_request() aan, die GET /v1/scripted/last-request ophaalt: de laatste requestbody die je sandbox naar llm-api stuurde, precies zoals de dienst die ontving. Ze drukt het response_format van die body af, dat je nooit zelf hebt geschreven:

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

Dat is het requestformaat json_schema. Het json_schema daarin bevat drie dingen: de name van het schema, afgeleid van de klassenaam; "strict": true; en het schema zelf, dat QuizSet.model_json_schema() uit hoofdstuk 4 is met één toevoeging. Elk object erin heeft nu "additionalProperties": false, wat de strikte modus vereist en wat sleutels verbiedt die het model niet declareert. QuizQuestion staat onder $defs, en "$ref": "#/$defs/QuizQuestion" verwijst ernaar vanuit de lijst questions.

Daarna gaat python client_calls.py verder met de demonstratie van les 5, die alleen afgeronde code gebruikt, en stopt bij chat_turn, de eerste functie van het project.

parse krijgt een antwoord waarin answer_index gelijk is aan "abc". Wat krijgt je code?

Waarom gebruikt quiz_messages gewoon QUIZ_SYSTEM in plaats van quiz_system_message() uit hoofdstuk 4, dat het schema toevoegde?

Opdracht

Vervang in client_calls.py de onafgemaakte bodies van quiz_messages(note_text) en parse_quiz_reply(messages, *, client).

  • quiz_messages geeft [{"role": "system", "content": QUIZ_SYSTEM}, note_message(note_text, QUIZ_PROMPT)] terug, zonder schema in het systeembericht.

  • parse_quiz_reply doet één aanroep, client.chat.completions.parse(model=MODEL, messages=messages, response_format=QuizSet), en leest message = response.choices[0].message.

  • Als message.parsed None is, werp dan ValueError(f"The model refused: {message.refusal}") op. Geef anders message.parsed terug.

  • Vang niets af: een ValidationError uit parse bereikt de aanroeper.

Voer python client_calls.py uit om de quiz te zien en het requestformaat dat de hulpfunctie verstuurde, en controleer daarna je werk.