Judge-Modelle mit menschlichen Bewertungen kalibrieren
Sammeln Sie einen Ground-Truth-Datensatz mit menschlichen Präferenzurteilen, messen Sie die Übereinstimmung zwischen Bewertenden und Menschen mit Cohens Kappa und optimieren Sie den Judge per Prompt-Tuning, um systematische Verzerrungen zu reduzieren.
Judge-Modelle mit menschlichen Bewertungen kalibrieren ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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 Kalibrierung unverzichtbar ist
Ein nicht kalibrierter LLM-Judge kann Ausgaben systematisch höher oder niedriger bewerten als Menschen, einen bestimmten Schreibstil bevorzugen oder bei Grenzfällen versagen, die Ihre Bewertungsrichtlinie nicht berücksichtigt. Wenn Sie einen solchen Judge für Bereitstellungsentscheidungen verwenden, vertrauen Sie einem verzerrten Messinstrument. Die Kalibrierung validiert den Judge anhand menschlicher Referenzwerte und quantifiziert, wie sehr Sie seinen Bewertungen vertrauen können, bevor Sie sich in der Produktion darauf verlassen.
Einen Kalibrierungsdatensatz erstellen
Erstellen Sie einen Kalibrierungssatz mit 100–500 Beispielantworten, die von Menschen bewertet wurden. Achten Sie auf Vielfalt: Nehmen Sie hochwertige Antworten (Bewertung 5), Antworten mittlerer Qualität (Bewertung 3) und eindeutig schlechte Antworten (Bewertung 1) auf. Lassen Sie jedes Beispiel von 3–5 unabhängigen menschlichen Bewertern bewerten, um die Übereinstimmung zwischen den Bewertern zu messen, und berechnen Sie einen konsensbasierten Referenzwert, indem Sie den Durchschnitt oder den Modalwert verwenden.
# Calibration dataset structure:
# [
# {
# 'question': 'What causes inflation?',
# 'response': '...',
# 'human_scores': [4, 4, 3, 5, 4], # 5 raters
# 'human_consensus': 4, # mean or mode
# 'rater_ids': ['r1', 'r2', 'r3', 'r4', 'r5']
# },
# ...
# ]
# Typical calibration set composition:
# 30% excellent responses (score 4-5)
# 40% adequate responses (score 2-4)
# 30% poor responses (score 1-2)
# Include adversarial / edge casesÜbereinstimmung zwischen Bewertern messen
Bevor Sie menschliche Bewertungen als Referenzwerte verwenden, prüfen Sie, ob die menschlichen Bewerter untereinander übereinstimmen. Cohens Kappa misst die über den Zufall hinausgehende Übereinstimmung zwischen zwei Bewertern: Ein Wert über 0,6 ist akzeptabel, über 0,8 ist ausgezeichnet. Verwenden Sie bei 5-stufigen Skalen ein gewichtetes Kappa (lineare Gewichte). Eine geringe Übereinstimmung zwischen den Bewertern bedeutet, dass die Aufgabe nicht eindeutig definiert ist — verbessern Sie die Richtlinien für die Bewerter, bevor Sie die Bewertungen zur Kalibrierung eines Judges verwenden.
from sklearn.metrics import cohen_kappa_score
import numpy as np
def measure_inter_rater_agreement(rater1_scores: list, rater2_scores: list) -> dict:
kappa = cohen_kappa_score(rater1_scores, rater2_scores, weights='linear')
exact_agreement = sum(a == b for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
adjacent_agreement = sum(abs(a - b) <= 1 for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
return {
'weighted_kappa': round(kappa, 3),
'exact_agreement': round(exact_agreement, 3),
'adjacent_agreement': round(adjacent_agreement, 3),
'acceptable': kappa >= 0.6
}Den Judge auf den Kalibrierungsdaten ausführen
Führen Sie Ihren LLM-Judge für jedes Beispiel im Kalibrierungssatz mit demselben Prompt aus, den Sie in der Produktion verwenden möchten. Erfassen Sie für jedes Beispiel neben dem menschlichen Konsenswert auch die Bewertung des Judges. Halten Sie diese beiden Listen synchron, damit Sie sie Element für Element vergleichen können. Dieser paarweise Vergleich macht systematische Verzerrungen und Unterschiede im Bewertungsbereich sichtbar.
async def run_judge_on_calibration(calibration_set: list) -> list:
pairs = []
for item in calibration_set:
judge_result = await async_judge(item['question'], item['response'])
pairs.append({
'question': item['question'],
'human': item['human_consensus'],
'judge': judge_result.correctness,
'judge_rationale': judge_result.rationale
})
return pairsKorrelation zwischen Judge und Menschen berechnen
Berechnen Sie die Pearson-Korrelation zwischen den Bewertungen des Judges und den menschlichen Konsenswerten. Damit messen Sie die lineare Übereinstimmung: Eine Korrelation von 1,0 bedeutet, dass der Judge die Rangfolge der menschlichen Bewertungen perfekt nachbildet. Berechnen Sie außerdem den mittleren absoluten Fehler (MAE), um die durchschnittliche Bewertungsabweichung zu ermitteln. Eine Korrelation über 0,7 und ein MAE unter 0,8 Punkten auf einer 5-Punkte-Skala weisen typischerweise auf einen Judge hin, der zuverlässig genug für den Produktionseinsatz ist.
from scipy.stats import pearsonr, spearmanr
import numpy as np
def calibration_metrics(pairs: list) -> dict:
humans = [p['human'] for p in pairs]
judges = [p['judge'] for p in pairs]
pearson_r, p_val = pearsonr(humans, judges)
spearman_r, _ = spearmanr(humans, judges)
mae = np.mean([abs(h - j) for h, j in zip(humans, judges)])
return {
'pearson_r': round(pearson_r, 3),
'spearman_r': round(spearman_r, 3),
'p_value': round(p_val, 5),
'mae': round(mae, 3),
'reliable': pearson_r >= 0.7 and mae <= 0.8
}Systematische Verzerrungen erkennen
Untersuchen Sie zusätzlich zur Korrelation systematische Verzerrungen: Bewertet der Judge durchgehend zu hoch oder zu niedrig? Stellen Sie die Bewertungen des Judges den menschlichen Bewertungen gegenüber und achten Sie auf eine Regressionsgerade, die nicht durch den Ursprung verläuft. Wenn der Judge dort, wo Menschen durchschnittlich 3 vergeben, eine 4 vergibt, weist er eine Aufwärtsverzerrung auf. Korrigieren Sie dies, indem Sie entweder die Bewertungsrichtlinie anpassen oder eine lineare Kalibrierungstransformation auf die Rohbewertungen anwenden.
import numpy as np
from scipy import stats
def detect_score_bias(pairs: list) -> dict:
humans = np.array([p['human'] for p in pairs])
judges = np.array([p['judge'] for p in pairs])
slope, intercept, r, p, se = stats.linregress(judges, humans)
bias = np.mean(judges - humans) # positive = judge over-scores
return {
'mean_bias': round(bias, 3), # > 0 means judge inflates
'calibration_slope': round(slope, 3),
'calibration_intercept': round(intercept, 3),
# Corrected score = slope * judge_score + intercept
'correction_formula': f'human_score ≈ {slope:.2f} * judge + {intercept:.2f}'
}Kalibrierungskorrektur anwenden
Sobald Sie die Kalibrierungsregression (Steigung und Achsenabschnitt) bestimmt haben, wenden Sie sie an, um die Rohbewertungen des Judges in kalibrierte Bewertungen umzuwandeln, die besser mit den menschlichen Bewertungen übereinstimmen. Diese lineare Korrektur ist einfach und effektiv. Begrenzen Sie die korrigierte Bewertung auf den gültigen Bereich (1–5), damit die Regression keine Werte außerhalb des Bereichs erzeugt. Speichern Sie sowohl die Rohbewertungen als auch die korrigierten Bewertungen, um spätere Vergleiche zu ermöglichen, während der Kalibrierungsdatensatz wächst.
def calibrate_score(raw_judge_score: float, slope: float, intercept: float,
min_score: int = 1, max_score: int = 5) -> float:
corrected = slope * raw_judge_score + intercept
return max(min_score, min(max_score, round(corrected, 1)))
# Example: if judge inflates by 0.5 points on average
# slope=0.85, intercept=0.3
# raw_score=4 -> corrected = 0.85*4 + 0.3 = 3.7Muster systematischer Fehler finden
Gruppieren Sie Kalibrierungsfehler nach Fragetyp, Antwortlänge und Themenbereich, um systematische Fehlermuster zu erkennen. Der Judge kann bei technischen Programmierfragen unzuverlässig, bei faktischen Fragen jedoch präzise sein. Möglicherweise bewertet er sehr lange Antworten zu hoch, kurze und prägnante Antworten dagegen zu niedrig. Diese Muster liefern Hinweise für gezielte Verbesserungen der Bewertungsrichtlinie oder themenspezifische Judge-Prompts in den Bereichen mit der schwächsten Kalibrierung.
from collections import defaultdict
def error_by_category(pairs: list) -> dict:
by_cat = defaultdict(list)
for p in pairs:
error = abs(p['judge'] - p['human'])
by_cat[p.get('category', 'unknown')].append(error)
return {
cat: {
'mean_error': round(sum(errs)/len(errs), 2),
'max_error': max(errs),
'n': len(errs)
}
for cat, errs in by_cat.items()
}Mit wachsendem Datensatz neu kalibrieren
Die Kalibrierung ist keine einmalige Aufgabe. Wenn Sie weitere menschliche Bewertungen sammeln und Modell-Updates das Verhalten des Judges verändern, führen Sie die Kalibrierung vierteljährlich erneut aus. Beobachten Sie die Kalibrierungsmetriken im Zeitverlauf — fällt die Pearson-Korrelation unter 0,7, prüfen Sie, ob ein Modell-Update die Bewertungsverteilung des Judges verändert hat. Automatisieren Sie die Kalibrierungspipeline, sodass ihre erneute Ausführung mit einem einzigen Befehl möglich ist und einen aktualisierten Korrekturkoeffizienten erzeugt.
def run_calibration_pipeline(calibration_data: list) -> dict:
# 1. Measure human inter-rater agreement
ira = measure_inter_rater_agreement(
[d['rater_1'] for d in calibration_data],
[d['rater_2'] for d in calibration_data]
)
# 2. Run judge on all items
pairs = run_judge_on_calibration(calibration_data)
# 3. Compute correlation metrics
metrics = calibration_metrics(pairs)
# 4. Detect bias
bias = detect_score_bias(pairs)
return {'ira': ira, 'metrics': metrics, 'bias': bias}Die Judge-Konfiguration dokumentieren
Dokumentieren Sie das Judge-Modell, die Prompt-Version, Größe und Datum des Kalibrierungsdatensatzes, die Kalibrierungsmetriken und alle Korrekturkoeffizienten in einer Judge-Konfigurationsdatei, die in der Versionsverwaltung eingecheckt wird. So entsteht ein Prüfpfad, anhand dessen zukünftige Teammitglieder nachvollziehen können, warum Bewertungen so ausfallen, und erkennen können, ob Änderungen an den Metriken auf eine Neukonfiguration des Judges oder auf echte Qualitätsveränderungen zurückzuführen sind.
# judge_config.yaml
# judge_model: gpt-4o-2025-01-01
# judge_prompt_version: v3.2
# calibration_date: 2026-05-15
# calibration_set_size: 312
# calibration_metrics:
# pearson_r: 0.81
# spearman_r: 0.79
# mae: 0.54
# bias_correction:
# slope: 0.88
# intercept: 0.45
# next_recalibration: 2026-08-15Dimensionsspezifische Judge-Prompts
Ein einzelner Judge-Prompt, der mehrere Dimensionen gleichzeitig bewertet, führt oft zu korrelierten Bewertungen – der Judge bewertet die Korrektheit hoch, weil er zuvor die Klarheit hoch bewertet hat, und orientiert sich dabei an seinem ersten Eindruck. Dimensionsspezifische Prompts bewerten jedes Kriterium unabhängig voneinander in einem separaten API-Aufruf. Das ist teurer, liefert aber zuverlässigere Bewertungen, die tatsächlich unabhängige Messungen darstellen. Verwenden Sie separate Prompts für Dimensionen, bei denen Sie erwarten, dass die Bewertungen unabhängig voneinander variieren.
async def multi_dimension_judge(question: str, answer: str) -> dict:
# Run each dimension as a separate judge call
correctness, helpfulness, clarity = await asyncio.gather(
judge_single_dimension(question, answer, 'correctness'),
judge_single_dimension(question, answer, 'helpfulness'),
judge_single_dimension(question, answer, 'clarity')
)
return {
'correctness': correctness,
'helpfulness': helpfulness,
'clarity': clarity,
'composite': 0.5 * correctness + 0.3 * helpfulness + 0.2 * clarity
}Kurzer Test
Testen Sie Ihr Verständnis der Kalibrierung von LLM-Judge-Modellen anhand menschlicher Bewertungen.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Kalibrierungsdatensätze mit menschlichen Konsenswerten liefern die Ground Truth, um die Zuverlässigkeit des Judges zu messen; Pearson-Korrelation und MAE quantifizieren, wie gut der Judge menschliche Bewertungen abbildet; und lineare Bias-Korrektur gleicht systematische Über- oder Unterbewertungen aus. Als Nächstes erstellen wir eine kontinuierliche Evaluations-Pipeline, die in CI/CD integriert ist.
Häufig gestellte Fragen
Ist die Lektion „Judge-Modelle mit menschlichen Bewertungen kalibrieren“ kostenlos?
Ja — der vollständige Text von „Judge-Modelle mit menschlichen Bewertungen kalibrieren“ 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 „Judge-Modelle mit menschlichen Bewertungen kalibrieren“?
Sammeln Sie einen Ground-Truth-Datensatz mit menschlichen Präferenzurteilen, messen Sie die Übereinstimmung zwischen Bewertenden und Menschen mit Cohens Kappa und optimieren Sie den Judge per Prompt-… 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 3 von 4.
Wie lange dauert die Lektion „Judge-Modelle mit menschlichen Bewertungen kalibrieren“?
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