Claude Academy
Wird geladen

Den Eval ausführen

Lektion 1315 Min.

Jetzt, wo unser Evaluierungsdatensatz bereit ist, ist es Zeit, die zentrale Evaluierungspipeline zu bauen. Dabei nehmen wir jeden Testfall, kombinieren ihn mit unserem Prompt, geben ihn an Claude weiter und bewerten anschließend die Ergebnisse.

Der Evaluierungsprozess folgt einem klaren Ablauf: Wir nehmen unseren Datensatz mit Testfällen, kombinieren jeden davon mit unserer Prompt-Vorlage, senden ihn zur Verarbeitung an Claude und bewerten dann die Ausgabe mithilfe eines Grader-Systems.

Die Kernfunktionen aufbauen

Die Evaluierungspipeline besteht aus drei Hauptfunktionen, jede mit einer spezifischen Aufgabe. Beginnen wir mit der einfachsten – der Funktion, die einzelne Prompts verarbeitet.

Die Funktion run_prompt

Diese Funktion nimmt einen Testfall und kombiniert ihn mit unserer Prompt-Vorlage:

python
def run_prompt(test_case):
    """Merges the prompt and test case input, then returns the result"""
    prompt = f"""
Please solve the following task:

{test_case["task"]}
"""
    
    messages = []
    add_user_message(messages, prompt)
    output = chat(messages)
    return output

Momentan halten wir den Prompt extrem einfach. Wir fügen keine Formatierungsanweisungen hinzu, sodass Claude wahrscheinlich ausführlichere Ausgaben liefert, als wir benötigen. Wir werden das später verfeinern, während wir unser Prompt-Design iterieren.

Die Funktion run_test_case

Diese Funktion orchestriert die Ausführung eines einzelnen Testfalls und die Bewertung des Ergebnisses:

python
def run_test_case(test_case):
    """Calls run_prompt, then grades the result"""
    output = run_prompt(test_case)
    
    # TODO - Bewertung
    score = 10
    
    return {
        "output": output,
        "test_case": test_case,
        "score": score
    }

Vorerst verwenden wir einen fest codierten Score von 10. Die Bewertungslogik ist der Bereich, in dem wir in den kommenden Abschnitten erheblich Zeit verbringen werden, aber dieser Platzhalter erlaubt es uns, die gesamte Pipeline zu testen.

Die Funktion run_eval

Diese Funktion koordiniert den gesamten Evaluierungsprozess:

python
def run_eval(dataset):
    """Loads the dataset and calls run_test_case with each case"""
    results = []
    
    for test_case in dataset:
        result = run_test_case(test_case)
        results.append(result)
    
    return results

Diese Funktion verarbeitet jeden Testfall in unserem Datensatz und sammelt alle Ergebnisse in einer einzigen Liste.

Die Evaluierung ausführen

Um unsere Evaluierungspipeline auszuführen, laden wir unseren Datensatz und lassen ihn durch unsere Funktionen laufen:

python
with open("dataset.json", "r") as f:
    dataset = json.load(f)

results = run_eval(dataset)

Beim ersten Ausführen solltest du damit rechnen, dass es etwas Zeit braucht – selbst mit Claude Haiku kann es etwa 30 Sekunden dauern, einen vollständigen Datensatz zu verarbeiten. Wir werden später Optimierungstechniken behandeln.

Die Ergebnisse untersuchen

Die Evaluierung liefert ein strukturiertes JSON-Array zurück, bei dem jedes Objekt das Ergebnis eines Testfalls darstellt:

python
print(json.dumps(results, indent=2))

Jedes Ergebnis enthält drei wichtige Informationen:

  • output: Die vollständige Antwort von Claude
  • test_case: Der ursprüngliche Testfall, der verarbeitet wurde
  • score: Der Evaluierungsscore (derzeit fest codiert)

Wie du in der Ausgabe sehen kannst, generiert Claude recht ausführliche Antworten, da wir noch keine spezifischen Formatierungsanweisungen bereitgestellt haben. Genau das ist die Art von Problem, die wir angehen werden, während wir unsere Prompts verfeinern.

Was wir erreicht haben

An diesem Punkt haben wir erfolgreich die zentrale Evaluierungspipeline aufgebaut. Wir können unseren Datensatz nehmen, ihn durch Claude verarbeiten und strukturierte Ergebnisse sammeln. Das größte fehlende Stück ist das Bewertungssystem – dieser fest codierte Score von 10 muss durch tatsächliche Bewertungslogik ersetzt werden.

Diese Pipeline stellt die Grundlage der meisten KI-Evaluierungssysteme dar. Auch wenn sie einfach erscheinen mag, hast du gerade den Großteil dessen gebaut, was eine Eval-Pipeline tatsächlich leistet. Die Komplexität liegt in den Details – bessere Prompts, ausgefeiltere Bewertung und Leistungsoptimierungen.

Als Nächstes tauchen wir in das entscheidende Thema der Grader ein, die unsere fest codierten Scores in aussagekräftige Bewertungen der Leistung von Claude verwandeln werden.