Automatiseret prompt-evaluering
På denne side
Lektion 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"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Automatiseret prompt-evaluering
Automatiseret evaluering er hjørnestenen i en moden pipeline til prompt-engineering. Den lader dig opdage regressioner, sammenligne modeller og validere ændringer før udrulning. Uden den er hver ændring af en prompt et blindt gæt.
Typer af evaluering
Tre familier af evaluatorer fordeler arbejdet baseret på arten af det forventede output, og du vil næsten altid kombinere flere af dem.
Evaluering med eksakt match
For opgaver med ét enkelt forventet svar er en direkte sammenligning tilstrækkelig. eval_exact_match normaliserer store og små bogstaver samt mellemrum før sammenligning: uden denne forholdsregel ville „Bug” og „bug” tælle som en fejl, hvilket sender dig ud på at løse et problem, der ikke eksisterer.
eval_set_match håndterer tilfælde, hvor svaret er et sæt – f.eks. enheder fundet i et dokument eller kategorier tildelt en artikel. Den udleder præcision og recall, to tal der fortæller forskellige historier: høj præcision med lav recall signalerer en alt for forsigtig model, der kun udtrækker det, den er sikker på; det modsatte afslører en model, der hallucinerer for at fylde huller. F1 opsummerer dem belejligt, men erstatter dem ikke ved diagnosticering.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Eksakt match efter normalisering."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Sæt-match (enheder, kategorier)."""
tp = len(prediction & reference)
fp = len(prediction - reference)
fn = len(reference - prediction)
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = (2 * precision * recall / (precision + recall)
if (precision + recall) > 0 else 0)
return {"precision": precision, "recall": recall, "f1": f1}
Semantisk evaluering (Embedding)
For tekstsvar, hvor ordlyden kan variere, bliver eksakt match absurd: „Din ordre bliver leveret i morgen” og „Levering er planlagt til i morgen” siger det samme, men ville score nul. Cosinus-likhed mellem embeddings måler semantisk nærhed snarere end tegnsammenfald og returnerer en løbende score.
Du fastsætter den tærskel, over hvilken et svar betragtes som acceptabelt. Kalibrer den på et par dusin par, du manuelt har klassificeret som „ækvivalente” eller „forskellige”, og vælg derefter den værdi, der bedst adskiller de to grupper: en tærskel valgt på mavefornemmelsen giver resultater, der er lige så vilkårlige som ingen måling overhovedet, med den ekstra illusion af stringens.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Cosinus-likhed mellem embeddings."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[prediction, reference]
)
emb_pred = np.array(response.data[0].embedding)
emb_ref = np.array(response.data[1].embedding)
similarity = float(
np.dot(emb_pred, emb_ref) /
(np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
)
return similarity
LLM-evaluering (LLM-as-Judge)
Modellen evaluerer kvaliteten af et svar. Dette er den eneste levedygtige tilgang, når der ikke findes nogen reference: ingen vil håndskrive det „korrekte” support-svar til to hundrede billetter.
Det, der gør en dommer brugbar, afhænger af nogle få ting. Først modellen, der bruges: du vælger en mere capable model som dommer, her gpt-5.6-sol, fordi en dommer på samme niveau som den, der evalueres, tenderer til at validere sine egne fejl. For det andet kravet om begrundelse: at motivere hver score stabiliserer dømmekraften og lader dig spotte en evaluator, der bruger det forkerte kriterium – en begrundelse, der diskuterer længde, når kriteriet var klarhed, er et advarselstegn. Endelig sikrer temperature på 0,1 score-stabilitet på tværs af kørsler.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Evaluering ved en dommer-model."""
criteria_text = "\n".join(
f"- {c}: score fra 1 til 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Mere capable model som dommer
reasoning={"effort": "none"}, # temperature kræver effort none
instructions="Du er en ekspert, upartisk evaluator.",
input=f"""Evaluer dette svar ud fra følgende kriterier:
Stillet spørgsmål: {question}
Svar der skal evalueres: {prediction}
Kriterier:
{criteria_text}
Giv for hvert kriterium en score fra 1 til 5 med begrundelse.""",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"scores": {
"type": "array",
"items": {
"type": "object",
"properties": {
"criterion": {"type": "string"},
"score": {"type": "integer"},
"justification": {"type": "string"}
},
"required": ["criterion", "score",
"justification"],
"additionalProperties": False
}
},
"overall_score": {"type": "number"},
"verdict": {"type": "string"}
},
"required": ["scores", "overall_score", "verdict"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(response.output_text)
Komplet evaluerings-pipeline
EvalPipeline samler disse byggesten: den indlæser en testsuite, kører prompten på hvert tilfælde, anvender alle medfølgende evaluatorer og aggregerer scorer. Evaluatorer sendes som en liste af funktioner, alle kaldet med samme signatur; at tilføje en metrik kræver derfor ingen ændring af pipelinen, og du kan køre eksakt match, semantisk lighed og en dommer på samme eksekvering uden at betale for generering tre gange.
Metoden summary akkumulerer også forbrugte tokens. Denne tilsyneladende sekundære linje beskytter dig mod en fælde: en prompt-version, der vinder to point, mens regningen tredobles, er ikke nødvendigvis det rigtige valg, og det er bedre at lære det ved afvejningstidspunktet end når den månedlige faktura ankommer.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Et testtilfælde til evaluering."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Automatiseret evaluerings-pipeline."""
def __init__(self, test_suite_path: str):
"""Indlæser testsuiten fra en JSON-fil."""
data = json.loads(Path(test_suite_path).read_text())
self.test_cases = [TestCase(**tc) for tc in data]
self.results = []
def run(self, prompt_config: dict,
evaluators: list[callable]) -> dict:
"""Kører alle tests og evaluerer resultater."""
self.results = []
for tc in self.test_cases:
# Generer svar
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature kræver effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Evaluer med hver evaluator
scores = {}
for evaluator in evaluators:
score = evaluator(
question=tc.input_text,
prediction=prediction,
reference=tc.expected_output
)
scores[evaluator.__name__] = score
self.results.append({
"input": tc.input_text,
"expected": tc.expected_output,
"prediction": prediction,
"scores": scores,
"tokens": {
"input": response.usage.input_tokens,
"output": response.usage.output_tokens
}
})
return self.summary()
def summary(self) -> dict:
"""Opsummerer evalueringsresultater."""
if not self.results:
return {"error": "Ingen resultater"}
# Aggreger scorer pr. evaluator
all_scores = {}
for result in self.results:
for eval_name, score in result["scores"].items():
if eval_name not in all_scores:
all_scores[eval_name] = []
if isinstance(score, (int, float)):
all_scores[eval_name].append(score)
elif isinstance(score, dict) and "f1" in score:
all_scores[eval_name].append(score["f1"])
summary = {
"total_tests": len(self.results),
"average_scores": {
name: sum(scores) / len(scores)
for name, scores in all_scores.items()
if scores
},
"total_token_cost": sum(
r["tokens"]["input"] + r["tokens"]["output"]
for r in self.results
)
}
return summary
Testsuite: Format
Formatet for testsuiten er bevidst minimalt: et input, det forventede output og frit formaterede metadata. Disse metadata er mere nyttige, end de ser ud – ved at tagge hvert tilfælde efter kategori kan du opdele scorer og opdage, at din klassificator ikke fejler tilfældigt, men på en specifik familie af forespørgsler, hvilket et globalt gennemsnit på 88 % ikke afslører. De tre eksempler nedenfor viser også, hvad en god suite bør indeholde: klare tilfælde, som et nedbrud ved opstart, men også tilfælde der grænser op til en anden kategori – et spørgsmål om en manglende funktion ligner meget en fejlrapport, og det er på denne grænse, en klassifikators kvalitet afgøres.
[
{
"input_text": "Min pakke er ikke ankommet",
"expected_output": "klage",
"metadata": {"category": "levering"}
},
{
"input_text": "Hvordan aktiverer jeg mørk tilstand?",
"expected_output": "spørgsmål",
"metadata": {"category": "funktion"}
},
{
"input_text": "Appen crascher ved opstart på iOS 18",
"expected_output": "fejl",
"metadata": {"category": "teknisk"}
}
]
CI/CD-integration
Kør evaluering ved hver ændring af en prompt. Funktionen ci_eval_check gør måling til en guardrail: den kører pipelinen, sammenligner gennemsnitsscoren med en tærskel og returnerer en boolean, som din integrationskæde fortolker som en succes eller fiasko for buildet. En ændring, der får præcisionen til at falde under 85 %, når ikke længere produktionen, ligesom en defekt unit-test blokerer en merge.
Sæt tærsklen baseret på den score, den nuværende version allerede opnår, ikke ud fra et ideal. Sætter du den for højt, dømmer du teamet til at omgå verifikationen med midlertidige deaktiveringer, der bliver permanente; sætter du den for lavt, tjekker du ingenting, mens du viser et grønt mærke. Husk endelig, at suiten skal forblive repræsentativ for rigtig trafik: en tærskel mødt på tyve tilfælde skrevet for to år siden beviser intet om dagens forespørgsler.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD-port: tjekker at prompten overholder minimumsscoren."""
pipeline = EvalPipeline(test_suite)
def accuracy(question, prediction, reference):
return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0
results = pipeline.run(prompt_config, [accuracy])
avg_score = results["average_scores"].get("accuracy", 0)
print(f"Gennemsnitlig score: {avg_score:.2%}")
print(f"Minimumstærskel: {min_score:.2%}")
if avg_score < min_score:
print("FIASKO: score under tærskel")
return False
print("SUCCES: prompt valideret")
return True
Evalueringsoversigt
Følg score-udviklingen over tid. En enkelt score siger ingenting; serien fortæller din prompts historie og besvarer det spørgsmål, der altid dukker op til møder: gør vi fremskridt? Funktionen nedenfor producerer en Markdown-tabel, der side om side for hver version viser gennemsnitsscoren, forbrugte tokens og estimerede omkostninger. Formatet er ikke tilfældigt: det kan indsættes direkte i en pull request, hvilket gør sammenligningen læsbar for folk, der aldrig åbner din kode.
def comparison_report(results: dict[str, dict]) -> str:
"""Genererer en sammenlignende rapport mellem prompt-versioner."""
report = "# Sammenlignende evalueringsrapport\n\n"
report += "| Version | Gennemsnitlig score | Gennemsnitlige tokens | Omkostning |\n"
report += "|---------|---------------|----------------|------|\n"
for version, data in results.items():
score = data.get("average_scores", {})
score_val = list(score.values())[0] if score else 0
tokens = data.get("total_token_cost", 0)
report += (f"| {version} | {score_val:.2%} | "
f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")
return report
Opsæt dine guardrails
Byg en suite på tyve testtilfælde til en rigtig prompt, og placer en håndfuld grænsetilfælde snarere end tyve komfortable eksempler: en suite, der består 100 % ved første forsøg, lærer dig ingenting. Implementer de tre evaluator-typer og kør dem sammen på to versioner af din prompt. Eksakt match giver et rent tal, semantisk lighed fanger legitime omformuleringer, og dommeren oplyser om tilfælde, hvor de første to er uenige – disse uenigheder er rigest på lærdom om, hvad du egentlig forventer af modellen.
Sammenlign, identificer den vindende version, og opsæt derefter CI-scriptet, der blokerer udrulning, hvis scoren falder. Du vil vide, at systemet virker den dag, det afviser en ændring, du troede var indlysende.
Vigtige pointer
- Automatiseret evaluering er essentiel for at iterere med tillid
- Kombinér evaluering med eksakt match, semantisk lighed og LLM-as-judge efter behov
- Vedligehold en testsuite, der udvikler sig sammen med din applikation
- Integrér evaluering i din CI/CD med en minimumstærskel
- Brug en mere capable model som dommer til at evaluere en billigere model
- Dokumenter hver versions scorer for at følge udviklingen
Test din viden
Avancerede teknikker og industrialisering: den sidste tjekliste.
1. Hvad indeholder en effektiv system-prompt?
Svar: Rolle, omfang, adfærdsregler, output-format og håndtering af grænsetilfælde – skrevet som en specifikation, testet som kode.
2. Hvornår skal du bruge self-consistency?
Svar: På ræsonneringsproblemer med verificerbare svar: generér flere uafhængige ræsonnementer og behold flertallets svar – varians bliver en allieret.
3. Hvad garanterer JSON-tilstand med schema-håndhævelse?
Svar: Output der strengt overholder schemaet (typer, påkrævede felter, enums) – valideret på API-siden og genvalideret i kode (JSON Schema, Zod) for en kæde uden overraskelser.
4. Hvad er grounding?
Svar: At forankre svar i leverede fakta (dokumenter, hentede data) snarere end modellens hukommelse – med kravet om at citere eller afholde sig fra eksterne kilder.
5. Hvad er formålet med et versioneret prompt-katalog?
Svar: At behandle prompts som artefakter: versioner, A/B-tests, automatiserede evalueringer ved hver ændring – du ved, hvad der kører i produktion, og hvorfor.
Den sidste sløjfe i kurset – versionér, test, evaluér automatisk – transformerer håndværksmæssig prompt-engineering til en teampraksis.