Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Evaluér dine prompts: Metoder, bedømmere og migration til Promptfoo

Lektion 15 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Hvorfor du skal evaluere systematisk
  2. Byg et datasæt, der ligner din virkelighed
  3. Vælg den rigtige bedømmer
  4. Saml den fulde evaluering
  5. Industrialisér med Promptfoo
  6. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres 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 specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

Opdatering 2. november 2026 — Evals-platformen. OpenAI har annonceret afviklingen af deres Evals-platform: eksisterende evalueringer har været skrivebeskyttet siden 31. oktober 2026, og dashboardet samt API’et lukker den 30. november 2026, inklusive bedømmere. OpenAI har udgivet en migrationsguide til Promptfoo. Evalueringsprincipperne i denne lektion forbliver gyldige; det er kun værktøjet, der ændrer sig.

Hvorfor du skal evaluere systematisk

Du kan ikke forbedre det, du ikke måler. Når du ændrer en prompt, en model eller en parameter, hvordan ved du så, at kvaliteten faktisk er blevet bedre? Den spontane metode er at prøve tre eller fire eksempler, finde de bedre svar og derefter deploye. Dette fejler regelmæssigt, fordi de testede eksempler netop er dem, der forårsagede problemer i sidste uge: du måler forbedring dér, hvor du ledte efter den, og du overser regressioner introduceret i tilfælde, der allerede fungerede.

Evalueringer (evals) omdanner denne intuition til et objektivt mål. Indtil 2026 tilbød OpenAI en integreret platform til dette, Evals; den har været skrivebeskyttet siden 31. oktober 2026 og lukker den 30. november. OpenAI anbefaler nu Promptfoo, et open source-værktøj til evaluering og red teaming. De gode nyheder er, at begge deler de samme byggesten – testdata, prompts, modeller og scoringkriterier. Det, du lærer her i Python-kode, kan oversættes direkte, og den sidste del af lektionen viser overgangen til Promptfoo.

Tre begreber strukturerer hele processen. Datasættet er et sæt testtilfælde med input og forventede output: det er din reference, svarende til en suite af unit-tests. Bedømmeren er et evalueringskriterium – eksakt match, LLM-as-judge, score – der afgør, om et givent svar er godt. Kørslen er en evalueringsudførelse på et datasæt med en specifik model og prompt; det er den enhed, du sammenligner fra én version til den næste.

Byg et datasæt, der ligner din virkelighed

Et testtilfælde består af et input, et forventet output og metadata. Sidstnævnte er ikke blot dekorative: det er dem, der vil lade dig indse efterfølgende, at en samlet score på 87 % skjuler et kollaps i kategorien “kode”, kompenseret af fremragende resultater inden for geografi. Uden kategori eller sværhedsgrad har du kun et aggregeret tal, og et aggregeret tal fortæller dig aldrig, hvor du skal gribe ind.

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")

Et datasæt opfundet på kontoret evaluerer din fantasi, ikke din applikation. Dine brugere formulerer deres forespørgsler anderledes end du gør: stavefejl, halvfærdige spørgsmål, implicit kontekst. Den bedste kilde til testtilfælde er derfor dine egne produktionsdata, forudsat at du får et menneske til at validere referencesvarene – ellers fryser du nuværende fejl som normen.

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ælg den rigtige bedømmer

Bedømmeren med eksakt match er den strengeste og hurtigste. Den passer kun til opgaver, hvor outputtet er begrænset: en klassificering i tre kategorier, udtrækning af et fakturanummer, et ja-eller-nej-svar. Brugt på fri tekst ville den give nul til et perfekt svar, blot fordi det er formuleret anderledes end referencen.

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"}

Inklusionsbedømmeren lemper begrænsningen: den tjekker for tilstedeværelsen af forventede nøgleord og returnerer en delvis score. Dette er det rigtige værktøj til svar, der skal dække obligatoriske punkter, uden at ordlyden betyder noget – f.eks. et supportsvær, der skal nævne fortrydelsesfristen og returadressen. Dens svaghed er velkendt: en tekst, der indeholder de rigtige ord i en absurd rækkefølge, ville få en perfekt score.

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",
    }

Så er der den mest kraftfulde: en anden LLM evaluerer svarets kvalitet. LLM-as-Judge-bedømmeren sætter pris på det, som ingen mekanisk regel kan – klarhed, fuldstændighed, tonens nøjagtighed. To implementeringsdetaljer gør den praktisk. For det første temperature=0.0: uden dette ville den samme dommer tildele forskellige scores til det samme svar fra én kørsel til den næste, og dit benchmark ville miste al sammenlignelig værdi. For det andet fallbacket for json.JSONDecodeError: en dommer, der kommenterer i stedet for at returnere JSON, bør ikke få hele kampagnen til at crashe.

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}

Saml den fulde evaluering

Orkestrering byder ikke på konceptuelle vanskeligheder: du itererer gennem datasættet, kalder modellen med system-prompten, der skal testes, anvender bedømmeren og aggregerer. Det interessante punkt er, at scoringfunktionen kommer ind som en parameter, hvilket lader dig afspille nøjagtig det samme datasæt med forskellige kriterier afhængigt af kampagnen – inklusion til et hurtigt tjek under udvikling, LLM-dommer til validering før 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 beholder min_score og detaljen for hvert tilfælde, og det er bevidst. Gennemsnittet fortæller dig, om du rykker fremad; tilfældene med den dårligste score fortæller dig hvorfor. Gør det til en vane at læse de fem dårligste svar fra hver kørsel, før du kommenterer på gennemsnittet: det er dér, og sjældent andre steder, du finder den næste rettelse, der skal laves.

Industrialisér med Promptfoo

At skrive dine evals i hånden i Python er lærerigt; at vedligeholde dem over tid er mere komfortabelt med et dedikeret værktøj. OpenAIs migrationsguide beskriver Promptfoos logik: evalueringen lever i en konfigurationsfil, promptfooconfig.yaml, som samler prompts, model(ler), testtilfælde og kriterier – her kaldet assertions. Den kører fra kommandolinjen, lokalt eller i din continuous integration, og lever side om side 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ømmerne i denne lektion genoptræder som assertions: eksakt match, nøgleordsinklusion og modelbedømmelse. OpenAI advarer om det sidste punkt: en genskabt bedømmer, især en LLM-dommer, skal valideres på ny, før den bruges til at afgøre en regression, fordi scorerne ikke nødvendigvis vil være identiske fra ét værktøj til et andet.

Vigtige pointer

  • Evals omdanner intuition til et objektivt kvalitetsmål
  • Opret dine datasæt ud fra rigtige produktionstilfælde, valideret af et menneske
  • Vælg bedømmeren ud fra opgaven: eksakt for begrænsede, inklusion for obligatoriske punkter, LLM-as-Judge for nuancer
  • Sæt temperature=0.0 på dommeren for at gøre scorerne reproducerbare
  • Kør evals før hver ændring af prompt eller model
  • OpenAIs Evals-platform lukker den 30. november 2026: Promptfoo, anbefalet af OpenAI, overtager datasæt, prompts, modeller og kriterier i en konfigurationsfil