Wird geladen
Wird geladen

Beim Aufbau von Workflows zur Prompt-Bewertung liefern Bewertungssysteme objektive Signale über die Qualität der Ausgabe. Ein Grader nimmt die Modellausgabe entgegen und gibt eine Art messbares Feedback zurück - typischerweise eine Zahl zwischen 1 und 10, wobei 10 hohe Qualität und 1 schlechte Qualität darstellt.

Arten von Gradern

Code-, Modell- und menschliche Grader im Vergleich; Modell- und menschliche Grader können auch zwei Versionen einer Ausgabe vergleichen, wie unten beschrieben.

Es gibt drei Hauptansätze zur Bewertung von Modellausgaben:

  • Code-Grader - Bewerten Ausgaben programmatisch mithilfe von benutzerdefinierter Logik
  • Modell-Grader - Verwenden ein anderes KI-Modell zur Qualitätsbewertung
  • Menschliche Grader - Lassen Personen die Ausgaben manuell überprüfen und bewerten

Code-Grader

Code-Grader ermöglichen es dir, jede programmatische Prüfung zu implementieren, die du dir vorstellen kannst. Häufige Anwendungsfälle sind:

  • Überprüfung der Ausgabelänge
  • Überprüfung, ob die Ausgabe bestimmte Wörter enthält/nicht enthält
  • Syntaxvalidierung für JSON, Python oder Regex
  • Lesbarkeitswerte

Die einzige Anforderung ist, dass dein Code ein nutzbares Signal zurückgibt - normalerweise eine Zahl zwischen 1 und 10.

Modell-Grader

Modell-Grader speisen deine ursprüngliche Ausgabe in einen weiteren API-Aufruf zur Bewertung ein. Dieser Ansatz bietet enorme Flexibilität bei der Bewertung von:

  • Antwortqualität
  • Qualität der Befolgung von Anweisungen
  • Vollständigkeit
  • Hilfsbereitschaft
  • Sicherheit

Menschliche Grader

Menschliche Grader bieten die größte Flexibilität, sind aber zeitaufwändig und mühsam. Sie sind nützlich für die Bewertung von:

  • Allgemeiner Antwortqualität
  • Umfassendheit
  • Tiefe
  • Prägnanz
  • Relevanz

Definition von Bewertungskriterien

"Woher wissen wir, ob unser Prompt gute Ausgaben produziert?" beantwortet durch die drei unten beschriebenen Kriterien.

Bevor du einen Grader implementierst, benötigst du klare Bewertungskriterien. Bei einem Prompt zur Codegenerierung könntest du dich auf Folgendes konzentrieren:

  • Format - Sollte nur Python, JSON oder Regex ohne Erklärung zurückgeben
  • Gültige Syntax - Der erzeugte Code sollte eine gültige Syntax haben
  • Aufgabenbefolgung - Die Antwort sollte die Aufgabe des Benutzers direkt mit korrektem Code adressieren

"Format" und "Gültige Syntax" werden unter einem Code-Grader gruppiert und "Aufgabenbefolgung" unter einem Modell-Grader, wie unten erklärt.

Die ersten beiden Kriterien funktionieren gut mit Code-Gradern, während sich die Aufgabenbefolgung aufgrund ihrer Flexibilität besser für Modell-Grader eignet.

Implementierung eines Modell-Graders

So baust du eine Modell-Grader-Funktion:

python
def grade_by_model(test_case, output):
    # Evaluierungsprompt erstellen
    eval_prompt = f"""
    You are an expert code reviewer. Evaluate this AI-generated solution.
    
    Task: {test_case["task"]}
    Solution: {output}
    
    Provide your evaluation as a structured JSON object with:
    - "strengths": An array of 1-3 key strengths
    - "weaknesses": An array of 1-3 key areas for improvement  
    - "reasoning": A concise explanation of your assessment
    - "score": A number between 1-10
    """
    
    messages = []
    add_user_message(messages, eval_prompt)
    add_assistant_message(messages, "```json")

    eval_text = chat(messages, stop_sequences=["```"])
    return json.loads(eval_text)

Die wichtigste Erkenntnis ist, neben der Bewertung auch nach Stärken, Schwächen und Begründung zu fragen. Ohne diesen Kontext neigen Modelle dazu, standardmäßig mittelmäßige Bewertungen um 6 zu vergeben.

Integration der Bewertung in deinen Workflow

Aktualisiere deinen Testfall-Runner, um den Grader aufzurufen:

python
def run_test_case(test_case):
    output = run_prompt(test_case)

    # Bewerte die Ausgabe
    model_grade = grade_by_model(test_case, output)
    score = model_grade["score"]
    reasoning = model_grade["reasoning"]

    return {
        "output": output,
        "test_case": test_case,
        "score": score,
        "reasoning": reasoning
    }

Berechne abschließend einen durchschnittlichen Score über alle Testfälle hinweg:

python
from statistics import mean

def run_eval(dataset):
    results = []

    for test_case in dataset:
        result = run_test_case(test_case)
        results.append(result)

    average_score = mean([result["score"] for result in results])
    print(f"Average score: {average_score}")

    return results

Dies gibt dir eine objektive Metrik, die du verfolgen kannst, während du deinen Prompt iterierst. Modell-Grader können zwar etwas launisch sein, bieten aber eine konsistente Baseline zur Messung von Verbesserungen.