LLM-code testen · oefening
Test eigenschappen, geen formuleringen
Elke test tot nu toe scriptte één antwoord en controleerde één resultaat. Dat is de juiste vorm voor “wat doet ask met None?”, maar het laat een gat. Het antwoord dat je scriptte, is er één uit eindeloos veel antwoorden die een live model kan sturen, en het volgende zal anders verwoord zijn. Deze les draait de vraag om: vraag niet “wat leverde dit antwoord op?”, maar “wat moet waar zijn, wat het antwoord ook was?”
Een eigenschap
Een eigenschap (property) is iets wat elk acceptabel resultaat heeft, wat de formulering ook is. Twee die de studieassistent belooft:
answer_from_notesgeeft nooit een bronvermelding terug die het niet kreeg. Het mag antwoorden, of het antwoord afwijzen met eenValueError, maar een antwoord dat het teruggeeft, verwijst alleen naar labels van de passages die het verstuurde.run_agentblijft binnen zijn limieten. De trace heeft nooit meer stappen danmax_steps, en het budget dat hij uitgaf, is gelijk aan de tokens die zijn trace vastlegt.
Een eigenschapstest controleert zo’n zin over veel invoer. De decorator @pytest.mark.parametrize uit Python in de praktijk doet het herhalen: die voert één testfunctie één keer per rij van een tabel uit en meldt elke rij als een eigen test.
Dit is niet de “property-based testing” van libraries die willekeurige invoer voor je verzinnen. Hier kies je de invoer zelf, een tabel met antwoorden waaronder lastige, en de assertion is de eigenschap.
Bronvermeldingen komen uit de passages
De passages voor de kopieervraag zijn wat best_chunks(question, note_chunks(load_notes()), 3) teruggeeft, en hun labels komen van chunk_label uit hoofdstuk 8. De test bouwt die lijst met labels en geeft answer_from_notes daarna elk antwoord uit een tabel:
@pytest.mark.parametrize(
"reply_text",
[
'{"answer": "Use scores.copy().", "citations": ["03-lists#4"]}',
'{"answer": "Use scores.copy().", "citations": ["03-lists#4", "99-nothing#1"]}',
'{"answer": "Use scores.copy().", "citations": []}',
"Use scores.copy().",
],
)
def test_an_answer_cites_only_passages_it_was_given(reply_text):
...
De rijen zijn een geldig antwoord, een antwoord dat verwijst naar een passage die nooit werd verstuurd, een zonder bronvermeldingen en een dat helemaal geen JSON is. Voor elk ervan roept de test answer_from_notes aan met een nep-client die dat antwoord bevat, en controleert hij daarna met een assertion dat elke bronvermelding van het antwoord een van de labels is.
Een antwoord afwijzen is ook acceptabel. Voor de tweede en de vierde rij geeft answer_from_notes een ValueError: de eigen melding van hoofdstuk 8 voor het onbekende label, en de ValidationError van pydantic voor de tekst die geen JSON is, wat een soort ValueError is (hoofdstuk 4). Daarom staat de aanroep binnen try, en bij except ValueError: doet de test return, waarmee die rij als geslaagd eindigt. De eigenschap is niet “het antwoord wordt geaccepteerd”, maar “er glipt niets zonder geldige bron doorheen”.
De limieten gelden bij elke stappenlimiet
De tweede eigenschap stuurt run_agent aan met een model dat nooit ophoudt met vragen. Schrijf vier toolaanroep-antwoorden uit, elk met een vraag om een andere notitie, zodat geen aanroep zich herhaalt en de lus geen reden heeft om te stoppen als "stuck":
FOUR_CALLS = [
fakes.tool_call_reply([("c1", "read_note", '{"note_id": "n1"}')]),
fakes.tool_call_reply([("c2", "read_note", '{"note_id": "n2"}')]),
fakes.tool_call_reply([("c3", "read_note", '{"note_id": "n3"}')]),
fakes.tool_call_reply([("c4", "read_note", '{"note_id": "n4"}')]),
]
Parametriseer daarna over een tabel van drie rijen, elk met een max_steps-waarde en de antwoorden:
@pytest.mark.parametrize(("max_steps", "replies"), [(1, FOUR_CALLS), (2, FOUR_CALLS), (3, FOUR_CALLS)])
def test_the_agent_stays_within_its_limits(max_steps, replies):
...
Met twee namen is het eerste argument van parametrize een tuple van namen en is elke rij een tuple van waarden. Voer in elke rij de agent uit met een FakeClient(replies), je eigen tool read_note zoals in les 3, een nieuw budget en sleep=waits.append, en assert daarna twee dingen: len(result["trace"]) <= max_steps, en dat budget["used"] gelijk is aan het totaal van de tokens van elke stap in de trace, opgeteld met een lus.
Een lus die max_steps negeerde, zou om een vijfde antwoord vragen, en de nep-client zou de test laten falen met Your code called the model 5 times. Een lus die sommige tokens dubbel telde, zou een budget hebben dat niet overeenkomt met zijn trace.
Nu jij
Schrijf in tests/test_properties.py beide tests: de bronvermeldingseigenschap over de vier antwoorden, en de limieteigenschap over max_steps 1, 2 en 3. Voer ze daarna uit:
python -m pytest -q tests/test_properties.py
....... [100%]
7 passed in 0.23s
Twee testfuncties, zeven tests: pytest telt elke rij als één test.
Hoe je tests worden gecontroleerd
tests/test_properties.py wordt uitgevoerd tegen de correcte code en drie kapotte functies, en moet op elke functie falen:
answer_from_notesslaat de bronvermeldingscontrole over, en valideert het antwoord dus alleen alsCitedAnswer;run_agentnegeertmax_steps;call_modeltelt het verbruik van elk antwoord twee keer bij het budget op.
Geen van deze zou opvallen in een test met één geldig antwoord. Elk ervan schendt een eigenschap.
In de test van de bronvermeldingseigenschap geeft answer_from_notes een ValueError voor het antwoord dat geen JSON is, en de test doet return. Waarom telt die rij als geslaagd?
In de limiettest staan vier gescripte toolaanroep-antwoorden, elk met een vraag om een andere notitie. Waarom verschillende notities?
Opdracht
Schrijf in tests/test_properties.py twee geparametriseerde tests:
Over vier antwoordteksten voor de kopieervraag (een geldige, een die naar
03-lists#4en99-nothing#1verwijst, een zonder bronvermeldingen, een die geen JSON is): bouw de labels vanbest_chunks(question, note_chunks(load_notes()), 3)metchunk_label, roepanswer_from_notesaan met een nep-client die het antwoord bevat en assert dat elke bronvermelding een van die labels is. Binnentryzorgt eenValueErrorervoor dat de testreturndoet.Over drie rijen,
max_steps1, 2 en 3, elk met dezelfde vier uitgeschreven toolaanroep-antwoorden (n1tot en metn4): voerrun_agentuit met je eigen toolread_noteen een nieuw budget, en assertlen(result["trace"]) <= max_stepsen datbudget["used"]gelijk is aan de som van detokensvan de trace.
Voer python -m pytest -q tests/test_properties.py uit en controleer daarna je werk.