Il pattern LLM-as-Judge
Comprenda come fornire a un LLM potente un prompt per valutare o confrontare gli output secondo criteri quali correttezza, utilità e tono, e perché questo approccio sia più scalabile della valutazione umana.
Il pattern LLM-as-Judge è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 1 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é è necessaria la valutazione automatizzata
La valutazione manuale degli output degli LLM è lenta e costosa. Un team di valutatori umani può analizzare alcune centinaia di output alla settimana, mentre un sistema in produzione ne genera migliaia al giorno. LLM-as-judge utilizza un potente modello linguistico per valutare su larga scala la qualità degli output di altri LLM, consentendo test di regressione automatizzati e un monitoraggio continuo della qualità senza dover assumere un esercito di annotatori.
L'idea fondamentale: un LLM valuta un altro LLM
Nel pattern LLM-as-judge, invia a un modello giudice un prompt di sistema che definisce i criteri di valutazione, la domanda originale, la risposta del modello e, facoltativamente, una risposta di riferimento. Il modello giudice restituisce un punteggio numerico, un'etichetta o una classifica. Questo approccio funziona perché i modelli allo stato dell'arte comprendono sufficientemente concetti di qualità come correttezza, utilità e coerenza.
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.
'''Scrittura di un prompt per il giudice
Un buon prompt per il giudice specifica rubriche esplicite con definizioni dei punteggi, invece di termini vaghi come 'buono' o 'cattivo'. Definisca concretamente che cosa significa un punteggio di 5, 3 o 1 per ogni criterio. Fornisca la domanda, la risposta da valutare e, facoltativamente, una risposta di riferimento. Chieda il ragionamento prima del punteggio (chain-of-thought) per ridurre le valutazioni arbitrarie.
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": "..."}}
'''Chiamata al modello giudice
Chiami il modello giudice con il prompt di valutazione. Analizzi la risposta JSON per estrarre i punteggi. Utilizzi sempre output strutturati o la modalità JSON per assicurarsi che il giudice restituisca dati analizzabili. L'utilizzo dello stesso modello sia come sistema sottoposto a test sia come giudice può introdurre distorsioni: preferisca un modello diverso o almeno una configurazione diversa per il giudice.
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)}
]
)Valutazione senza riferimento e basata su riferimento
Esistono due modalità di valutazione con LLM. La valutazione senza riferimento chiede al giudice di valutare la qualità senza una risposta corretta di riferimento, ed è utile quando non esiste una verità di base, come nelle chat a risposta aperta. La valutazione basata su riferimento fornisce una risposta standard e chiede se la risposta del modello corrisponde a essa: è più adatta alle domande fattuali per cui si conosce la risposta corretta. Utilizzi la modalità basata su riferimento quando dispone di un set di test etichettato.
# 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.'
)Controllo delle distorsioni del giudice
I giudici LLM presentano distorsioni note: preferiscono le risposte più lunghe (distorsione a favore della prolissità), le risposte dal tono sicuro e quelle che corrispondono allo stile dei dati di addestramento. Riduca la distorsione a favore della prolissità penalizzando esplicitamente nella rubrica la lunghezza non necessaria. Riduca la distorsione dell'ordine nei confronti a coppie randomizzando quale risposta viene mostrata per prima e calcolando la media dei punteggi ottenuti con entrambi gli ordini.
# 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'Raggruppamento delle valutazioni per aumentare la velocità
Esegua le valutazioni del giudice in parallelo per analizzare rapidamente set di test di grandi dimensioni. Con asyncio e un semaforo può valutare centinaia di output al minuto. Mantenga un budget separato per il limite di richieste delle chiamate al giudice (che consumano anch'esse token) e consideri l'utilizzo di un modello giudice più piccolo ma comunque efficace, come GPT-4o-mini, per i criteri che non richiedono un ragionamento approfondito, riservando GPT-4o ai criteri più importanti.
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
)Aggregazione dei punteggi del giudice
Dopo aver valutato un set di test, aggreghi i punteggi in statistiche riepilogative: media, mediana e percentuale di risposte con un punteggio superiore a una soglia di qualità, ad esempio correttezza ≥ 4. Confronti questi aggregati tra versioni del modello o varianti del prompt. Una diminuzione superiore al 5% nella percentuale oltre soglia dovrebbe attivare una revisione prima della distribuzione della nuova versione.
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)
}Confronto tra versioni LLM con il giudice
Utilizzi LLM-as-judge per confrontare due versioni del sistema, ad esempio prima e dopo una modifica al prompt. Esegua entrambe le versioni sullo stesso insieme di domande di test, valuti tutti gli output e calcoli il tasso di vittoria: la percentuale di casi in cui la versione B ottiene un punteggio superiore alla versione A. Un tasso di vittoria superiore al 55% su oltre 100 campioni è generalmente abbastanza significativo dal punto di vista statistico da giustificare la distribuzione della nuova versione.
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}Calibrazione dei punteggi del giudice rispetto alle valutazioni umane
Convalidi il giudice confrontando i suoi punteggi con le valutazioni umane su un set di calibrazione composto da 50-200 esempi. Calcoli la correlazione di Pearson tra i punteggi del giudice e quelli umani. Una correlazione superiore a 0.7 indica che il giudice è affidabile. Se la correlazione è bassa, esamini il prompt del giudice per individuare i casi in cui non concorda con gli esseri umani e aggiunga esempi o chiarimenti alla rubrica. Non distribuisca mai un giudice senza averlo calibrato.
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
}Quando non utilizzare LLM-as-judge
LLM-as-judge non è adatto a ogni scenario di valutazione. Lo eviti quando: il criterio richiede competenze di dominio che il modello giudice non possiede, come l'accuratezza di una diagnosi medica o la conformità legale; serve una valutazione difendibile sul piano giuridico, per la quale è necessaria una revisione umana; si valuta un modello più potente del giudice, che non può assegnare in modo affidabile un punteggio a un output che non sarebbe in grado di produrre; oppure il budget di valutazione è troppo limitato per sostenere il costo API aggiuntivo. In questi casi utilizzi la valutazione umana o metriche deterministiche.
# 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 levelVerifica rapida
Verifichi la propria comprensione del pattern di valutazione LLM-as-judge.
Riepilogo della lezione
In questa lezione ha appreso che LLM-as-judge utilizza un modello potente per valutare la qualità su larga scala mediante rubriche esplicite; le modalità senza riferimento e basata su riferimento sono adatte a scenari di valutazione diversi; e la calibrazione rispetto alle valutazioni umane convalida l'affidabilità del giudice prima del suo utilizzo in produzione. Nel prossimo argomento implementeremo strategie di valutazione puntuale e a coppie.
Domande Frequenti
La lezione «Il pattern LLM-as-Judge» è gratuita?
Sì — il testo completo di «Il pattern LLM-as-Judge» è 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 «Il pattern LLM-as-Judge»?
Comprenda come fornire a un LLM potente un prompt per valutare o confrontare gli output secondo criteri quali correttezza, utilità e tono, e perché questo approccio sia più scalabile della valutazion… 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 1 di 4.
Quanto tempo richiede la lezione «Il pattern LLM-as-Judge»?
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