Das LLM-as-Judge-Muster
Verstehen Sie, wie Sie ein leistungsfähiges LLM dazu auffordern, Ausgaben anhand von Kriterien wie Korrektheit, Hilfsbereitschaft und Ton zu bewerten oder zu vergleichen, und warum dieser Ansatz besser skaliert als eine menschliche Bewertung.
Das LLM-as-Judge-Muster ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum automatisierte Bewertung notwendig ist
Die manuelle Bewertung von LLM-Ausgaben ist langsam und teuer. Ein Team menschlicher Bewerter kann einige hundert Ausgaben pro Woche bewerten, ein Produktivsystem erzeugt jedoch Tausende pro Tag. LLM-as-judge verwendet ein leistungsfähiges Sprachmodell, um die Qualität anderer LLM-Ausgaben in großem Maßstab zu bewerten. Dadurch werden automatisierte Regressionstests und eine kontinuierliche Qualitätsüberwachung möglich, ohne eine große Zahl von Annotatoren einzustellen.
Die Grundidee: Ein LLM bewertet ein anderes
Bei LLM-as-judge senden Sie einem Judge-Modell (typischerweise GPT-4o oder Claude) einen System-Prompt mit den Bewertungskriterien, der ursprünglichen Frage, der Modellantwort und optional einer Referenzantwort. Das Judge-Modell gibt eine numerische Bewertung, ein Label oder eine Rangfolge zurück. Das funktioniert, weil hochmoderne Modelle Qualitätskonzepte wie Korrektheit, Nützlichkeit und Kohärenz ausreichend gut verstehen.
JUDGE_SYSTEM_PROMPT = '''
You are an expert evaluator of AI-generated responses.
Given a question and an AI-generated answer, score the answer on:
- Correctness (0-5): Is the information factually accurate?
- Completeness (0-5): Does it fully address the question?
- Clarity (0-5): Is it easy to understand?
Return a JSON object with scores and a brief rationale.
'''Einen Judge-Prompt verfassen
Ein guter Judge-Prompt definiert explizite Bewertungsschemata mit konkreten Bedeutungen der Punktzahlen, statt vager Begriffe wie „gut“ oder „schlecht“ zu verwenden. Legen Sie für jedes Kriterium konkret fest, was eine Bewertung von 5, 3 oder 1 bedeutet. Geben Sie die Frage, die zu bewertende Antwort und optional eine Referenzantwort an. Bitten Sie vor der Punktzahl um eine Begründung (Chain-of-Thought), um willkürliche Bewertungen zu reduzieren.
def build_judge_prompt(question: str, answer: str, reference: str = None) -> str:
ref_section = f'Reference answer:\n{reference}\n\n' if reference else ''
return f'''
Question: {question}
{ref_section}Answer to evaluate:
{answer}
Score this answer on correctness (1-5) where:
5 = Completely accurate, no factual errors
3 = Mostly accurate with minor errors
1 = Contains significant factual errors
First explain your reasoning, then provide the score as JSON:
{{"correctness": <1-5>, "rationale": "..."}}
'''Das Judge-Modell aufrufen
Rufen Sie das Judge-Modell mit Ihrem Bewertungs-Prompt auf. Parsen Sie die JSON-Antwort, um die Bewertungen zu extrahieren. Verwenden Sie immer strukturierte Ausgaben oder den JSON-Modus, damit das Judge-Modell parsebare Daten zurückgibt. Wenn dasselbe Modell sowohl das zu testende System als auch den Judge bildet, kann dies zu Verzerrungen führen – bevorzugen Sie ein anderes Modell oder zumindest eine andere Konfiguration für den Judge.
from pydantic import BaseModel
import instructor
from openai import OpenAI
class JudgeScore(BaseModel):
correctness: int
completeness: int
clarity: int
rationale: str
judge_client = instructor.from_openai(OpenAI())
def judge(question: str, answer: str) -> JudgeScore:
return judge_client.chat.completions.create(
model='gpt-4o', # Use stronger judge than the model being tested
response_model=JudgeScore,
messages=[
{'role': 'system', 'content': JUDGE_SYSTEM_PROMPT},
{'role': 'user', 'content': build_judge_prompt(question, answer)}
]
)Referenzfreie und referenzbasierte Bewertung
Bei der Bewertung durch LLMs gibt es zwei Modi. Bei der referenzfreien Bewertung soll der Judge die Qualität ohne eine Musterlösung bewerten – das ist nützlich, wenn keine Musterlösung existiert, etwa bei offenen Chats. Bei der referenzbasierten Bewertung wird eine Musterlösung bereitgestellt und geprüft, ob die Modellantwort mit ihr übereinstimmt – das eignet sich besser für faktische Fragen, bei denen eine korrekte Antwort bekannt ist. Verwenden Sie die referenzbasierte Bewertung, wenn Ihnen ein gelabelter Testsatz vorliegt.
# Reference-free: good for open-ended generation
judge_result = judge(question='What is machine learning?', answer=model_answer)
# Reference-based: better for factual QA
judge_result = judge(
question='What year was Python created?',
answer=model_answer,
reference='Python was created by Guido van Rossum and released in 1991.'
)Verzerrungen des Judges kontrollieren
LLM-Judges weisen bekannte Verzerrungen auf: Sie bevorzugen längere Antworten (Verzerrung zugunsten von Ausführlichkeit), selbstsicher klingende Antworten und Antworten, die dem Stil ihrer Trainingsdaten entsprechen. Verringern Sie die Verzerrung zugunsten von Ausführlichkeit, indem Sie unnötige Länge in Ihrem Bewertungsschema ausdrücklich abwerten. Reduzieren Sie bei paarweisen Vergleichen die Positionsverzerrung, indem Sie randomisieren, welche Antwort zuerst erscheint, und die Bewertungen beider Reihenfolgen mitteln.
# Anti-verbosity note in rubric:
ANTI_VERBOSITY_CLAUSE = '''
Note: A concise, accurate answer should score higher than a long,
rambling answer that happens to contain the correct information.
Do not reward length for its own sake.
'''
# Position-debiasing for pairwise comparison:
async def debiased_pairwise(q, a, b):
score_ab = await compare(q, answer_a=a, answer_b=b)
score_ba = await compare(q, answer_a=b, answer_b=a)
# A wins if it wins in both orderings
a_wins = (score_ab == 'A' and score_ba == 'B')
return 'A' if a_wins else 'B' if (score_ab == 'B' and score_ba == 'A') else 'tie'Bewertungen zur Beschleunigung bündeln
Führen Sie Judge-Bewertungen parallel aus, um große Testsätze schnell zu bewerten. Mit asyncio und einem Semaphore können Sie Hunderte Ausgaben pro Minute bewerten. Planen Sie ein separates Rate-Limit-Budget für Judge-Aufrufe ein (auch diese verbrauchen Tokens) und erwägen Sie für Kriterien ohne Bedarf an tiefgreifender Reasoning ein kleineres, aber weiterhin leistungsfähiges Judge-Modell wie GPT-4o-mini. GPT-4o bleibt dann den wichtigsten Kriterien vorbehalten.
import asyncio
async def batch_judge(qa_pairs: list, concurrency: int = 20) -> list:
sem = asyncio.Semaphore(concurrency)
async def judge_one(item):
async with sem:
return await async_judge(item['question'], item['answer'])
return await asyncio.gather(
*[judge_one(item) for item in qa_pairs],
return_exceptions=True
)Judge-Bewertungen aggregieren
Aggregieren Sie nach der Bewertung eines Testsatzes die Ergebnisse zu zusammenfassenden Statistiken: Mittelwert, Median und den Prozentsatz der Antworten oberhalb eines Qualitätsschwellenwerts (beispielsweise Korrektheit ≥ 4). Vergleichen Sie diese zusammengefassten Werte zwischen Modellversionen oder Prompt-Varianten. Ein Rückgang der Rate oberhalb des Schwellenwerts um mehr als 5 % sollte vor der Bereitstellung der neuen Version eine Überprüfung auslösen.
import statistics
def summarize_judge_results(scores: list) -> dict:
correctness = [s.correctness for s in scores if isinstance(s, JudgeScore)]
return {
'n': len(correctness),
'mean_correctness': round(statistics.mean(correctness), 2),
'median_correctness': statistics.median(correctness),
'pct_above_4': round(100 * sum(1 for s in correctness if s >= 4) / len(correctness), 1)
}LLM-Versionen mit einem Judge vergleichen
Verwenden Sie LLM-as-judge, um zwei Versionen Ihres Systems zu vergleichen – beispielsweise vor und nach einer Prompt-Änderung. Führen Sie beide Versionen mit demselben Satz von Testfragen aus, lassen Sie alle Ausgaben bewerten und berechnen Sie die Gewinnrate: den Prozentsatz der Fälle, in denen Version B eine höhere Bewertung als Version A erhält. Eine Gewinnrate von über 55 % bei mehr als 100 Stichproben ist typischerweise statistisch signifikant genug, um die Auslieferung der neuen Version zu rechtfertigen.
async def ab_compare(test_questions: list, version_a, version_b) -> dict:
a_wins = b_wins = ties = 0
for q in test_questions:
answer_a = await version_a.answer(q)
answer_b = await version_b.answer(q)
winner = await debiased_pairwise(q, answer_a, answer_b)
if winner == 'A': a_wins += 1
elif winner == 'B': b_wins += 1
else: ties += 1
total = len(test_questions)
return {'a_win_rate': a_wins/total, 'b_win_rate': b_wins/total, 'tie_rate': ties/total}Judge-Bewertungen mit menschlichen Bewertungen kalibrieren
Validieren Sie Ihren Judge, indem Sie seine Bewertungen mit menschlichen Bewertungen auf einem Kalibrierungsdatensatz mit 50–200 Beispielen vergleichen. Berechnen Sie die Pearson-Korrelation zwischen den Bewertungen des Judges und denen der Menschen. Eine Korrelation über 0,7 zeigt, dass der Judge zuverlässig ist. Wenn die Korrelation niedrig ist, prüfen Sie den Judge-Prompt, um festzustellen, wo er von den menschlichen Bewertungen abweicht, und ergänzen Sie Beispiele oder Erläuterungen in der Bewertungsrichtlinie. Setzen Sie niemals einen Judge ohne Kalibrierung produktiv ein.
from scipy.stats import pearsonr
def calibrate_judge(human_scores: list, judge_scores: list) -> dict:
corr, p_value = pearsonr(human_scores, judge_scores)
mean_abs_error = sum(abs(h - j) for h, j in zip(human_scores, judge_scores)) / len(human_scores)
return {
'pearson_r': round(corr, 3),
'p_value': round(p_value, 4),
'mean_abs_error': round(mean_abs_error, 2),
'reliable': corr >= 0.7
}Wann Sie LLM-as-Judge nicht verwenden sollten
LLM-as-Judge eignet sich nicht für jedes Evaluationsszenario. Vermeiden Sie es, wenn das Kriterium Fachwissen erfordert, über das das Judge-Modell nicht verfügt (etwa die Genauigkeit medizinischer Diagnosen oder die Einhaltung rechtlicher Vorgaben), wenn Sie eine rechtlich belastbare Evaluation benötigen (hier ist eine menschliche Prüfung erforderlich), wenn Sie ein Modell bewerten, das leistungsfähiger ist als der Judge (der Judge kann Ausgaben nicht zuverlässig bewerten, die er selbst nicht erzeugen könnte), oder wenn das Evaluationsbudget für die zusätzlichen API-Kosten zu knapp ist. Verwenden Sie in diesen Fällen eine menschliche Evaluation oder deterministische Metriken.
# Appropriate uses of LLM-as-judge:
# YES: General helpfulness, clarity, tone, factual accuracy (general knowledge)
# YES: Code correctness for common languages
# YES: Translation quality comparison
# YES: Content safety classification
#
# NOT appropriate:
# NO: Medical/legal/financial accuracy (needs domain expert)
# NO: Evaluating GPT-4o with GPT-4o (same capability ceiling)
# NO: Formal compliance audits (non-deterministic judge)
# NO: Streaming quality at individual token levelKurztest
Testen Sie Ihr Verständnis des Evaluationsmusters LLM-as-Judge.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: LLM-as-Judge verwendet ein leistungsstarkes Modell, um die Qualität mithilfe expliziter Bewertungsrichtlinien in großem Umfang zu evaluieren; referenzfreie und referenzbasierte Modi eignen sich für unterschiedliche Evaluationsszenarien; und die Kalibrierung anhand menschlicher Bewertungen bestätigt die Zuverlässigkeit Ihres Judges, bevor Sie ihn in der Produktion einsetzen. Als Nächstes implementieren wir punktweise und paarweise Evaluationsstrategien.
Häufig gestellte Fragen
Ist die Lektion „Das LLM-as-Judge-Muster“ kostenlos?
Ja — der vollständige Text von „Das LLM-as-Judge-Muster“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Das LLM-as-Judge-Muster“?
Verstehen Sie, wie Sie ein leistungsfähiges LLM dazu auffordern, Ausgaben anhand von Kriterien wie Korrektheit, Hilfsbereitschaft und Ton zu bewerten oder zu vergleichen, und warum dieser Ansatz bess… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Das LLM-as-Judge-Muster“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Das LLM-as-Judge-Muster
- Punktuelle und paarweise Evaluierung
- Judge-Modelle mit menschlichen Bewertungen kalibrieren
- Eine kontinuierliche Evaluationspipeline erstellen