Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Evalueer uw prompts: methoden, graders en migratie naar Promptfoo

Les 15 van 20 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Waarom u systematisch moet evalueren
  2. Bouw een dataset die uw realiteit weerspiegelt
  3. Kies de juiste grader
  4. Stel de volledige evaluatie samen
  5. Industrialiseer met Promptfoo
  6. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (Responses API) of reasoning_effort="none" (Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.

Update 2 november 2026 — Evals Platform. OpenAI heeft het einde van zijn Evals-platform aangekondigd: bestaande evaluaties zijn sinds 31 oktober 2026 alleen-lezen en het dashboard连同 de API sluiten op 30 november 2026, inclusief graders. OpenAI heeft een migratiegids naar Promptfoo gepubliceerd. De evaluatieprincipes in deze les blijven geldig; alleen de tool verandert.

Waarom u systematisch moet evalueren

U kunt niet verbeteren wat u niet meet. Wanneer u een prompt, een model of een parameter wijzigt, hoe weet u dan zeker dat de kwaliteit daadwerkelijk is verbeterd? De spontane methode is om drie of vier voorbeelden te proberen, de betere antwoorden te zoeken en te implementeren. Dit faalt regelmatig omdat de geteste voorbeelden precies die zijn die vorige week problemen veroorzaakten: u meet verbetering waar u naar zocht, en u mist regressies die zijn geïntroduceerd in gevallen die al werkten.

Evaluaties (evals) maken van deze intuïtie een objectieve maatstaf. Tot 2026 bood OpenAI hiervoor een geïntegreerd platform, Evals; dit is sinds 31 oktober 2026 alleen-lezen en sluit op 30 november. OpenAI raadt nu Promptfoo aan, een open-source tool voor evaluatie en red teaming. Het goede nieuws is dat beide dezelfde bouwstenen delen: testdata, prompts, modellen en scorecriteria. Wat u hier leert in Python-code is direct toepasbaar, en het laatste deel van de les toont de overstap naar Promptfoo.

Drie concepten structureren het hele proces. De dataset is een reeks testcases met inputs en verwachte outputs: dit is uw referentie, het equivalent van een unit-testsuite. De grader is een evaluatiecriterium—exacte overeenkomst, LLM-as-judge, score—dat beslist of een gegeven respons goed is. De run is een evaluatie-uitvoering op een dataset met een specifiek model en prompt; dit is de eenheid die u van de ene versie naar de volgende vergelijkt.

Bouw een dataset die uw realiteit weerspiegelt

Een testcase bestaat uit een input, een verwachte output en metadata. Deze laatste zijn niet decoratief: ze stellen u in staat om achteraf te constateren dat een totaalscore van 87% een instorting in de categorie “code” verbergt, gecompenseerd door uitstekende resultaten in aardrijkskunde. Zonder categorie of moeilijkheidsgraad heeft u slechts een geaggregeerd getal, en een geaggregeerd getal vertelt u nooit waar u moet ingrijpen.

import json

# Een dataset is een lijst van testcases
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"},
    },
]

# Opslaan als JSONL
with open("eval_dataset.jsonl", "w") as f:
    for case in dataset:
        f.write(json.dumps(case, ensure_ascii=False) + "\n")

Een op kantoor verzonnen dataset evalueert uw verbeelding, niet uw applicatie. Uw gebruikers formuleren hun verzoeken anders dan u doet: typefouten, half gestelde vragen, impliciete context. De beste bron van testcases is daarom uw eigen productiedata, mits een mens de referentieantwoorden valideert—anders bevriest u huidige fouten als de norm.

import openai
import random

client = openai.OpenAI()

def create_dataset_from_logs(
    production_logs: list[dict],
    sample_size: int = 100,
) -> list[dict]:
    """Maakt een evaluatiedataset van productielogs."""
    # Steekproef
    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"],  # Door een mens gevalideerde respons
            "metadata": {
                "source": "production",
                "date": log["date"],
                "original_model": log["model"],
            },
        })

    return dataset

Kies de juiste grader

De exacte overeenkomst-grader is de strengste en snelste. Deze is alleen geschikt voor taken waarbij de output beperkt is: een classificatie in drie categorieën, het extraheren van een factuurnummer, een ja-of-nee-antwoord. Gebruikt op vrije tekst, zou deze een perfect antwoord een nul geven simpelweg omdat het anders is geformuleerd dan de referentie.

def exact_grader(response: str, expected: str) -> dict:
    """Evalueert of de respons exact overeenkomt."""
    score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
    return {"score": score, "type": "exact"}

De inclusie-grader versoepelt de beperking: deze controleert op de aanwezigheid van verwachte trefwoorden en retourneert een gedeeltelijke score. Dit is het juiste instrument voor responsen die verplichte punten moeten behandelen zonder dat de formulering uitmaakt—bijvoorbeeld een supportrespons die de bedenktijd en het retouradres moet noemen. De zwakte is bekend: een tekst die de juiste woorden in een absurde volgorde bevat, zou een perfecte score krijgen.

def inclusion_grader(response: str, keywords: list[str]) -> dict:
    """Controleert of de respons de verwachte trefwoorden bevat."""
    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",
    }

Dan is er de krachtigste: een andere LLM evalueert de kwaliteit van de respons. De LLM-as-Judge-grader waardeert wat geen enkele mechanische regel kan—duidelijkheid, volledigheid, toonaccuratesse. Twee implementatiedetails maken dit praktisch. Ten eerste, temperature=0.0: zonder dit zou dezelfde judge verschillende scores toekennen aan dezelfde respons van de ene run naar de andere, en zou uw benchmark alle vergelijkende waarde verliezen. Ten tweede, de fallback voor json.JSONDecodeError: een judge die commentaar geeft in plaats van JSON terug te sturen, mag niet de hele campagne laten crashen.

def llm_judge_grader(
    question: str,
    response: str,
    expected: str,
    criteria: str = "accuracy, completeness, clarity",
) -> dict:
    """Gebruikt een LLM om de responskwaliteit te evalueren."""
    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 vereist 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}

Stel de volledige evaluatie samen

Orkestratie presenteert geen conceptuele moeilijkheid: u iterereert door de dataset, roept het model aan met de te testen systeemprompt, past de grader toe en aggregeert. Het interessante punt is dat de scorefunctie als parameter binnenkomt, waardoor u exact dezelfde dataset opnieuw kunt uitvoeren met verschillende criteria afhankelijk van de campagne—inclusie voor een snelle check tijdens ontwikkeling, LLM-judge voor validatie voor productie.

async def run_eval(
    dataset: list[dict],
    model: str,
    system_prompt: str,
    grader_fn,
) -> dict:
    """Voert een volledige evaluatie uit op een 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,
        })

    # Bereken geaggregeerde metrieken
    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,
    }

Het rapport behoudt min_score en de details van elke testcase, en dat is opzettelijk. Het gemiddelde vertelt u of u vooruitgang boekt; de slechtst gescoorde cases vertellen u waarom. Maak er een gewoonte van om de vijf slechtste responsen van elke run te lezen voordat u commentaar geeft op het gemiddelde: daar, en zelden elders, vindt u de volgende oplossing die u moet toepassen.

Industrialiseer met Promptfoo

Het handmatig schrijven van uw evals in Python is leerzaam; ze in de loop der tijd onderhouden is comfortabeler met een gespecialiseerde tool. De migratiegids van OpenAI beschrijft de logica van Promptfoo: de evaluatie leeft in een configuratiebestand, promptfooconfig.yaml, dat prompts, model(len), testcases en criteria—hier assertions genoemd—samenbrengt. Het draait vanaf de commandoregel, lokaal of in uw continuous integration, en leeft naast de applicatiecode.

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 geval van configuratiefout

De graders in deze les keren terug als assertions: exacte overeenkomst, trefwoordinclusie en modeloordeel. OpenAI waarschuwt voor het laatste punt: een opnieuw gemaakte grader, vooral een LLM-judge, moet opnieuw worden gevalideerd voordat deze wordt gebruikt om over een regressie te beslissen, omdat scores niet noodzakelijkerwijs identiek zullen zijn van de ene tool naar de andere.

Belangrijkste punten

  • Evals maken van intuïtie een objectieve kwaliteitsmaatstaf
  • Creëer uw datasets op basis van echte productiecases, gevalideerd door een mens
  • Kies de grader op basis van de taak: exact voor beperkte outputs, inclusie voor verplichte punten, LLM-as-Judge voor nuance
  • Stel temperature=0.0 in bij de judge om scores reproduceerbaar te maken
  • Voer evals uit vóór elke wijziging in prompt of model
  • Het Evals-platform van OpenAI sluit op 30 november 2026: Promptfoo, aanbevolen door OpenAI, neemt datasets, prompts, modellen en criteria over in een configuratiebestand