Metrics en Benchmarks
Op deze pagina
Les geactualiseerd op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Oproepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(API Responses) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Kwaliteit meten met metrics
Naast LLM-as-Judge-scores bestaan er kwantitatieve metrics om verschillende aspecten van LLM-uitvoer te evalueren. Hun waarde ligt niet in een hogere nauwkeurigheid—een goed opgezette LLM-judge ziet dingen die geen enkele formule ooit zal zien—maar in hun stabiliteit en lage kosten. Cosinusovereenkomst levert bij elke uitvoering exact hetzelfde getal op, kost bijna niets en kan daarom bij elke commit op duizenden casussen worden toegepast. U reserveert de LLM-judge vervolgens voor dimensies waar dit echt nodig is.
We bekijken de essentiële metrics voordat we ze samenvoegen tot reproduceerbare benchmarks.
Betekenis vergelijken in plaats van woorden
Het vergelijken van twee teksten teken voor teken wordt onbruikbaar zodra de formulering vrij is. Semantische overeenkomst omzeilt dit probleem: elke tekst wordt door een embedding-model omgezet in een vector, en we meten de hoek tussen de twee vectoren. Twee zinnen die hetzelfde zeggen met andere woorden, wijzen in dezelfde richting.
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+
Het voorbeeld is leerzaam: twee zinnen zonder gemeenschappelijke woorden scoren boven de 0,85. Dit is de kracht van de methode, maar ook haar valkuil. Semantische overeenkomst negeert ontkenningen en nuances in graad—“de betaling werd geaccepteerd” en “de betaling werd geweigerd” lijken vectoriël gezien zeer op elkaar. Gebruik het daarom nooit alleen om een antwoord te valideren waar feitelijke nauwkeurigheid belangrijk is.
Wanneer de vraag luidt “beantwoordt het antwoord daadwerkelijk de gestelde vraag”, kan geen enkele formule het oordeel vervangen. De onderstaande relevantiescore breekt dit oordeel op in drie afzonderlijke vragen: Is het antwoord direct? Blijft het gefocust? Is het compleet? Deze opdeling is beter dan een globale score, omdat deze aangeeft in welke richting u de prompt moet corrigeren—een woordrijk model en een onvolledig model vereisen tegenovergestelde correcties.
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"}
Let op de omgekeerde formulering van het tweede criterium, waarbij 5 betekent “geen ongevraagde informatie”. Hierdoor kunnen de drie scores in dezelfde richting worden opgeteld, maar het is contra-intuïtief om te lezen: wanneer u uw eigen criteria toevoegt, houd u dan aan deze conventie, anders krijgt u gemiddelden die het gebrek belonen dat u juist wilde bestraffen.
Verifiëren dat het model niet hallucineert
In een op documenten gebaseerde Q&A-toepassing is de doorslaggevende metric niet de schrijfkwaliteit, maar de trouw aan de bron. Het controleprincipe is eenvoudig: presenteer de judge de originele context en het gegenereerde antwoord, en vraag het om elke uitspraak te classificeren als ondersteund door de context, afwezig in de context, of in tegenspraak met de context. Het onderscheid tussen deze laatste twee categorieën is belangrijk, omdat een uitspraak die slechts afwezig is, accurate algemene kennis kan zijn, terwijl een uitspraak die de bron tegenspreekt altijd een fout is.
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"}
Het inkorten van de context tot 3.000 tekens is een limiet waar u zich bewust van moet zijn: als de bron deze grootte overschrijdt, worden perfect accurate uitspraken als niet-ondersteund geteld, simpelweg omdat de passage die ze rechtvaardigt, is afgekapt. Voor lange documenten splitst u deze en evalueert u per sectie in plaats van systematische false positives te accepteren.
Een reproduceerbare benchmark samenstellen
Een benchmark is niet zomaar een andere metric: het is een opzet die een dataset en een protocol bevriest, zodat twee uitvoeringen vergelijkbaar zijn. De onderstaande klasse meet relevantie, trouw (wanneer context beschikbaar is), latentie en kosten, en bewaart elk resultaat met datum en label per prompt-versie.
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)
De uitvoer van compare plaatst relevantie en latentie bewust op dezelfde regel, omdat dit is hoe de beslissing daadwerkelijk wordt genomen. Een model dat twee honderdsten punt wint in relevantie terwijl de responstijd verdubbelt, is geen betere keuze voor een interactieve toepassing; voor nachtelijke verwerking misschien wel. De tabel beslist niet voor u; hij legt de afweging recht voor uw neus.
Tot slot blijft total_cost in deze implementatie op nul staan. Vul dit in op basis van de usage-velden die door de API worden geretourneerd: een modelvergelijking die kosten weglaat, laat het criterium weg dat het gesprek met uw financieel team zal beslechten.
Belangrijkste punten
- Semantische overeenkomst meet betekenis maar blijft blind voor ontkenningen
- Splits relevantie op in afzonderlijke criteria in plaats van een globale score
- Detecteer hallucinaties door het antwoord te confronteren met de broncontext
- Creëer reproduceerbare benchmarks die kwaliteit, latentie en kosten gezamenlijk meten
- Combineer automatische metrics en LLM-as-Judge voor een volledige evaluatie