Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

A/B-testen van prompts

Les 15 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. A/B-testen van prompts
  2. Principe
  3. A/B-testframework
  4. Evaluatiemetrics
  5. Volledig voorbeeld: twee promptstijlen testen
  6. Statistische significantie
  7. Uw eerste experiment uitvoeren
  8. 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). Oproepen 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.

A/B-testen van prompts

Met A/B-testen van prompts kunt u objectief twee versies van een prompt vergelijken met behulp van echt verkeer. In plaats van een prompt op basis van intuïtie te kiezen, meet u welke versie betere resultaten oplevert volgens uw bedrijfsdoelstellingen. Dit is de verplichte stap tussen prototyping en productie.

Principe

Inkomend verkeer wordt willekeurig verdeeld over twee (of meer) varianten van een prompt. Elk antwoord wordt geëvalueerd aan de hand van vooraf gedefinieerde criteria, en de winnende variant wordt uitgerold naar 100% van het verkeer.

De kracht van deze methode is dat beide varianten hetzelfde verkeer onder dezelfde omstandigheden en op hetzelfde moment verwerken. Alle externe variatiebronnen – seizoensgebondenheid, netwerkincidenten, de komst van een nieuwe categorie verzoeken – beïnvloeden beide groepen even sterk en heffen elkaar op in de vergelijking. Een sequentiële test kan dit niet garanderen: als u de oude prompt een week draait en de nieuwe de week erna, kunt u niet vaststellen of de verbetering door uw herschrijving kwam of door de kalender.

A/B-testframework

De klasse PromptExperiment heeft drie verantwoordelijkheden. assign_variant beslist welke variant een bepaald verzoek bedient, run voert de oproep uit en logt het resultaat, en get_stats aggregeert de gegevens.

De toewijzing verdient een toelichting. Wanneer een user_id wordt meegegeven, is de toewijzing deterministisch, berekend op basis van een hash van het experiment-gebruiker-paar. Dezelfde gebruiker blijft bij opeenvolgende oproepen in dezelfde groep. Deze continuïteit is geen theoretische verfijning: een klant die eerst een warm antwoord krijgt en drie minuten later een droog antwoord op een follow-up, zal denken dat het een bug is, en hun ontevredenheid zal beide varianten vervuilen.

Elke uitvoering registreert de invoer, uitvoer, verbruikte tokens en tijdstempel. Deze tokens zijn er niet voor de sier: een variant kan winnen op kwaliteit maar de responslengte verdubbelen, en _estimate_cost vertaalt dat verschil naar dollars zodat u een weloverwogen afweging kunt maken.

import random
import json
from datetime import datetime
from openai import OpenAI

client = OpenAI()

class PromptExperiment:
    """A/B-testframework voor 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:
        """Wijs een variant toe (sticky per user_id indien meegegeven)."""
        if user_id:
            # Deterministische toewijzing per gebruiker
            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:
        """Voert de prompt uit met de toegewezen 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:
        """Berekent statistieken per 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:
        """Schat de kosten in USD."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Evaluatiemetrics

Metrics hangen af van uw use case; twee families dekken de meeste scenario’s. Wanneer de taak een correct antwoord heeft – zoals het classificeren van een ticket of het extraheren van een veld – komt evaluatie neer op vergelijken met een referentielabel. Dat is de rol van evaluer_classification. Let op een instructieve keuze hier: parseerfouten worden behandeld als lege voorspellingen in plaats van dat er een uitzondering wordt gegenereerd, omdat een variant die ongeldige JSON produceert gestraft moet worden in de score, niet de meting moet laten crashen.

Wanneer de taak vrije tekst oplevert, is er geen enkel juist antwoord, dus vraagt u het model om te arbitrereren. evaluer_qualite_texte splitst het oordeel op in vier criteria – relevantie, duidelijkheid, volledigheid, professionele toon – in plaats van te vragen om een directe totaalscore. Deze opsplitsing maakt evaluatie stabieler en vertelt u op welk vlak de winnende variant uitblinkt: weten dat de winst komt door de toon en niet door volledigheid is precies de informatie die u nodig hebt om de volgende versie te schrijven.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Evalueert een classificatie-antwoord."""
    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:
    """Evalueert de kwaliteit van een tekstueel antwoord met behulp van het LLM."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vereist 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)

Volledig voorbeeld: twee promptstijlen testen

Het onderstaande experiment zet twee benaderingen voor klantenservice tegenover elkaar. De controle gebruikt een minimale, professionele en neutrale instructie. De “empatische” variant legt een driedelige structuur op: erken het probleem, toon empathie, stel vervolgens een concrete oplossing met stappen voor. Al het andere is identiek, van het model tot de temperatuur. Deze symmetrie is de voorwaarde om elk gemeten verschil aan de prompt toe te schrijven. Zowel de toon als de temperatuur tegelijk wijzigen, levert een oninterpreteerbaar resultaat op.

De vijf testtickets dekken bewust verschillende registers: een emotioneel geladen leveringsincident, een functionele bug, een neutrale vraag over wachtwoorden, een betwiste restitutieverzoek, en een API-storing gemeld door een technisch profiel. U verwacht dat de empatische variant de eerste twee domineert en straft krijgt bij de laatste, waar de gesprekspartner een status en een ETA wil, geen medeleven. Dit is de nuance die een globaal gemiddelde maskeert en die een ticket-per-ticket-onderzoek blootlegt – wat vaak leidt tot de echte beslissing: routeer op basis van het verzoektype in plaats van één toon te kiezen.

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

# Simuleer verkeer
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))

Statistische significantie

Trek niet te snel conclusies. Bij weinig data zijn resultaten ruis, en de klassieke fout is om 7,4 tegen 6,9 over twaalf waarnemingen te zien en een winnaar uit te roepen. De onderstaande Student’s t-test beantwoordt de enige vraag die telt: is het waargenomen verschil groter dan wat toeval natuurlijk zou produceren tussen twee equivalente reeksen?

Een p_value lager dan 0,05 betekent dat zo’n verschil onwaarschijnlijk zou zijn als de twee varianten gelijk waren. Daarboven heeft u niets bewezen – wat niet hetzelfde is als het bewijzen van gelijkheid. Meestal heeft u gewoon te weinig data. Reken op minimaal honderd waarnemingen per variant voordat u concludeert, en pas op voor de drang om elke ochtend de resultaten te controleren. Als u vaak genoeg kijkt, vindt u altijd een moment waarop het verschil zinvol lijkt.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Student's t-test om twee varianten te vergelijken."""
    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"
        )
    }

Uw eerste experiment uitvoeren

Kies een taak die u goed kent en zet een PromptExperiment op met twee varianten, waarbij u slechts één ding wijzigt tussen de controle en de variant: een toon, een opgelegde structuur of een aanvullende instructie. Definieer twee of drie metrics voordat u iets start, want het kiezen van de metric na het zien van de resultaten is alsof u de winnaar van tevoren kiest; het is de meest voorkomende bias in zelfgebouwde tests.

Draai het experiment op twintig invoeren en analyseer vervolgens. Kijk naar het gemiddelde, maar open vooral de gevallen waarin de twee varianten het meest divergeren: deze verklaren het verschil. Twintig waarnemingen zijn uiteraard niet genoeg om significantie te bereiken, en dat zelf inzien is beter dan het hier te lezen. Documenteer ten slotte de beslissing en archiveer de ruwe resultaten met de datum en de exacte variantconfiguratie – dit archief weerhoudt u ervan om over een jaar hetzelfde experiment opnieuw uit te voeren.

Belangrijkste punten

  • A/B-testen vervangt intuïtie door meetbare data
  • Wijs varianten deterministisch toe per gebruiker
  • Meet bedrijfsmetrics, niet alleen waargenomen kwaliteit
  • Wacht op statistische significantie voordat u concludeert
  • Documenteer elk experiment en de resultaten