0%

LLM-Code testen · Übung

Eine echte Antwort speichern und erneut abspielen

Die Antworten in deinen bisherigen Tests waren von Hand getippt. Das geht schnell, und ein Test kann so jede Antwort skripten, die er braucht, aber eine von Hand getippte Antwort kann sich von dem entfernen, was ein echter Dienst sendet: ein Feld, das es dort nie gibt, ein Text, den kein Modell schreiben würde, ein leicht falsch geformter Tool-Aufruf. Eine Aufzeichnung (recording) behebt das. Du speicherst einmal eine echte Antwort in einer Datei, und jeder Test danach spielt sie erneut ab.

Eine Antwort ist ein Pydantic-Modell

Was client.chat.completions.create zurückgibt, ist kein Dictionary. Es ist ein Objekt der Klasse ChatCompletion aus dem Paket openai, und diese Klasse ist ein Pydantic-Modell, wie QuizSet aus Kapitel 4. Sie hat also die Methode, die du in Kapitel 4 in die andere Richtung verwendet hast: QuizSet.model_validate_json(text) hat JSON-Text in ein Objekt verwandelt, und response.model_dump_json() verwandelt ein Objekt in JSON-Text. Mit indent=2 wird der Text auf Zeilen verteilt und ist im Editor leicht zu lesen.

Baue save_response

Schreibe in evals.py die Funktion save_response(response, path):

  1. Öffne path zum Schreiben, mit encoding="utf-8". path kann ein String oder ein Path sein; open nimmt beides.

  2. Schreibe response.model_dump_json(indent=2) hinein.

  3. Gib nichts zurück.

Der Modus "w" ersetzt, was immer die Datei enthielt, also ergibt erneutes Speichern eine frische Aufzeichnung und nicht zwei aneinandergehängte Antworten.

Zeichne eine Antwort auf

Führe python evals.py noch einmal aus. Nach den Live-Antworten aus Lektion 1 ruft die Demonstration record_copy_answer() auf. Sie sendet die Kopierfrage mit ihren besten drei Passagen, genau wie in Kapitel 8, über den echten Client, übergibt die Antwort mit dem Pfad tests/recordings/copy-question.json an dein save_response und gibt die Datei aus:

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.

Das ist die ganze Antwort, so wie der Client sie gesehen hat. Deine Datei hat eine andere id und eine andere created-Zeit, weil der Dienst jeder Antwort neue gibt. Der Code des Kurses liest vier Dinge daraus, und nur diese: choices[0].message.content, hier das CitedAnswer-JSON als String; choices[0].message.tool_calls, hier null; choices[0].finish_reason; und usage, hier 327 + 43 = 370 Tokens. Der Rest, von logprobs bis system_fingerprint, ist da, weil die Klasse des Clients diese Felder hat.

Die Demonstration hält dann bei Lektion 6 an.

Spiele sie in einem Test erneut ab

fakes.from_recorded(path) liest eine solche Datei und baut daraus eine Fake-Antwort, wobei nur die vier oben genannten Dinge erhalten bleiben. Es akzeptiert die model_dump_json-Ausgabe des Clients, so wie du sie gerade gespeichert hast, und auch einen Antwort-Body, wie der Dienst ihn über HTTP gesendet hat. tests/recordings/live-lists-note.json, die erste der Live-Antworten aus Lektion 1, ist so ein Body: Er kam von OpenRouter, mit zusätzlichen Feldern wie provider, native_finish_reason und cost, die dieser Kurs nie liest. Er lässt sich genauso abspielen.

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

Die Pfade sind relativ zum Projektordner, so wie NOTES_DIR = Path("notes") in retrieval.py. Das ist der Ordner, aus dem du pytest ausführst, und der Ordner, in dem die Prüfung deiner Arbeit deine Tests ausführt, also funktionieren dieselben Pfade an beiden Stellen.

Jetzt du

Schreibe in tests/test_recorded.py zwei Tests:

  1. Spiele tests/recordings/copy-question.json über answer_from_notes(question, load_notes(), client=client, k=3) ab, mit der Kopierfrage How do I make an independent copy of a list?, und prüfe, dass die Quellenangaben ["03-lists#4"] sind.

  2. Spiele tests/recordings/live-lists-note.json über ask ab und prüfe, dass es den aufgezeichneten Text zurückgibt. Tippe den Text nicht in den Test: Öffne die Aufzeichnung mit json.load und lies ihn aus ["choices"][0]["message"]["content"], damit der erwartete Wert der aus der Datei ist.

Wenn python evals.py llm-api nicht erreichen konnte, gibt es copy-question.json noch nicht, und dein erster Test schlägt mit FileNotFoundError fehl, bis ein Lauf davon gelingt. Die Prüfung deiner Arbeit verwendet eine eigene Kopie der Datei.

Führe sie aus:

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

Was du prüfen solltest und was nicht

Prüfe das, was der Kurs liest: den Inhalt, die Quellenangaben, die Tool-Aufrufe, die Usage. Prüfe nie id oder created. Sie ändern sich mit jeder Aufzeichnung, und die Kopie von copy-question.json, die die Prüfung deiner Arbeit verwendet, hat ihre eigenen.

Den aufgezeichneten Text zu prüfen ist hier sicher, anders als bei assert answer == expected aus Lektion 1, weil sich eine Aufzeichnung nie ändert. Der Test fragt das Modell nichts. Er prüft, wie dein Programm mit einer echten Antwort umgeht, also kann er nie sagen, ob das Modell gut antwortet. Wenn du einen Prompt änderst, zeichne neu auf: Eine alte Aufzeichnung beantwortet eine Anfrage, die dein Programm nicht mehr sendet.

Wie deine Arbeit geprüft wird

save_response wird mit zwei echten ChatCompletion-Objekten geprüft, eines mit Text und eines mit zwei Tool-Aufrufen. Die Datei muss die ganze Antwort als JSON enthalten, als UTF-8 zurückgelesen, fakes.from_recorded muss daraus denselben Inhalt, dieselben Tool-Aufrufe, denselben Finish-Reason und dieselbe Usage wieder aufbauen, und es darf nichts zurückgegeben werden.

Danach läuft tests/test_recorded.py in einer schreibgeschützten Kopie des Projekts, gegen den korrekten Code und zwei kaputte Versionen, und muss bei jeder fehlschlagen:

  • answer_from_notes gibt keine Quellenangaben zurück;

  • ask gibt "" statt des Antworttexts zurück.

Warum sollte ein Test einer Aufzeichnung nie ihre id oder ihr created prüfen?

Dein Test spielt copy-question.json über answer_from_notes ab und besteht. Was hat er gezeigt?

Aufgabe

  1. Schreibe in evals.py die Funktion save_response(response, path): Öffne path zum Schreiben mit encoding="utf-8", schreibe response.model_dump_json(indent=2) hinein und gib nichts zurück. Führe python evals.py in der Shell aus, um tests/recordings/copy-question.json aufzuzeichnen.

  2. Schreibe in tests/test_recorded.py zwei Tests mit fakes.from_recorded:

    • spiele tests/recordings/copy-question.json über answer_from_notes für die Kopierfrage mit load_notes() und k=3 ab und prüfe, dass die Quellenangaben ["03-lists#4"] sind;

    • spiele tests/recordings/live-lists-note.json über ask ab und prüfe, dass es den aufgezeichneten Text zurückgibt, gelesen aus der Datei mit json.load.

Prüfe nie id oder created. Führe python -m pytest -q tests/test_recorded.py aus und prüfe dann deine Arbeit.