Metriche e Benchmark
In questa pagina
Lezione aggiornata il 3 novembre 2026 sulla base della documentazione OpenAI:
temperatureetop_psono accettati solo con uno sforzo di ragionamento pari anone, mentre i modelli GPT-5.6 ragionano per impostazione predefinita (medium). Le chiamate che impostano questi parametri devono quindi specificarereasoning={"effort": "none"}(API Responses) oreasoning_effort="none"(Chat Completions). Fonti: Using GPT-6 · GPT-5.6 Terra.
Misurare la qualità con le metriche
Oltre ai punteggi LLM-as-Judge, esistono metriche quantitative per valutare diversi aspetti degli output degli LLM. Il loro valore non risiede in una maggiore accuratezza — un giudice LLM ben costruito coglie sfumature che nessuna formula potrà mai vedere — ma nella stabilità e nel basso costo. La similarità del coseno restituisce esattamente lo stesso numero a ogni esecuzione, costa quasi nulla e può quindi essere eseguita su migliaia di casi a ogni commit. Riservi poi il giudice LLM per le dimensioni che lo richiedono davvero.
Esamineremo le metriche essenziali prima di assemblarle in benchmark riproducibili.
Confrontare il significato, non le parole
Confrontare due testi carattere per carattere diventa inutilizzabile non appena la formulazione è libera. La similarità semantica aggira questo problema: ogni testo viene convertito in un vettore da un modello di embedding e misuriamo l’angolo tra i due vettori. Due frasi che dicono la stessa cosa con parole diverse puntano nella stessa direzione.
import openai
import numpy as np
client = openai.OpenAI()
def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
"""Calculates the cosine similarity between two vectors."""
a = np.array(vec_a)
b = np.array(vec_b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def semantic_similarity(text_a: str, text_b: str) -> float:
"""Measures the semantic similarity between two texts."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[text_a, text_b],
)
vec_a = response.data[0].embedding
vec_b = response.data[1].embedding
return cosine_similarity(vec_a, vec_b)
# Example
score = semantic_similarity(
"The cat is on the rug.",
"A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}") # ~0.85+
L’esempio è istruttivo: due frasi senza parole in comune ottengono un punteggio superiore a 0,85. Questa è la forza del metodo, ma anche la sua trappola. La similarità semantica ignora la negazione e le sfumature di grado: «il pagamento è stato accettato» e «il pagamento è stato rifiutato» appaiono molto simili a livello vettoriale. Pertanto, non usarla mai da sola per convalidare una risposta quando conta l’accuratezza fattuale.
Quando la domanda è «la risposta affronta effettivamente la questione posta?», nessuna formula sostituisce il giudizio. Il punteggio di rilevanza seguente scompone questo giudizio in tre domande distinte: la risposta è diretta? Rimane focalizzata? È completa? Questa scomposizione è migliore di un punteggio globale perché ti indica in quale direzione correggere il prompt: un modello verboso e un modello incompleto richiedono correzioni opposte.
def relevance_score(
question: str,
answer: str,
context: str | None = None,
) -> dict:
"""Evaluates whether the answer is relevant to the question."""
prompt = (
"Evaluate the relevance of this answer.\n\n"
f"Question: {question}\n"
)
if context:
prompt += f"Context provided: {context[:1000]}\n"
prompt += (
f"Answer: {answer}\n\n"
"Criteria:\n"
"1. Does the answer directly address the question? (0-5)\n"
"2. Does the answer contain unrequested information? (0-5, 5=none)\n"
"3. Is the answer complete? (0-5)\n\n"
"Respond in JSON with keys: direct, focus, completeness."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
import json
try:
scores = json.loads(response.output_text)
average = sum(scores.values()) / (len(scores) * 5)
return {"score": average, "details": scores}
except (json.JSONDecodeError, TypeError):
return {"score": 0, "error": "Parsing failed"}
Nota la formulazione invertita del secondo criterio, dove 5 significa «nessuna informazione non richiesta». Questo permette di sommare i tre punteggi nella stessa direzione, ma risulta controintuitivo alla lettura: quando aggiungi i tuoi criteri, mantieni questa convenzione, altrimenti otterrai medie che premiano il difetto che intendevi penalizzare.
Verificare che il modello non allucini
In un’applicazione di Q&A basata su documenti, la metrica decisiva non è la qualità della scrittura, ma la fedeltà alla fonte. Il principio di controllo è semplice: presentare al giudice il contesto originale e la risposta generata, e chiedergli di classificare ogni affermazione come supportata dal contesto, assente dal contesto o contraddittoria rispetto ad esso. La distinzione tra queste ultime due categorie conta, perché un’affermazione semplicemente assente potrebbe essere una conoscenza generale accurata, mentre un’affermazione che contraddice la fonte è sempre un errore.
def detect_hallucinations(
context: str,
answer: str,
) -> dict:
"""Detects statements not supported by the context."""
prompt = (
"Analyze this answer and identify any statement "
"that is NOT supported by the provided context.\n\n"
f"Context: {context[:3000]}\n\n"
f"Answer: {answer}\n\n"
"For each statement in the answer, indicate:\n"
"- supported: the statement is in the context\n"
"- unsupported: the statement is not in the context\n"
"- invented: the statement contradicts the context\n\n"
"Respond in JSON with the key statements (list) and "
"fidelity_score (0 to 1)."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
import json
try:
return json.loads(response.output_text)
except json.JSONDecodeError:
return {"fidelity_score": 0, "error": "Parsing failed"}
Troncare il contesto a 3.000 caratteri è un limite di cui devi essere consapevole: se la fonte supera questa dimensione, affermazioni perfettamente accurate verranno conteggiate come non supportate semplicemente perché il passaggio che le giustificava è stato tagliato. Per documenti lunghi, suddividi e valuta per sezione invece di accettare falsi positivi sistematici.
Assemblare un benchmark riproducibile
Un benchmark non è solo un’altra metrica: è una configurazione che congela un dataset e un protocollo in modo che due esecuzioni siano confrontabili. La classe seguente misura rilevanza, fedeltà (quando il contesto è disponibile), latenza e costo, quindi conserva ogni risultato datato ed etichettato per versione del prompt.
from dataclasses import dataclass, field
import time
@dataclass
class BenchmarkResult:
model: str
prompt_version: str
scores: dict
avg_latency: float
total_cost: float
date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))
class Benchmark:
"""Reusable benchmark for comparing models and prompts."""
def __init__(self, name: str, dataset: list[dict]):
self.name = name
self.dataset = dataset
self.results: list[BenchmarkResult] = []
def run(
self,
model: str,
system_prompt: str,
prompt_version: str,
) -> BenchmarkResult:
"""Runs the benchmark with a given model and prompt."""
relevance_scores = []
hallucination_scores = []
latencies = []
cost = 0
for case in self.dataset:
start = time.perf_counter()
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
latency = time.perf_counter() - start
latencies.append(latency)
# Evaluate
relevance = relevance_score(
case["input"], response.output_text
)
relevance_scores.append(relevance["score"])
if case.get("context"):
halluc = detect_hallucinations(
case["context"], response.output_text
)
hallucination_scores.append(
halluc.get("fidelity_score", 0)
)
result = BenchmarkResult(
model=model,
prompt_version=prompt_version,
scores={
"relevance": sum(relevance_scores) / len(relevance_scores),
"fidelity": (
sum(hallucination_scores) / len(hallucination_scores)
if hallucination_scores else None
),
},
avg_latency=sum(latencies) / len(latencies),
total_cost=cost,
)
self.results.append(result)
return result
def compare(self) -> str:
"""Compares all benchmark results."""
lines = [f"Benchmark: {self.name}\n"]
for r in self.results:
lines.append(
f" {r.model} (prompt {r.prompt_version}) | "
f"Relevance: {r.scores['relevance']:.2f} | "
f"Latency: {r.avg_latency:.2f}s"
)
return "\n".join(lines)
L’output di compare colloca deliberatamente rilevanza e latenza sulla stessa riga, perché è così che si prende effettivamente la decisione. Un modello che guadagna due centesimi di punto in rilevanza raddoppiando il tempo di risposta non è una scelta migliore per un’applicazione interattiva; potrebbe esserlo per un’elaborazione notturna. La tabella non decide per te; mette il compromesso proprio davanti ai tuoi occhi.
Infine, total_cost rimane zero in questa implementazione. Popolalo dai campi usage restituiti dall’API: un confronto tra modelli che omette il costo tralascia il criterio che chiuderà la discussione con il tuo team finanziario.
Punti chiave
- La similarità semantica misura il significato ma rimane cieca alla negazione
- Scomponi la rilevanza in criteri distinti invece di usare un punteggio globale
- Rileva le allucinazioni confrontando la risposta con il contesto di origine
- Crea benchmark riproducibili che misurino insieme qualità, latenza e costo
- Combina metriche automatiche e LLM-as-Judge per una valutazione completa