0%

LLM-code testen · oefening

Gebruik de meegeleverde nep-client

Les 1 noemde vier soorten controles. Voor de eerste twee moet je code een antwoord krijgen zonder de modeldienst: een antwoord dat jij koos, zodat de test weet wat het juiste resultaat is, en een dat direct aankomt, elke keer, zonder netwerk. Daar is fakes.py voor.

De nep-client

De controles die je werk sinds hoofdstuk 5 nakeken, riepen llm-api nooit aan. Ze gaven je functies een FakeClient in plaats van de echte client, en fakes.py in je project is precies dat bestand. Je code ziet het verschil niet, want die roept alleen client.chat.completions.create(...) aan en leest attributen van wat er terugkomt.

Je gebruikt fakes.py; je hoeft niet te lezen hoe het gebouwd is. Dit is de interface:

fakes.FakeClient(replies)
    A client. Each call to client.chat.completions.create(...) returns the next
    item of replies, in order, one per call. If the item is an error, that
    call raises it.

client.requests
    A list with one dictionary per call so far: "method" ("create"), then
    every argument the call passed, such as "model", "messages" and "tools".

fakes.reply(content, *, finish_reason="stop", usage=(10, 5))
    A text reply. content may be None. usage is (prompt_tokens,
    completion_tokens), so this reply's total_tokens is 15.

fakes.tool_call_reply(calls, *, usage=(10, 5))
    A reply that asks for tools. calls is a list of (id, name, arguments_text)
    tuples, such as ("call_1", "read_note", '{"note_id": "03-lists"}').

fakes.stream(pieces)
    A streamed reply, for code that passes stream=True.

fakes.from_recorded(path)
    A reply rebuilt from a saved response. Lesson 4 uses it.

fakes.rate_limit_error(retry_after=1), fakes.server_error(status=500),
fakes.connection_error(), fakes.timeout_error(), fakes.bad_request_error()
    Real openai errors. Put one in replies, and the call that takes it raises it.

Een antwoord heeft alleen de attributen die de code van de cursus leest: choices[0].message.content, choices[0].message.tool_calls, choices[0].finish_reason en usage. Code die iets anders probeert te gebruiken, zoals response.id, faalt met een AttributeError in plaats van per ongeluk te slagen.

Als je code het model vaker aanroept dan de lijst antwoorden heeft, geeft de extra aanroep een gewone AssertionError die hem noemt: Your code called the model 2 times, but this check expected 1 call(s). Een test die één aanroep verwachtte, faalt dan, en dat is wat je wilt.

Een eerste test

ask(question, *, client) uit hoofdstuk 5, in client_calls.py, stuurt één vraag en geeft de tekst van het antwoord terug, of "" als het antwoord geen tekst heeft. Hier is een test ervan, in de vorm arrange, act, assert (voorbereiden, uitvoeren, controleren) uit Python in de praktijk:

import fakes
from client_calls import MODEL, ask


def test_ask_returns_the_reply_text():
    client = fakes.FakeClient([fakes.reply("A list keeps items in order.")])
    assert ask("What is a list?", client=client) == "A list keeps items in order."
    assert client.requests[0]["model"] == MODEL
  • Arrange: een nep-client met één gescript antwoord.

  • Act: roep er ask mee aan, precies zoals het programma hem met de echte client zou aanroepen.

  • Assert: controleer wat ask teruggaf, en controleer het request dat hij verstuurde, dat de nep-client vastlegde in client.requests[0].

De verwachte tekst kun je veilig in de test schrijven, want de test schreef het antwoord. Dit is geen test van het model, dat nooit draaide; het is een test van wat ask met een antwoord doet. Hij raakt llm-api nooit aan, dus hij draait in een paar milliseconden en slaagt op dezelfde manier, of de dienst nu draait of niet.

De afbeelding volgt dezelfde test van boven naar beneden. De tekst in het gescripte antwoord komt uit ask terug en belandt in de assertion: de test schreef hem in de nep-client, dus hij kan hem verwachten, en niets onderweg bereikt llm-api.

Een test van ask met een nep-client: de test script één antwoord, roept ask aan, krijgt de tekst van dat antwoord terug en controleert die en het request dat de nep-client vastlegde in client.requests[0].

Nu jij

Open tests/test_fake_client.py. Schrijf onder de imports tests die vier dingen over ask controleren:

  1. Hij geeft de tekst van het antwoord terug.

  2. Hij geeft "" terug als de content van het antwoord None is. Script fakes.reply(None).

  3. Het request dat hij verstuurt, heeft model gelijk aan MODEL, en de messages zijn precies [{"role": "user", "content": question}], met jouw vraag, en verder niets: geen systeembericht.

  4. Twee aanroepen op één nep-client met twee gescripte antwoorden krijgen de twee teksten op volgorde terug, en client.requests bevat daarna twee requests.

Geef elke test een naam die zegt wat hij controleert, beginnend met test_. Eén assertion per gedrag is genoeg; meerdere assertions in één test mag ook.

Voer je tests uit

python evals.py voert je tests niet uit. Voer ze uit in de Shell, vanuit de projectmap:

python -m pytest -q tests/test_fake_client.py

Met vier tests die slagen, drukt pytest één punt per test af en een samenvatting. De tijd aan het eind verschilt:

....                                                                     [100%]
4 passed in 0.23s

python -m pytest -q zonder bestand voert elke test in de map tests uit. Les 3 tot en met 5 voegen daar bestanden aan toe, dus dat commando groeit mee met het hoofdstuk.

Bouw in een test nooit de echte client. make_client() maakt verbinding met de dienst, en een test die het netwerk nodig heeft, is traag, faalt als de dienst niet draait en kost geld bij een live model. Wanneer je tests worden gecontroleerd, geeft make_client() de fout AssertionError: Tests must not call llm-api: pass a FakeClient., en elk ander request mislukt.

Hoe je tests worden gecontroleerd

Bij het controleren van je werk wordt tests/test_fake_client.py met pytest uitgevoerd, in een alleen-lezen kopie van het project met eigen kopieën van elk cursusbestand. Je tests moeten slagen, twee keer, tegen de correcte ask. Daarna draaien ze tegen drie kapotte versies van ask, een voor een, en moeten ze op elke versie falen:

  • ask geeft None terug voor een antwoord waarvan de content None is;

  • ask stuurt een systeembericht vóór de vraag;

  • ask stuurt als model "pl-live" in plaats van MODEL.

Een test vangt een kapotte versie alleen als hij ask aanroept en daarna faalt. Als er een doorheen glipt, noemt de feedback die versie, zodat je weet welke test je moet toevoegen.

Een test van een echt model kan het exacte antwoord niet asserten. Waarom mag test_ask_returns_the_reply_text dan asserten dat ask precies "A list keeps items in order." teruggeeft?

Eén kapotte ask stuurt een systeembericht vóór de vraag. Welke assertion vangt dat?

Opdracht

Schrijf in tests/test_fake_client.py tests voor ask uit client_calls.py die fakes.FakeClient gebruiken en controleren dat:

  1. ask de tekst van het antwoord teruggeeft;

  2. ask "" teruggeeft als de content van het antwoord None is (script fakes.reply(None));

  3. de model van het request MODEL is en de messages precies [{"role": "user", "content": question}] zijn;

  4. twee aanroepen op een nep-client met twee antwoorden de twee teksten op volgorde teruggeven, en client.requests twee requests bevat.

Voer ze uit met python -m pytest -q tests/test_fake_client.py in de en controleer daarna je werk. Je tests moeten slagen op de correcte ask en falen op kapotte versies.