Målinger og benchmarks
På denne side
Lektionen opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(API Responses) ellerreasoning_effort="none"(Chat Completions). Kilder: Using GPT-6 · GPT-5.6 Terra.
Måling af kvalitet med metrikker
Ud over LLM-as-Judge-score findes der kvantitative metrikker til at evaluere forskellige aspekter af LLM-output. Deres værdi ligger ikke i, at de er mere nøjagtige – en velkonstrueret LLM-dommer ser ting, som ingen formel nogensinde vil kunne – men i, at de er stabile og billige. Cosinusligehed returnerer præcis det samme tal ved hver kørsel, koster næsten ingenting og kan derfor køres på tusindvis af tilfælde ved hvert commit. Derefter reserverer du LLM-dommeren til dimensioner, der virkelig kræver det.
Vi gennemgår de essentielle metrikker, før vi samler dem til reproducerbare benchmarks.
Sammenligning af betydning frem for ord
Sammenligning af to tekster tegn for tegn bliver ubrugelig, så snart formuleringen er fri. Semantisk ligehed omgår dette problem: hver tekst konverteres til en vektor af en indlejringsmodel (embedding model), og vi måler vinklen mellem de to vektorer. To sætninger, der siger det samme med forskellige ord, peger i samme retning.
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+
Eksemplet er lærerigt: to sætninger uden fælles ord scorer over 0,85. Dette er metodens styrke, men også dens fælde. Semantisk ligehed ignorerer negation og nuancer i grad – „betalingen blev accepteret” og „betalingen blev afvist” ser meget ens ud vektormæssigt. Brug derfor aldrig denne metode alene til at validere et svar, hvor faktuel nøjagtighed er afgørende.
Når spørgsmålet er „besvarer svaret faktisk det stillede spørgsmål”, kan ingen formel erstatte dømmekraft. Relevansscoren nedenfor opdeler denne dømmekraft i tre distinkte spørgsmål: Er svaret direkte? Holder det sig fokuseret? Er det komplet? Denne opdeling er bedre end en global score, fordi den fortæller dig, hvilken retning du skal korrigere prompten i – en verbose model og en ufuldstændig model kræver modsatrettede korrektioner.
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"}
Bemærk den omvendte formulering af det andet kriterium, hvor 5 betyder „ingen uopfordret information”. Dette gør det muligt at lægge de tre scorer sammen i samme retning, men det er kontraintuitivt at læse: Når du tilføjer dine egne kriterier, skal du beholde denne konvention, ellers får du gennemsnit, der belønner den fejl, du havde til hensigt at straffe.
Verificering af at modellen ikke hallucinerer
I en dokumentbaseret Q&A-applikation er den afgørende metrik ikke skrivekvalitet, men troskab mod kilden. Kontrolprincippet er simpelt: Præsenter dommeren for den originale kontekst og det genererede svar, og bed den om at klassificere hver udtalelse som understøttet af konteksten, fraværende i konteksten eller modsigende konteksten. Distinktionen mellem disse to sidste kategorier er vigtig, fordi en udtalelse, der blot er fraværende, kan være korrekt almen viden, hvorimod en udtalelse, der modsiger kilden, altid er en fejl.
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"}
Afkortning af konteksten til 3.000 tegn er en grænse, du skal være opmærksom på: Hvis kilden overstiger denne størrelse, vil perfekt nøjagtige udtalelser blive talt som ikke-understøttede simpelthen fordi passagen, der begrunder dem, blev klippet væk. Ved lange dokumenter skal du opdele og evaluere efter sektion i stedet for at acceptere systematiske falske positiver.
Sammensætning af et reproducerbart benchmark
Et benchmark er ikke bare endnu en metrik: Det er en opsætning, der fryser et datasæt og en protokol, så to kørsler er sammenlignelige. Klassen nedenfor måler relevans, troskab (når kontekst er tilgængelig), latenstid og omkostninger, og gemmer derefter hvert resultat med dato og mærket efter prompt-version.
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)
Outputtet fra compare placerer bevidst relevans og latenstid på samme linje, fordi det er sådan, beslutningen faktisk træffes. En model, der vinder to hundrededele i relevans, mens den fordobler svartiden, er ikke et bedre valg til en interaktiv applikation; det kan den være til nattenlig behandling. Tabellen beslutter ikke for dig; den placerer afvejningen lige foran dine øjne.
Endelig forbliver total_cost nul i denne implementering. Udfyld den ud fra brugsfelterne returneret af API’et: En modelsammenligning, der udelader omkostninger, udelader det kriterium, der vil afgøre diskussionen med dit økonomiteam.
Vigtige pointer
- Semantisk ligehed måler betydning, men forbliver blind over for negation
- Opdel relevans i distinkte kriterier frem for en global score
- Detekter hallucinationer ved at konfrontere svaret med kildekonteksten
- Skab reproducerbare benchmarks, der måler kvalitet, latenstid og omkostninger sammen
- Kombinér automatiske metrikker og LLM-as-Judge for en komplet evaluering