Claude Academy
Wird geladen

Den Eval ausführen

Lektion 1215 Min.

Jetzt, wo unser Evaluierungsdatensatz bereit ist, ist es Zeit, die zentrale Evaluierungspipeline zu erstellen. 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 Workflow: 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 erstellen

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 zurückgibt, als wir benötigen. Wir werden dies später verfeinern, wenn 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 hartcodierten Score von 10. Die Bewertungslogik ist der Bereich, in dem wir in den kommenden Abschnitten viel 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 führen ihn durch unsere Funktionen:

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

results = run_eval(dataset)

Wenn du dies zum ersten Mal ausführst, erwarte, dass es etwas Zeit braucht – selbst mit Claude Haiku kann es etwa 30 Sekunden dauern, um einen vollständigen Datensatz zu verarbeiten. Wir werden Optimierungstechniken später behandeln.

Die Ergebnisse untersuchen

Die Evaluierung gibt 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 hartcodiert)

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

Was wir erreicht haben

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

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

Als Nächstes werden wir uns mit dem entscheidenden Thema der Grader beschäftigen, die unsere hartcodierten Scores in aussagekräftige Bewertungen der Leistung von Claude verwandeln werden.