0%

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_notes geeft nooit een bronvermelding terug die het niet kreeg. Het mag antwoorden, of het antwoord afwijzen met een ValueError, maar een antwoord dat het teruggeeft, verwijst alleen naar labels van de passages die het verstuurde.

  • run_agent blijft binnen zijn limieten. De trace heeft nooit meer stappen dan max_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_notes slaat de bronvermeldingscontrole over, en valideert het antwoord dus alleen als CitedAnswer;

  • run_agent negeert max_steps;

  • call_model telt 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:

  1. Over vier antwoordteksten voor de kopieervraag (een geldige, een die naar 03-lists#4 en 99-nothing#1 verwijst, een zonder bronvermeldingen, een die geen JSON is): bouw de labels van best_chunks(question, note_chunks(load_notes()), 3) met chunk_label, roep answer_from_notes aan met een nep-client die het antwoord bevat en assert dat elke bronvermelding een van die labels is. Binnen try zorgt een ValueError ervoor dat de test return doet.

  2. Over drie rijen, max_steps 1, 2 en 3, elk met dezelfde vier uitgeschreven toolaanroep-antwoorden (n1 tot en met n4): voer run_agent uit met je eigen tool read_note en een nieuw budget, en assert len(result["trace"]) <= max_steps en dat budget["used"] gelijk is aan de som van de tokens van de trace.

Voer python -m pytest -q tests/test_properties.py uit en controleer daarna je werk.