0%

LLM-code testen · oefening

Sla een echte response op en speel die opnieuw af

De antwoorden in je tests waren tot nu toe met de hand getypt. Dat is snel, en zo kan een test elk antwoord scripten dat hij nodig heeft, maar een met de hand getypt antwoord kan afwijken van wat een echte dienst stuurt: een veld dat die nooit heeft, tekst die geen model zou schrijven, een toolaanroep met een net iets verkeerde vorm. Een opname (recording) lost dat op. Je slaat één echt antwoord op in een bestand, één keer, en elke test daarna speelt het opnieuw af.

Een response is een pydantic-model

Wat client.chat.completions.create teruggeeft, is geen dictionary. Het is een object van de klasse ChatCompletion uit het pakket openai, en die klasse is een pydantic-model, zoals QuizSet uit hoofdstuk 4. Het heeft dus de methode die je in hoofdstuk 4 andersom gebruikte: QuizSet.model_validate_json(text) maakte van JSON-tekst een object, en response.model_dump_json() maakt van een object JSON-tekst. Met indent=2 wordt de tekst over regels verdeeld, makkelijk te lezen in de editor.

Bouw save_response

Schrijf in evals.py de functie save_response(response, path):

  1. Open path om te schrijven, met encoding="utf-8". path kan een string of een Path zijn; open accepteert beide.

  2. Schrijf response.model_dump_json(indent=2) erin.

  3. Geef niets terug.

Modus "w" vervangt wat het bestand bevatte, dus opnieuw opslaan geeft een verse opname, niet twee responses achter elkaar.

Neem één antwoord op

Voer python evals.py opnieuw uit. Na de live antwoorden uit les 1 roept de demonstratie record_copy_answer() aan. Die stuurt de kopieervraag met de drie beste passages, precies zoals hoofdstuk 8 deed, via de echte client, geeft de response aan jouw save_response met het pad tests/recordings/copy-question.json en drukt het bestand af:

Your tests do not run here. Run them in the terminal: python -m pytest -q
Recording the copy question's reply:
Saved tests/recordings/copy-question.json:
{
  "id": "chatcmpl-scripted-fbe288a867ac4c1aba660a1c",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "message": {
        "content": "{\"answer\": \"Use scores.copy() or list(scores). Both build a new list, so a change made through one name no longer shows through the other.\", \"citations\": [\"03-lists#4\"]}",
        "refusal": null,
        "role": "assistant",
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": null
      }
    }
  ],
  "created": 1794172068,
  "model": "pl-scripted",
  "object": "chat.completion",
  "metadata": null,
  "moderation": null,
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "completion_tokens": 43,
    "prompt_tokens": 327,
    "total_tokens": 370,
    "completion_tokens_details": null,
    "prompt_tokens_details": null
  }
}
The eval with GROUNDED_SYSTEM:
Run stopped at the next function to build: run_eval is built in Lesson 6.

Dat is de hele response zoals de client hem zag. Jouw bestand heeft een ander id en een andere created-tijd, omdat de dienst elke response nieuwe waarden geeft. De code van de cursus leest er vier dingen uit, en alleen die: choices[0].message.content, hier de CitedAnswer-JSON als string; choices[0].message.tool_calls, hier null; choices[0].finish_reason; en usage, hier 327 + 43 = 370 tokens. De rest, van logprobs tot system_fingerprint, staat erin omdat de klasse van de client die velden heeft.

De demonstratie stopt daarna bij les 6.

Speel hem af in een test

fakes.from_recorded(path) leest zo’n bestand en bouwt er een nep-antwoord van, waarbij alleen de vier dingen hierboven behouden blijven. Hij accepteert de model_dump_json-uitvoer van de client, zoals je die net opsloeg, en ook een responsebody zoals de dienst die via HTTP stuurde. tests/recordings/live-lists-note.json, het eerste live antwoord uit les 1, is zo’n body: die kwam van OpenRouter, met extra velden zoals provider, native_finish_reason en cost die deze cursus nooit leest. Die speel je op dezelfde manier af.

reply = fakes.from_recorded("tests/recordings/copy-question.json")
client = fakes.FakeClient([reply])

De paden zijn relatief ten opzichte van de projectmap, net als NOTES_DIR = Path("notes") in retrieval.py. Dat is de map waaruit je pytest uitvoert, en de map waarin je tests worden uitgevoerd bij het controleren van je werk, dus dezelfde paden werken in beide gevallen.

Nu jij

Schrijf in tests/test_recorded.py twee tests:

  1. Speel tests/recordings/copy-question.json af via answer_from_notes(question, load_notes(), client=client, k=3), met de kopieervraag, How do I make an independent copy of a list?, en assert dat de bronvermeldingen ["03-lists#4"] zijn.

  2. Speel tests/recordings/live-lists-note.json af via ask, en assert dat die de opgenomen tekst teruggeeft. Typ de tekst niet in de test: open de opname met json.load en lees hem uit ["choices"][0]["message"]["content"], zodat de verwachte waarde die uit het bestand is.

Als python evals.py llm-api niet kon bereiken, bestaat copy-question.json nog niet, en faalt je eerste test met FileNotFoundError totdat een run ervan lukt. Bij het controleren van je werk wordt een eigen kopie van het bestand gebruikt.

Voer ze uit:

python -m pytest -q tests/test_recorded.py
..                                                                       [100%]
2 passed in 0.22s

Waarop je wel en niet assert

Assert op wat de cursus leest: de content, de bronvermeldingen, de toolaanroepen, het verbruik. Assert nooit op id of created. Die veranderen bij elke opname, en de kopie van copy-question.json die bij het controleren van je werk wordt gebruikt, heeft zijn eigen waarden.

Asserten op de opgenomen tekst is hier veilig, anders dan assert answer == expected uit les 1, omdat een opname nooit verandert. De test vraagt het model niets. Hij controleert hoe je programma met één echt antwoord omgaat, dus hij kan nooit zeggen of het model goed antwoordt. Als je een prompt verandert, neem dan opnieuw op: een oude opname beantwoordt een request dat je programma niet meer verstuurt.

Hoe je werk wordt gecontroleerd

save_response wordt gecontroleerd met twee echte ChatCompletion-objecten, een met tekst en een met twee toolaanroepen. Het bestand moet de hele response als JSON bevatten, teruggelezen als UTF-8, fakes.from_recorded moet er dezelfde content, toolaanroepen, finish reason en hetzelfde verbruik uit opbouwen, en er mag niets worden teruggegeven.

Daarna wordt tests/test_recorded.py uitgevoerd in een alleen-lezen kopie van het project, tegen de correcte code en twee kapotte versies, en moet het op elke versie falen:

  • answer_from_notes geeft geen bronvermeldingen terug;

  • ask geeft "" terug in plaats van de tekst van het antwoord.

Waarom mag een test van een opname nooit asserten op id of created?

Je test speelt copy-question.json af via answer_from_notes en slaagt. Wat heeft hij laten zien?

Opdracht

  1. Schrijf in evals.py de functie save_response(response, path): open path om te schrijven met encoding="utf-8", schrijf response.model_dump_json(indent=2) en geef niets terug. Voer python evals.py uit in de Shell om tests/recordings/copy-question.json op te nemen.

  2. Schrijf in tests/test_recorded.py twee tests met fakes.from_recorded:

    • speel tests/recordings/copy-question.json af via answer_from_notes voor de kopieervraag met load_notes() en k=3, en assert dat de bronvermeldingen ["03-lists#4"] zijn;

    • speel tests/recordings/live-lists-note.json af via ask, en assert dat die de opgenomen tekst teruggeeft, gelezen uit het bestand met json.load.

Assert nooit op id of created. Voer python -m pytest -q tests/test_recorded.py uit en controleer daarna je werk.