A/B-test af prompts
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.
A/B-test af prompts
A/B-test af prompts giver dig mulighed for objektivt at sammenligne to versioner af en prompt ved hjælp af rigtig trafik. I stedet for at vælge en prompt baseret på intuition, måler du, hvilken der giver bedre resultater i forhold til dine forretningsmæssige nøgletal. Dette er det obligatoriske skridt mellem prototyping og produktion.
Princip
Indgående trafik opdeles tilfældigt mellem to (eller flere) prompt-varianter. Hvert svar evalueres ud fra foruddefinerede kriterier, og den vindende variant udrulles til 100 % af trafikken.
Styrken ved denne metode er, at begge varianter udsættes for den samme trafik under de samme forhold på samme tid. Alle eksterne variationskilder – sæsonudsving, netværkshændelser, ankomsten af en ny kategori af forespørgsler – påvirker begge grupper lige meget og udlignes i sammenligningen. En sekventiel test kan ikke garantere dette: Hvis du kører den gamle prompt i en uge og den nye i den næste, kan du ikke afgøre, om forbedringen skyldtes din omskrivning eller kalenderen.
Rammeværk for A/B-test
Klassen PromptExperiment har tre ansvarsområder. assign_variant beslutter, hvilken variant der betjener en given forespørgsel, run udfører kaldet og logger resultatet, og get_stats aggregerer dataene.
Tildelingen fortjener en bemærkning. Når en user_id angives, er tildelingen deterministisk og beregnes ud fra et hash af eksperiment-bruger-parret. Den samme bruger forbliver i den samme gruppe fra kald til kald. Denne kontinuitet er ikke en teoretisk forfinelse: En kunde, der modtager et varmt svar og derefter tre minutter senere et tørt svar på deres opfølgning, vil tro, det er en fejl, og deres utilfredshed vil forurene begge varianter.
Hver kørsel registrerer input, output, forbrugte tokens og tidsstempel. Disse tokens er ikke blot pynt: En variant kan vinde på kvalitet, mens den fordobler svarlængden, og _estimate_cost oversætter dette gab til dollars, så du kan foretage en informeret afvejning.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""A/B-test rammeværk for prompts."""
def __init__(self, name: str, variants: dict[str, dict]):
"""
variants = {
"control": {"system_prompt": "...", "model": "gpt-5.6-terra",
"temperature": 0.3},
"variant_a": {"system_prompt": "...", "model": "gpt-5.6-terra",
"temperature": 0.1},
}
"""
self.name = name
self.variants = variants
self.results = {v: [] for v in variants}
def assign_variant(self, user_id: str = None) -> str:
"""Tildeler en variant (fastlåst ved user_id hvis angivet)."""
if user_id:
# Deterministisk tildeling pr. bruger
hash_val = hash(f"{self.name}:{user_id}") % 100
keys = sorted(self.variants.keys())
split = 100 // len(keys)
for i, key in enumerate(keys):
if hash_val < (i + 1) * split:
return key
return keys[-1]
return random.choice(list(self.variants.keys()))
def run(self, input_text: str, user_id: str = None,
schema: dict = None) -> dict:
"""Udfører prompten med den tildelte variant."""
variant_name = self.assign_variant(user_id)
variant = self.variants[variant_name]
kwargs = {
"model": variant["model"],
"instructions": variant["system_prompt"],
"input": input_text,
"temperature": variant.get("temperature", 0.3)
}
if schema:
kwargs["text"] = {
"format": {
"type": "json_schema",
"name": "response",
"schema": schema,
"strict": True
}
}
response = client.responses.create(**kwargs)
result = {
"variant": variant_name,
"input": input_text,
"output": response.output_text,
"tokens_input": response.usage.input_tokens,
"tokens_output": response.usage.output_tokens,
"timestamp": datetime.now().isoformat()
}
self.results[variant_name].append(result)
return result
def get_stats(self) -> dict:
"""Beregner statistik pr. variant."""
stats = {}
for variant, results in self.results.items():
if not results:
continue
tokens_in = [r["tokens_input"] for r in results]
tokens_out = [r["tokens_output"] for r in results]
stats[variant] = {
"count": len(results),
"avg_tokens_input": sum(tokens_in) / len(tokens_in),
"avg_tokens_output": sum(tokens_out) / len(tokens_out),
"total_cost_estimate": self._estimate_cost(
sum(tokens_in), sum(tokens_out)
)
}
return stats
def _estimate_cost(self, tokens_in: int,
tokens_out: int) -> float:
"""Estimerer omkostninger i USD."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Evaluationsmålinger
Målingerne afhænger af dit brugstilfælde, og to familier dækker de fleste scenarier. Når opgaven har et korrekt svar – f.eks. klassificering af en billet eller udtrækning af et felt – reduceres evalueringen til en sammenligning med et referencelabel. Dette er rollen for evaluer_classification. Bemærk et instruktivt valg her: Parse-fejl behandles som tomme forudsigelser i stedet for at udløse en undtagelse, fordi en variant, der producerer ugyldig JSON, skal straffes i scoren, ikke få målingen til at crashe.
Når opgaven producerer frit tekst, findes der ikke ét korrekt svar, så du beder modellen om at dømme. evaluer_qualite_texte opdeler bedømmelsen i fire kriterier – relevans, klarhed, fuldstændighed, professionel tone – i stedet for at bede om en direkte samlet score. Denne opdeling gør evalueringen mere stabil og fortæller dig, på hvilken akse den vindende variant excellerer: At vide, at gevinsten kommer fra tonen snarere end fuldstændigheden, er præcis den information, du har brug for til at skrive næste version.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Evaluerer et klassificeringssvar."""
try:
output = json.loads(result["output"])
prediction = output.get("category", "")
except json.JSONDecodeError:
prediction = ""
return {
"correct": prediction == label_attendu,
"prediction": prediction,
"attendu": label_attendu
}
def evaluer_qualite_texte(result: dict) -> dict:
"""Evaluerer kvaliteten af et tekstsvar ved hjælp af LLM."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kræver effort none
instructions="You are a text quality evaluator. "
"Rate out of 10 based on: relevance, clarity, "
"completeness, professional tone.",
input=f"Question: {result['input']}\n\n"
f"Answer: {result['output']}",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"pertinence": {"type": "integer"},
"clarte": {"type": "integer"},
"completude": {"type": "integer"},
"ton": {"type": "integer"},
"note_globale": {"type": "number"},
"commentaire": {"type": "string"}
},
"required": ["pertinence", "clarte",
"completude", "ton",
"note_globale", "commentaire"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(eval_response.output_text)
Komplet eksempel: Test af to prompt-stile
Eksperimentet nedenfor kontrasterer to tilgange til kundesupport. Kontrollen bruger en minimal, professionel og neutral instruktion. Den „empatiske” variant pålægger en tretrinsstruktur: anerkend problemet, udvis empati, og foreslå derefter en konkret løsning med trin. Alt andet er identisk, fra model til temperatur. Denne symmetri er betingelsen for at kunne tilskrive ethvert målt gab til prompten. At ændre både tone og temperatur samtidig ville give et ufortolkeligt resultat.
De fem testbilletter dækker bevidst forskellige registre: en følelsesladet leveringshændelse, en funktionel fejl, et neutralt spørgsmål om adgangskode, en konfliktfyldt anmodning om refusion og en API-nedetid rapporteret af en teknisk profil. Du forventer, at den empatiske variant dominerer de to første og straffes på den sidste, hvor samtalepartneren ønsker en status og en forventet tid, ikke medfølelse. Dette er den nuance, som et globalt gennemsnit skjuler, og som en billet-for-billet undersøgelse afslører – hvilket ofte fører til den rigtige beslutning: Routér baseret på forespørgselstype i stedet for at vælge én enkelt tone.
experiment = PromptExperiment(
name="customer-support-style",
variants={
"control": {
"system_prompt": "You are a support agent. "
"Respond professionally.",
"model": "gpt-5.6-terra",
"temperature": 0.3
},
"empathique": {
"system_prompt": "You are a caring support agent. "
"Start by acknowledging the customer's problem, "
"show empathy, then propose a concrete solution "
"with steps.",
"model": "gpt-5.6-terra",
"temperature": 0.3
}
}
)
# Simuler trafik
test_tickets = [
"My package hasn't arrived in 2 weeks.",
"The app crashes when I click on Settings.",
"How do I change my password?",
"I want a refund, the product is defective.",
"Your API has been returning a 500 error since this morning.",
]
for ticket in test_tickets:
result = experiment.run(ticket)
quality = evaluer_qualite_texte(result)
print(f"Variant: {result['variant']} | "
f"Score: {quality['note_globale']}/10")
print("\nStatistics:")
print(json.dumps(experiment.get_stats(), indent=2))
Statistisk signifikans
Drag ikke konklusioner for hurtigt. Med få data er resultaterne støjende, og den klassiske fejl er at se 7,4 mod 6,9 over tolv observationer og erklære en vinder. Student’s t-testen nedenfor besvarer det eneste spørgsmål, der betyder noget: Er det observerede gab større end det, tilfældigheden naturligt ville producere mellem to ækvivalente serier?
En p_value under 0,05 betyder, at et sådant gab ville være usandsynligt, hvis de to varianter var ens. Over denne værdi har du bevist ingenting – hvilket ikke er det samme som at bevise lighed. Oftest mangler du blot data. Regn med mindst hundrede observationer pr. variant, før du konkluderer, og pas på trangen til at tjekke resultaterne hver morgen. Hvis du kigger ofte nok, vil du altid finde et øjeblik, hvor gabet ser meningsfuldt ud.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""Student's t-test til sammenligning af to varianter."""
t_stat, p_value = stats.ttest_ind(scores_a, scores_b)
return {
"moyenne_a": sum(scores_a) / len(scores_a),
"moyenne_b": sum(scores_b) / len(scores_b),
"p_value": p_value,
"significatif": p_value < 0.05,
"recommandation": (
"Significant difference, deploy the winning variant"
if p_value < 0.05
else "Not enough data or no significant difference"
)
}
Kør dit første eksperiment
Tag en opgave, du kender godt, og opsæt en PromptExperiment med to varianter, hvor du kun ændrer én ting mellem kontrollen og varianten: en tone, en pålagt struktur eller en ekstra instruktion. Definer to eller tre målinger, før du lancerer noget, fordi valg af måling efter at have set resultaterne svarer til at vælge vinderen på forhånd, og det er den mest almindelige bias i hjemmelavede tests.
Kør eksperimentet på tyve input, og analyser derefter. Kig på gennemsnittet, men åbn især de tilfælde, hvor de to varianter afviger mest: disse forklarer gabet. Tyve observationer vil åbenlyst ikke være nok til at opnå signifikans, og at indse dette selv er bedre end at læse det her. Dokumentér endelig beslutningen og arkivér de rå resultater med dato og den nøjagtige variantkonfiguration – dette arkiv er det, der vil stoppe dig i at køre det samme eksperiment igen om et år.
Vigtige pointer
- A/B-test erstatter intuition med målbare data
- Tildel varianter deterministisk pr. bruger
- Mål forretningsmæssige nøgletal, ikke kun oplevet kvalitet
- Vent på statistisk signifikans, før du konkluderer
- Dokumentér hvert eksperiment og dets resultater