Utvärdera dina prompts: Metoder, bedömare och migrering till Promptfoo
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.
Uppdatering 2 november 2026 — Evals-plattform. OpenAI har meddelat att deras Evals-plattform läggs ner: befintliga utvärderingar har varit skrivskyddade sedan den 31 oktober 2026, och instrumentpanelen samt API:t stängs den 30 november 2026, inklusive bedömare. OpenAI har publicerat en migrationsguide till Promptfoo. Utvärderingsprinciperna i denna lektion förblir giltiga; det är endast verktyget som byts ut.
Varför du måste utvärdera systematiskt
Du kan inte förbättra det du inte mäter. När du ändrar en prompt, en modell eller en parameter, hur vet du då att kvaliteten faktiskt har förbättrats? Den spontana metoden är att testa tre eller fyra exempel, hitta de bättre svaren och distribuera koden. Detta misslyckas regelbundet eftersom de testade exemplen precis är de som orsakade problem förra veckan: du mäter förbättring där du letade efter den, och du missar regressioner som introducerats i fall som redan fungerade.
Utvärderingar (evals) omvandlar denna intuition till ett objektivt mått. Fram till 2026 erbjöd OpenAI en integrerad plattform för detta, Evals; den har varit skrivskyddad sedan den 31 oktober 2026 och stängs den 30 november. OpenAI rekommenderar nu Promptfoo, ett open source-verktyg för utvärdering och red teaming. Den goda nyheten är att båda delar samma byggstenar – testdata, prompts, modeller och poängsättningskriterier. Det du lär dig här i Python-kod är direkt överförbart, och den sista delen av lektionen visar hur du flyttar till Promptfoo.
Tre begrepp strukturerar hela processen. Datasetet är en uppsättning testfall med indata och förväntade utdata: det är din referens, motsvarigheten till en svit med enhetstester. Bedömaren (grader) är ett utvärderingskriterium – exakt matchning, LLM-as-judge, poäng – som avgör om ett givet svar är bra. Körningen (run) är en utvärderingsexekvering på ett dataset med en specifik modell och prompt; det är enheten du jämför från en version till nästa.
Bygg ett dataset som speglar din verklighet
Ett testfall består av en indata, ett förväntat utdata och metadata. Det senare är inte bara dekoration: det är det som låter dig inse, i efterhand, att ett totalt betyg på 87 % döljer ett kollaps inom kategorin “kod” som kompenseras av utmärkta resultat inom geografi. Utan kategori eller svårighetsgrad har du bara ett aggregerat tal, och ett aggregerat tal berättar aldrig var du behöver ingripa.
import json
# A dataset is a list of test cases
dataset = [
{
"input": "What is the capital of France?",
"expected": "Paris",
"metadata": {"category": "geography", "difficulty": "easy"},
},
{
"input": "Explain Bayes' theorem in one sentence.",
"expected": "Bayes' theorem calculates the probability "
"of an event based on known conditional probabilities.",
"metadata": {"category": "mathematics", "difficulty": "medium"},
},
{
"input": "Write a Python function that reverses a list.",
"expected": "def reverse_list(lst): return lst[::-1]",
"metadata": {"category": "code", "difficulty": "easy"},
},
]
# Save as JSONL
with open("eval_dataset.jsonl", "w") as f:
for case in dataset:
f.write(json.dumps(case, ensure_ascii=False) + "\n")
Ett dataset som hittas på i kontorsmiljön utvärderar din fantasi, inte din applikation. Dina användare formulerar sina förfrågningar annorlunda än du gör: stavfel, halvfärdiga frågor, implicit kontext. Den bästa källan till testfall är därför din egen produktionsdata, förutsatt att en människa validerar referenssvaren – annars fryser du nuvarande fel som norm.
import openai
import random
client = openai.OpenAI()
def create_dataset_from_logs(
production_logs: list[dict],
sample_size: int = 100,
) -> list[dict]:
"""Creates an evaluation dataset from production logs."""
# Sample
sample = random.sample(
production_logs,
min(sample_size, len(production_logs)),
)
dataset = []
for log in sample:
dataset.append({
"input": log["prompt"],
"expected": log["validated_response"], # Response validated by a human
"metadata": {
"source": "production",
"date": log["date"],
"original_model": log["model"],
},
})
return dataset
Välj rätt bedömare
Bedömaren för exakt matchning är den strängaste och snabbaste. Den passar endast uppgifter där utdatan är begränsad: en klassificering i tre kategorier, extrahering av ett fakturanummer, ett ja-eller-nej-svar. Använd på fritt text skulle den ge noll poäng till ett perfekt svar som helt enkelt är formulerat annorlunda än referensen.
def exact_grader(response: str, expected: str) -> dict:
"""Evaluates if the response matches exactly."""
score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
return {"score": score, "type": "exact"}
Bedömaren för inkludering mjukar upp begränsningen: den kontrollerar förekomsten av förväntade nyckelord och returnerar en delpoäng. Detta är rätt verktyg för svar som måste täcka obligatoriska punkter utan att ordalydelsen spelar roll – till exempel ett supportsvar som måste nämna ångerrätten och returadressen. Dess svaghet är välkänd: en text som innehåller rätt ord i en absurd ordning skulle få full pott.
def inclusion_grader(response: str, keywords: list[str]) -> dict:
"""Checks that the response contains the expected keywords."""
response_lower = response.lower()
found = sum(1 for word in keywords if word.lower() in response_lower)
score = found / len(keywords) if keywords else 0.0
return {
"score": score,
"found": found,
"total": len(keywords),
"type": "inclusion",
}
Sedan finns den mest kraftfulla: en annan LLM utvärderar svarskvaliteten. Bedömaren LLM-as-Judge uppskattar det som ingen mekanisk regel kan – tydlighet, fullständighet, tonläge. Två implementeringsdetaljer gör den praktisk. För det första, temperature=0.0: utan detta skulle samma bedömare tilldela olika poäng till samma svar från en körning till nästa, och ditt riktmärke skulle förlora allt jämförbart värde. För det andra, hanteringen av json.JSONDecodeError: en bedömare som kommenterar istället för att returnera JSON bör inte krascha hela kampanjen.
def llm_judge_grader(
question: str,
response: str,
expected: str,
criteria: str = "accuracy, completeness, clarity",
) -> dict:
"""Uses an LLM to evaluate response quality."""
judge_prompt = f"""Rate the quality of this response on a scale of 1 to 5.
Question: {question}
Expected Response: {expected}
Response to Evaluate: {response}
Criteria: {criteria}
Respond ONLY with JSON:
{{"score": <1-5>, "justification": "<short explanation>"}}"""
response_obj = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=judge_prompt,
temperature=0.0,
)
import json
try:
result = json.loads(response_obj.output_text)
result["normalized_score"] = result["score"] / 5.0
return result
except json.JSONDecodeError:
return {"score": 0, "justification": "Parsing error", "normalized_score": 0}
Sammanställ den fullständiga utvärderingen
Orkestreringen innebär ingen konceptuell svårighet: du itererar genom datasetet, anropar modellen med system-prompten som ska testas, applicerar bedömaren och aggregerar resultaten. Det intressanta är att poängsättningsfunktionen kommer in som en parameter, vilket låter dig köra exakt samma dataset med olika kriterier beroende på kampanj – inkludering för en snabb kontroll under utveckling, LLM-bedömare för validering innan produktion.
async def run_eval(
dataset: list[dict],
model: str,
system_prompt: str,
grader_fn,
) -> dict:
"""Runs a full evaluation on a dataset."""
results = []
for case in dataset:
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
score = grader_fn(response.output_text, case["expected"])
results.append({
"input": case["input"],
"expected": case["expected"],
"obtained": response.output_text,
**score,
})
# Calculate aggregated metrics
scores = [r["score"] for r in results if "score" in r]
return {
"model": model,
"num_cases": len(dataset),
"average_score": sum(scores) / len(scores) if scores else 0,
"min_score": min(scores) if scores else 0,
"max_score": max(scores) if scores else 0,
"results": results,
}
Rapporten behåller min_score och detaljerna för varje fall, och det är avsiktligt. Medelvärdet berättar om du rör dig framåt; fallen med sämst betyg berättar varför. Gör det till en vana att läsa de fem sämsta svaren från varje körning innan du kommenterar medelvärdet: det är där, och sällan någon annanstans, du hittar nästa fix som behöver göras.
Industrialisera med Promptfoo
Att skriva dina evals för hand i Python är lärorikt; att underhålla dem över tid är bekvämare med ett dedikerat verktyg. OpenAI:s migrationsguide beskriver Promptfoos logik: utvärderingen lever i en konfigurationsfil, promptfooconfig.yaml, som sammanför prompts, modell(er), testfall och kriterier – här kallade assertioner. Den körs från kommandoraden, lokalt eller i din kontinuerliga integration, och lever sida vid sida med applikationskoden.
description: Support ticket classification
prompts:
- "Classify this ticket into a single category (billing, technical, account): {{ticket}}"
providers:
- openai:gpt-6.1-sol
tests:
- vars:
ticket: "My card was charged twice this month."
assert:
- type: icontains
value: billing
- vars:
ticket: "The app crashes when I open a PDF."
assert:
- type: icontains
value: technical
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
promptfoo validate config -c promptfooconfig.yaml # in case of configuration error
Bedömarna i denna lektion dyker upp igen som assertioner: exakt matchning, nyckelordsinkludering och modellbedömning. OpenAI varnar för den sista punkten: en återskapad bedömare, särskilt en LLM-bedömare, måste omvalideras innan den används för att besluta om en regression, eftersom poängen inte nödvändigtvis blir identiska från ett verktyg till ett annat.
Viktiga punkter
- Evals omvandlar intuition till ett objektivt mått på kvalitet
- Skapa dina dataset från verkliga produktionsfall, validerade av en människa
- Välj bedömare baserat på uppgiften: exakt för begränsade svar, inkludering för obligatoriska punkter, LLM-as-Judge för nyanser
- Ställ in
temperature=0.0på bedömaren för att göra poängen reproducerbara - Kör evals före varje ändring av prompt eller modell
- OpenAI:s Evals-plattform stängs den 30 november 2026: Promptfoo, rekommenderat av OpenAI, tar över dataset, prompts, modeller och kriterier i en konfigurationsfil