Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Metrics en Benchmarks

Les 17 van 20 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Kwaliteit meten met metrics
  2. Betekenis vergelijken in plaats van woorden
  3. Verifiëren dat het model niet hallucineert
  4. Een reproduceerbare benchmark samenstellen
  5. Belangrijkste punten

Les geactualiseerd op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Oproepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (API Responses) of reasoning_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