Calibrare i modelli giudice rispetto alle valutazioni umane
Raccolga un dataset di riferimento con giudizi sulle preferenze umane, misuri l’accordo tra valutatore e giudizio umano con il Kappa di Cohen e ottimizzi il prompt del valutatore per ridurre i bias sistematici.
Calibrare i modelli giudice rispetto alle valutazioni umane è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.
Perché la calibrazione è imprescindibile
Un valutatore LLM non calibrato potrebbe assegnare sistematicamente punteggi più alti o più bassi rispetto alle persone, preferire uno specifico stile di scrittura oppure fallire nei casi limite non previsti dalla griglia di valutazione. Se utilizza un valutatore di questo tipo per prendere decisioni di deployment, si sta affidando a uno strumento viziato. La calibrazione convalida il valutatore rispetto a una ground truth umana e quantifica quanto sia possibile fidarsi dei suoi punteggi prima di utilizzarlo in produzione.
Creare un dataset di calibrazione
Crei un set di calibrazione composto da 100-500 risposte di esempio che siano state valutate da persone. Punti alla diversità: includa risposte di alta qualità (punteggio 5), di qualità media (punteggio 3) e chiaramente scadenti (punteggio 1). Chieda a 3-5 valutatori umani indipendenti di assegnare un punteggio a ogni esempio, così da misurare l'accordo tra valutatori e calcolare un punteggio di ground truth consensuale tramite la media o la moda.
# 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 casesMisurare l'accordo tra valutatori
Prima di considerare i punteggi umani come ground truth, verifichi che i valutatori umani concordino tra loro. Cohen's Kappa misura l'accordo tra due valutatori al netto di quello dovuto al caso: un valore superiore a 0,6 è accettabile, mentre uno superiore a 0,8 è eccellente. Per le scale a 5 punti, calcoli il kappa ponderato (con pesi lineari). Un basso accordo tra valutatori indica che l'attività è definita in modo ambiguo: migliori le linee guida per i valutatori prima di utilizzare i punteggi per calibrare un valutatore.
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
}Eseguire il valutatore sui dati di calibrazione
Esegua il valutatore LLM su ogni esempio del set di calibrazione utilizzando lo stesso prompt previsto per la produzione. Raccolga il punteggio del valutatore per ogni esempio insieme al punteggio consensuale umano. Mantenga allineati i due elenchi, in modo da poterli confrontare elemento per elemento. È questo confronto a coppie che rivela i bias sistematici e le differenze nell'intervallo dei punteggi.
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 pairsCalcolare la correlazione tra valutatore e persone
Calcoli la correlazione di Pearson tra i punteggi del valutatore e i punteggi consensuali umani. Questa misura l'accordo lineare: una correlazione pari a 1,0 significa che il valutatore segue perfettamente le classifiche umane. Calcoli anche l'errore assoluto medio (MAE) per comprendere il divario medio tra i punteggi. Una correlazione superiore a 0,7 e un MAE inferiore a 0,8 punti su una scala a 5 punti indicano in genere un valutatore sufficientemente affidabile per l'uso in produzione.
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
}Identificare i bias sistematici
Oltre alla correlazione, cerchi bias sistematici: il valutatore assegna costantemente punteggi troppo alti o troppo bassi? Rappresenti graficamente i punteggi del valutatore rispetto a quelli umani e verifichi se la retta di regressione non passa per l'origine. Se il valutatore assegna in media 4 quando le persone assegnano 3, presenta un bias di inflazione. Corregga questo problema modificando la griglia di valutazione oppure applicando una trasformazione di calibrazione lineare ai punteggi grezzi.
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}'
}Applicare la correzione di calibrazione
Una volta ottenuta la regressione di calibrazione (pendenza e intercetta), la applichi per trasformare i punteggi grezzi del valutatore in punteggi calibrati, più coerenti con i giudizi umani. Questa correzione lineare è semplice ed efficace. Limiti il punteggio corretto all'intervallo valido (1-5) per impedire che la regressione produca valori fuori intervallo. Conservi sia i punteggi grezzi sia quelli corretti, così da consentire confronti retrospettivi con la crescita dei dati di calibrazione.
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.7Individuare schemi di errore sistematici
Raggruppi gli errori di calibrazione per tipo di domanda, lunghezza della risposta e area tematica, così da individuare fallimenti ricorrenti. Il valutatore potrebbe essere inaffidabile nelle domande tecniche di programmazione ma accurato in quelle fattuali. Potrebbe assegnare punteggi troppo alti alle risposte molto lunghe e troppo bassi alle risposte brevi e concise. Questi schemi guidano miglioramenti mirati della griglia di valutazione o prompt specifici per argomento nei domini in cui la calibrazione è più debole.
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()
}Ricalibrare con la crescita dei dati
La calibrazione non è un'attività da svolgere una sola volta. Quando raccoglie più valutazioni umane e gli aggiornamenti del modello modificano il comportamento del valutatore, ripeta la calibrazione ogni trimestre. Monitori nel tempo le metriche di calibrazione: se la correlazione di Pearson scende al di sotto di 0,7, verifichi se un aggiornamento del modello ha modificato la distribuzione dei punteggi del valutatore. Automatizzi la pipeline di calibrazione, in modo che rieseguirla richieda un solo comando e produca un coefficiente di correzione aggiornato.
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}Documentare la configurazione del valutatore
Documenti il modello usato come valutatore, la versione del prompt, la dimensione e la data del dataset di calibrazione, le metriche di calibrazione e gli eventuali coefficienti di correzione in un file di configurazione del valutatore sottoposto al controllo versione. In questo modo crea una traccia di audit che consente ai membri futuri del team di capire perché i punteggi hanno quei valori e di distinguere i cambiamenti delle metriche dovuti alla riconfigurazione del valutatore da quelli dovuti a genuine variazioni della qualità.
# 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-15Prompt del valutatore specifici per dimensione
Un singolo prompt del valutatore che assegna punteggi a più dimensioni contemporaneamente produce spesso punteggi correlati: il valutatore assegna un punteggio alto alla correttezza perché ha assegnato un punteggio alto alla chiarezza, lasciandosi influenzare dalla prima impressione. I prompt specifici per dimensione valutano ogni criterio in modo indipendente, con una chiamata API separata. Questo approccio è più costoso, ma produce punteggi più affidabili e realmente indipendenti. Utilizzi prompt separati per le dimensioni i cui punteggi si prevede varino in modo indipendente.
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
}Controllo rapido
Verifichi la propria comprensione della calibrazione dei modelli LLM usati come valutatori rispetto alle valutazioni umane.
Riepilogo della lezione
In questa lezione ha imparato che i dataset di calibrazione con punteggi consensuali umani forniscono la ground truth per misurare l'affidabilità del valutatore; la correlazione di Pearson e il MAE quantificano quanto il valutatore segua i giudizi umani; e la correzione lineare del bias corregge l'assegnazione sistematica di punteggi troppo alti o troppo bassi. Nel prossimo modulo costruiremo una pipeline di valutazione continua integrata con CI/CD.
Domande Frequenti
La lezione «Calibrare i modelli giudice rispetto alle valutazioni umane» è gratuita?
Sì — il testo completo di «Calibrare i modelli giudice rispetto alle valutazioni umane» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.
Cosa imparerò in «Calibrare i modelli giudice rispetto alle valutazioni umane»?
Raccolga un dataset di riferimento con giudizi sulle preferenze umane, misuri l’accordo tra valutatore e giudizio umano con il Kappa di Cohen e ottimizzi il prompt del valutatore per ridurre i bias s… Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Engineering Academy?
Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Calibrare i modelli giudice rispetto alle valutazioni umane»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?
Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Il pattern LLM-as-Judge
- Valutazione pointwise e pairwise
- Calibrare i modelli giudice rispetto alle valutazioni umane
- Creazione di una pipeline di valutazione continua