Metrici și repere de performanță
Pe această pagină
Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii
temperatureșitop_psunt acceptați doar cu un efort de raționament denone, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specificereasoning={"effort": "none"}(API Responses) saureasoning_effort="none"(Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.
Măsurarea calității prin metrici
Dincolo de scorurile de tip LLM-as-Judge, există metrici cantitative pentru a evalua diferite aspecte ale ieșirilor LLM. Valoarea lor nu constă în faptul că sunt mai precise – un judecător LLM bine construit observă lucruri pe care nicio formulă nu le va vedea vreodată –, ci în faptul că sunt stabile și ieftine. Similaritatea cosinusică returnează exact același număr la fiecare execuție, costă aproape nimic și poate fi, prin urmare, rulată pe mii de cazuri la fiecare commit. Rezervați apoi judecătorul LLM pentru dimensiunile care îl solicită cu adevărat.
Vom examina metricile esențiale înainte de a le asambla în repere de performanță reproductibile.
Compararea sensului, nu a cuvintelor
Compararea a două texte caracter cu caracter devine inutilizabilă imediat ce formularea este liberă. Similaritatea semantică ocolește această problemă: fiecare text este convertit într-un vector de către un model de embedding, iar noi măsurăm unghiul dintre cei doi vectori. Două propoziții care spun același lucru cu cuvinte diferite indică aceeași direcție.
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+
Exemplul este instructiv: două propoziții fără niciun cuvânt comun obțin un scor peste 0,85. Aceasta este forța metodei, dar și capcana sa. Similaritatea semantică ignoră negația și nuanțele de grad – „plata a fost acceptată“ și „plata a fost refuzată“ arată foarte similar din punct de vedere vectorial. Prin urmare, nu o utilizați niciodată singură pentru a valida un răspuns unde acuratețea factuală contează.
Când întrebarea este „răspunsul abordează efectiv întrebarea pusă?“, nicio formulă nu înlocuiește judecata. Scorul de relevanță de mai jos descompune această judecată în trei întrebări distincte: Este răspunsul direct? Rămâne concentrat? Este complet? Această descompunere este mai bună decât un scor global, deoarece vă indică în ce direcție să corectați promptul – un model verbose și un model incomplet necesită corecții opuse.
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"}
Observați formularea inversată a celui de-al doilea criteriu, unde 5 înseamnă „nicio informație nesolicitată“. Acest lucru permite adunarea celor trei scoruri în aceeași direcție, dar este contra-intuitiv la citire: atunci când adăugați propriile criterii, păstrați această convenție sau veți obține medii care recompensează defectul pe care intenționați să îl penalizați.
Verificarea faptului că modelul nu halucinează
Într-o aplicație de tip Q&A bazată pe documente, metrica decisivă nu este calitatea scrierii, ci fidelitatea față de sursă. Principiul de control este simplu: prezentați judecătorului contextul original și răspunsul generat și cereți-i să clasifice fiecare afirmație ca fiind susținută de context, absentă din context sau contradictorie cu acesta. Distincția dintre aceste ultime două categorii contează, deoarece o afirmație doar absentă ar putea fi o cunoaștere generală corectă, în timp ce o afirmație care contrazice sursa este întotdeauna o eroare.
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"}
Trunchierea contextului la 3.000 de caractere este o limită de care trebuie să fiți conștienți: dacă sursa depășește această dimensiune, afirmațiile perfect exacte vor fi numărate ca nejustificate simplu pentru că pasajul care le justifica a fost tăiat. Pentru documente lungi, divizați și evaluați pe secțiuni, în loc să acceptați fals pozitive sistematice.
Asamblarea unui reper de performanță reproductibil
Un reper de performanță (benchmark) nu este doar o altă metrică: este o configurare care îngheață un set de date și un protocol, astfel încât două rulări să fie comparabile. Clasa de mai jos măsoară relevanța, fidelitatea (când contextul este disponibil), latența și costul, apoi păstrează fiecare rezultat datat și etichetat după versiunea promptului.
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)
Ieșirea funcției compare plasează în mod deliberat relevanța și latența pe aceeași linie, deoarece așa se ia decizia în realitate. Un model care câștigă două sutimi de punct la relevanță, dar dublează timpul de răspuns, nu este o alegere mai bună pentru o aplicație interactivă; ar putea fi însă pentru procesarea nocturnă. Tabelul nu decide în locul dumneavoastră; el pune compromisul chiar în fața ochilor dumneavoastră.
În final, total_cost rămâne zero în această implementare. Populați-l din câmpurile de utilizare returnate de API: o comparație de modele care omite costul lasă afară criteriul care va tranșa discuția cu echipa dumneavoastră financiară.
Puncte cheie
- Similaritatea semantică măsoară sensul, dar rămâne oarbă la negație
- Descompuneți relevanța în criterii distincte, nu într-un scor global
- Detectați halucinațiile confruntând răspunsul cu contextul sursă
- Creați repere de performanță reproductibile care măsoară calitatea, latența și costul împreună
- Combinați metricile automate și LLM-as-Judge pentru o evaluare completă