Wird geladen
Wird geladen

Jetzt, da unser Evaluierungsdatensatz bereit ist, ist es an der Zeit, die Kern-Evaluierungspipeline zu bauen. Dabei wird jeder Testfall genommen, mit unserem Prompt zusammengeführt, an Claude übergeben und anschließend werden die Ergebnisse bewertet.

Ein Prompt mit einem Platzhalter für eine Frage, drei Testfragen wie "Was ist 2+2?" und Claudes Antworten wie "2 + 2 = 4".

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

Die Kernfunktionen erstellen

Die Evaluierungspipeline besteht aus drei Hauptfunktionen, von denen jede eine bestimmte Aufgabe hat. Beginnen wir mit der einfachsten - der Funktion, die die Ausführung einzelner Prompts übernimmt.

Die Funktion run_prompt

Diese Funktion nimmt einen Testfall und führt ihn mit unserer Prompt-Vorlage zusammen:

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

Im Moment halten wir den Prompt extrem einfach. Wir fügen keine Formatierungsanweisungen hinzu, was bedeutet, dass Claude wahrscheinlich eine ausführlichere Ausgabe zurückgibt, als wir benötigen. Wir werden das später verfeinern, während wir unseren Evaluierungsprozess weiterentwickeln.

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
    }

Im Moment verwenden wir einen fest codierten Score von 10. Die Bewertungslogik ist der Bereich, in den wir in den kommenden Abschnitten erheblich viel Zeit investieren werden, aber dieser Platzhalter ermöglicht es uns, die gesamte Pipeline-Struktur zu testen.

Die Funktion run_eval

Dies ist der Haupt-Orchestrator, der den gesamten Datensatz verarbeitet:

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 durchläuft jeden Testfall in unserem Datensatz, verarbeitet jeden einzelnen und sammelt alle Ergebnisse in einer einzigen Liste.

Die Evaluierung ausführen

Um unsere Evaluierungspipeline auszuführen, laden wir den Datensatz und rufen unsere Hauptfunktion auf:

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 einige Zeit dauert - selbst mit Claude Haiku kann die Verarbeitung eines vollständigen Datensatzes 30+ Sekunden dauern. Optimierungstechniken behandeln wir später, aber im Moment ist Geduld der Schlüssel.

Die Ergebnisse untersuchen

Sobald die Evaluierung abgeschlossen ist, kannst du die Ergebnisse mit formatierter JSON-Ausgabe untersuchen:

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

Ein Prompt mit einem Platzhalter für eine Frage, drei Testfragen wie "Was ist 2+2?" und Claudes Antworten wie "2 + 2 = 4".

Die Ergebnisstruktur enthält ein Array von Objekten, wobei jedes Objekt die Ausführung eines Testfalls darstellt. Du siehst die Claude-Ausgabe (die ohne Formatierungsvorgaben tendenziell recht ausführlich ausfällt), die ursprüngliche Testfall-Definition und den Score.

Die Grader-Stufe der Eval-Pipeline hervorgehoben: die drei Frage-Antwort-Paare gehen in einen Grader, bewertet mit 10, 4 und 9.

Was wir erreicht haben

An diesem Punkt haben wir die Kern-Evaluierungspipeline erfolgreich implementiert. Wir können:

  • Testfälle aus unserem Datensatz nehmen
  • Sie mit Prompt-Vorlagen zusammenführen
  • Antworten von Claude erhalten
  • Alle Ergebnisse sammeln und organisieren

Das fehlende Teil ist eine intelligente Bewertung - im Moment vergeben wir nur einen festen Score für jede Antwort. Der nächste Schritt besteht darin, Grader zu bauen, die tatsächlich bewerten können, ob Claudes Ausgaben korrekt sind, und genau hier kommt die eigentliche Raffinesse von Evaluierungssystemen ins Spiel.

Diese Pipeline-Struktur mag einfach erscheinen, aber sie stellt die Grundlage dar, auf der die meisten KI-Evaluierungssysteme aufgebaut sind. Die Komplexität liegt in der Bewertungslogik und der Prompt-Optimierung, nicht in der grundlegenden Orchestrierung der Testausführung.