Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Geautomatiseerde Prompt-evaluatie

Les 16 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Geautomatiseerde Prompt-evaluatie
  2. Soorten Evaluatie
  3. Volledige Evaluatiepijplijn
  4. Testsuite: Formaat
  5. CI/CD-integratie
  6. Evaluatiedashboard
  7. Stel uw Vangrails In
  8. Belangrijkste punten
  9. Test uw Kennis

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.

Geautomatiseerde Prompt-evaluatie

Geautomatiseerde evaluatie is de hoeksteen van een volwassen prompt-engineeringpijplijn. Hiermee detecteert u regressies, vergelijkt u modellen en valideert u wijzigingen voordat ze worden uitgerold. Zonder dit is elke promptwijziging een blind gokspel.

Soorten Evaluatie

Drie families van evaluatoren verdelen het werk op basis van de aard van de verwachte output; u zult bijna altijd meerdere combinaties gebruiken.

Exacte Match-evaluatie

Voor taken met één verwacht antwoord volstaat een directe vergelijking. eval_exact_match normaliseert hoofdletters en witruimte voordat het vergelijkt: zonder deze voorzorgsmaatregel zouden “Bug” en “bug” als een fout tellen, waardoor u een probleem gaat oplossen dat niet bestaat.

eval_set_match behandelt gevallen waarin het antwoord een verzameling is—entiteiten gevonden in een document, categorieën toegewezen aan een artikel. Het leidt precisie en recall af, twee cijfers die verschillende verhalen vertellen: hoge precisie met lage recall wijst op een te voorzichtig model dat alleen extrahiert waarvan het zeker is; het omgekeerde verraadt een model dat hallucineert om gaten op te vullen. F1 vat ze handig samen, maar vervangt ze niet voor diagnose.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Exacte match na normalisatie."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Verzamelingsmatch (entiteiten, categorieën)."""
    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}

Semantische Evaluatie (Embedding)

Voor tekstantwoorden waar de formulering kan variëren, wordt exacte match absurd: “Uw bestelling wordt morgen bezorgd” en “De levering is gepland voor morgen” zeggen hetzelfde, maar zouden toch een score van nul krijgen. Cosinusovereenkomst tussen embeddings meet semantische nabijheid in plaats van tekenvergelijking en retourneert een continue score.

U stelt de drempelwaarde in waarboven een antwoord als aanvaardbaar wordt beschouwd. Kalibreer deze op enkele tientallen paren die u handmatig heeft geclassificeerd als “equivalent” of “verschillend”, en kies vervolgens de waarde die de twee groepen het beste scheidt: een drempel gekozen op onderbuikgevoel levert resultaten op die even willekeurig zijn als geen enkele meting, met de extra illusie van nauwkeurigheid.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Cosinusovereenkomst tussen 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-evaluatie (LLM-as-Judge)

Het model evalueert de kwaliteit van een antwoord. Dit is de enige haalbare aanpak wanneer er geen referentie bestaat: niemand gaat voor tweehonderd tickets het “correcte” supportantwoord handmatig schrijven.

Wat een judge bruikbaar maakt, hangt af van een paar dingen. Ten eerste het gebruikte model: u kiest een capabeler model als judge, hier gpt-5.6-sol, omdat een judge op hetzelfde niveau als de geëvalueerde diens eigen gebreken neigt te valideren. Ten tweede het vereisen van een onderbouwing: het motiveren van elke score stabiliseert het oordeel en stelt u in staat een evaluator te spotten die het verkeerde criterium hanteert—een onderbouwing die lengte bespreekt terwijl het criterium duidelijkheid was, is een rode vlag. Tot slot zorgt temperature op 0.1 voor scorestabiliteit tussen runs.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Evaluatie door een judge-model."""
    criteria_text = "\n".join(
        f"- {c}: score van 1 tot 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Capabeler model als judge
        reasoning={"effort": "none"},  # temperature vereist effort none
        instructions="U bent een deskundige, onpartijdige evaluator.",
        input=f"""Evalueer dit antwoord volgens de volgende criteria:

Gestelde vraag: {question}

Te evalueren antwoord: {prediction}

Criteria:
{criteria_text}

Geef voor elk criterium een score van 1 tot 5 met onderbouwing.""",
        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)

Volledige Evaluatiepijplijn

EvalPipeline assembleert deze bouwstenen: het laadt een testsuite, voert de prompt op elk geval uit, past alle verstrekte evaluatoren toe en aggregeert scores. Evaluatoren worden doorgegeven als een lijst met functies, allemaal aangeroepen met dezelfde signatuur; het toevoegen van een metriek vereist daarom geen wijziging in de pijplijn, en u kunt exacte match, semantische overeenkomst en een judge uitvoeren op dezelfde uitvoering zonder drie keer te betalen voor generatie.

De methode summary accumuleert ook verbruikte tokens. Deze ogenschijnlijk secundaire regel beschermt u tegen een veelvoorkomende valkuil: een promptversie die twee scorepunten wint terwijl de rekening verdrievoudigt, is niet per se de juiste keuze, en het is beter dat te leren op het moment van afweging dan wanneer de maandelijkse factuur arriveert.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Een testgeval voor evaluatie."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Geautomatiseerde evaluatiepijplijn."""

    def __init__(self, test_suite_path: str):
        """Laadt de testsuite vanuit een JSON-bestand."""
        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:
        """Voert alle tests uit en evalueert resultaten."""
        self.results = []

        for tc in self.test_cases:
            # Genereer antwoord
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature vereist effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Evalueer met elke 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:
        """Vat evaluatieresultaten samen."""
        if not self.results:
            return {"error": "Geen resultaten"}

        # Aggregeer scores per 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: Formaat

Het formaat van de testsuite blijft opzettelijk minimaal: een input, de verwachte output en metadata in vrije vorm. Deze metadata is nuttiger dan het lijkt—door elk geval te taggen per categorie, breekt u scores af en ontdekt u dat uw classifier niet willekeurig faalt, maar op een specifieke familie van verzoeken, wat een globaal gemiddelde van 88% niet onthult. De drie onderstaande voorbeelden tonen ook wat een goede suite moet bevatten: duidelijke gevallen, zoals een crash bij opstarten, maar ook gevallen die grenzen aan een andere categorie—een vraag over een ontbrekende functie lijkt veel op een bugrapport, en het is op deze grens dat de kwaliteit van een classifier wordt beslist.

[
    {
        "input_text": "Mijn pakket is niet aangekomen",
        "expected_output": "klacht",
        "metadata": {"category": "levering"}
    },
    {
        "input_text": "Hoe schakel ik de donkere modus in?",
        "expected_output": "vraag",
        "metadata": {"category": "functie"}
    },
    {
        "input_text": "De app crasht bij opstarten op iOS 18",
        "expected_output": "bug",
        "metadata": {"category": "technisch"}
    }
]

CI/CD-integratie

Voer evaluatie uit bij elke promptwijziging. De functie ci_eval_check verandert meting in een vangrail: deze voert de pijplijn uit, vergelijkt de gemiddelde score met een drempelwaarde en retourneert een boolean die uw integratieketen interpreteert als een geslaagde of mislukte build. Een wijziging die de precisie onder de 85% laat zakken, bereikt niet langer de productie, net zoals een gebroken unit-test een merge blokkeert.

Stel de drempelwaarde in op basis van de score die al door de huidige versie is behaald, niet vanuit een ideaalbeeld. Stelt u deze te hoog in, dan veroordeelt u het team tot het omzeilen van verificatie met tijdelijke deactiveringen die permanent worden; stelt u deze te laag in, dan controleert u niets terwijl u een groen badge toont. Houd tot slot in gedachten dat de suite representatief moet blijven voor echt verkeer: een drempel gehaald op twintig gevallen die twee jaar geleden zijn geschreven, bewijst niets over de verzoeken van vandaag.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """CI/CD-poort: controleert of de prompt aan de minimumscore voldoet."""
    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"Gemiddelde score: {avg_score:.2%}")
    print(f"Minimumdrempel: {min_score:.2%}")

    if avg_score < min_score:
        print("MISLUKT: score onder drempelwaarde")
        return False

    print("GESLAAGD: prompt gevalideerd")
    return True

Evaluatiedashboard

Volg de score-evolutie in de tijd. Een enkele score zegt niets; de reeks vertelt het verhaal van uw prompt en beantwoordt de vraag die altijd opkomt in vergaderingen: boeken we vooruitgang? De onderstaande functie produceert een Markdown-tabel die voor elke versie de gemiddelde score, verbruikte tokens en geschatte kosten naast elkaar plaatst. Het formaat is niet toevallig: het plakt direct in een pull request, waardoor vergelijking leesbaar wordt voor mensen die uw code nooit zullen openen.

def comparison_report(results: dict[str, dict]) -> str:
    """Genereert een vergelijkend rapport tussen promptversies."""
    report = "# Vergelijkend Evaluatierapport\n\n"
    report += "| Versie | Gemiddelde Score | Gemiddelde Tokens | Kosten |\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

Stel uw Vangrails In

Bouw een suite van twintig testgevallen voor een echte prompt, waarbij u een handvol randgevallen plaatst in plaats van twintig comfortabele voorbeelden: een suite die bij de eerste poging voor 100% slaagt, leert u niets. Implementeer de drie evaluatortypes en voer ze samen uit op twee versies van uw prompt. Exacte match geeft een schoon getal, semantische overeenkomst vangt legitieme herformuleringen, en de judge belicht gevallen waarin de eerste twee het oneens zijn—deze meningsverschillen zijn het rijkst aan lessen over wat u eigenlijk van het model verwacht.

Vergelijk, identificeer de winnende versie en stel vervolgens het CI-script in dat implementatie blokkeert als de score daalt. U weet dat het systeem werkt op de dag dat het een wijziging afwijst waarvan u dacht dat deze voor de hand lag.

Belangrijkste punten

  • Geautomatiseerde evaluatie is essentieel om met vertrouwen te itereren
  • Combineer exacte, semantische en LLM-as-judge-evaluatie naar behoefte
  • Onderhoud een testsuite die evolueert met uw applicatie
  • Integreer evaluatie in uw CI/CD met een minimumdrempel
  • Gebruik een capabeler model als judge om een goedkoper model te evalueren
  • Documenteer scores van elke versie om evolutie te volgen

Test uw Kennis

Geavanceerde technieken en industrialisatie: de laatste controle.

1. Wat bevat een effectieve systeemprompt?

Antwoord: Rol, reikwijdte, gedragsregels, outputformaat en afhandeling van randgevallen—geschreven als een specificatie, getest als code.

2. Wanneer moet u self-consistency gebruiken?

Antwoord: Bij redeneerproblemen met verifieerbare antwoorden: genereer meerdere onafhankelijke redeneringen en houd het meerderheidsantwoord—variantie wordt een bondgenoot.

3. Wat garandeert JSON-modus met schema-afdwinging?

Antwoord: Output die strikt conform het schema is (typen, verplichte velden, enums)—gevalideerd aan de API-kant en opnieuw gevalideerd in code (JSON Schema, Zod) voor een keten zonder verrassingen.

4. Wat is grounding?

Antwoord: Antwoorden verankeren in verstrekte feiten (documenten, opgehaalde gegevens) in plaats van het geheugen van het model—met de eis om bronnen buiten deze te citeren of zich ervan te onthouden.

5. Wat is het doel van een versiebeheerde promptcatalogus?

Antwoord: Prompts behandelen als artefacten: versies, A/B-tests, geautomatiseerde evaluaties bij elke wijziging—u weet wat er in productie draait en waarom.

De laatste lus van de cursus—versiebeheer, test, automatisch evalueren—transformeert ambachtelijk prompt-engineering naar een teampraktijk.