A/B-testen en zakelijke metrics
Op deze pagina
Update 2 november 2026 — Beschikbaarheid fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd uitgefaseerd: sinds 7 mei 2026 kunnen organisaties die dit nog nooit hebben gebruikt geen taken meer aanmaken; sinds 2 juli moet u binnen de laatste 60 dagen een fine-tuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.
Voorbij verlies: zakelijke impact meten
Trainingsverlies en kwaliteitsscores volstaan niet. Wat echt telt, is de impact van uw fine-tuned model op uw zakelijke KPI’s: klanttevredenheid, oplostijd, conversiepercentage. Een model kan antwoorden produceren die uw reviewers elegant vinden, terwijl het tegelijkertijd het escalatiepercentage naar uw menselijke agents verhoogt. Dat tweede cijfer bepaalt de toekomst van het project, niet het eerste.
Een A/B-test opzetten
Een A/B-test vergelijkt twee varianten onder reële omstandigheden met authentiek verkeer. Groep A, de controlegroep, ontvangt antwoorden van het basismodel met uw geoptimaliseerde prompt; Groep B, de testgroep, krijgt antwoorden van het fine-tuned model. Gebruikers worden willekeurig aan beide groepen toegewezen en u meet de resultaten met dezelfde metrics. De volledige geldigheid van de oefening hangt af van deze toewijzing: als Groep B per ongeluk de eenvoudigste verzoeken ontvangt, meet zijn schijnbare superioriteit niets anders dan dat geluk.
De functie choisir_variante lost dit probleem op door de gebruikers-ID te hashen. Deze aanpak garandeert dat dezelfde gebruiker altijd dezelfde variant ziet—essentieel, omdat afwisselen tussen sessies de persoon zou blootstellen aan twee antwoordstijlen en hun tevredenheidsbeoordeling zou verstoren. Het produceert een statistisch evenwichtige verdeling zodra het volume toereikend is, en het blijft reproduceerbaar: het later opnieuw uitvoeren van de berekening levert exact dezelfde groepen op, zodat u een vergeten metric kunt herberekenen zonder de test opnieuw te starten.
import random
import hashlib
from openai import OpenAI
client = OpenAI()
MODELE_BASE = "gpt-5.6-luna"
MODELE_FT = "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
PROMPT_BASE = "You are a professional customer support assistant..."
def choisir_variante(user_id: str, pourcentage_test: int = 50) -> str:
"""Assigns a user to group A or B deterministically."""
h = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
return "B" if (h % 100) < pourcentage_test else "A"
def repondre(user_id: str, question: str) -> dict:
"""Responds with the correct model based on the A/B group."""
variante = choisir_variante(user_id)
if variante == "A":
response = client.responses.create(
model=MODELE_BASE,
instructions=PROMPT_BASE,
input=question
)
else:
response = client.responses.create(
model=MODELE_FT,
input=question
)
return {
"variante": variante,
"modele": MODELE_BASE if variante == "A" else MODELE_FT,
"reponse": response.output_text,
"user_id": user_id
}
De juiste zakelijke metrics kiezen
De te volgen indicatoren hangen volledig af van wat uw assistent moet leveren, en elke use-case-familie heeft zijn eigen set.
Voor een klantenservice beantwoordt het percentage oplossingen bij eerste contact de meest concrete vraag: moest de gebruiker opnieuw contact opnemen met de support? De CSAT-score, een tevredenheidsbeoordeling van 1 tot 5 verzameld na de interactie, vat sentiment vast dat geautomatiseerde metrics missen. Oplostijd meet de totale duur van de uitwisseling, en het escalatiepercentage—het deel van de gesprekken dat aan een mens wordt overgedragen—leest als een toegeving van modelfalen voor de betrokken cases. Succesvolle fine-tuning verlaagt doorgaans beide laatsten gelijktijdig.
Voor een verkoopchatbot verschuift de redenering stroomafwaarts. Het conversiepercentage telt gesprekken die leiden tot een aankoop of afspraak; het engagementpercentage, uitgedrukt als het gemiddelde aantal berichten per gesprek, vereist zorgvuldige interpretatie aangezien een langere uitwisseling zowel interesse als misverstand kan signaleren; het bouncepercentage isoleert gebruikers die vertrekken na het eerste bericht, vaak omdat het initiële antwoord de plank missloeg.
Voor een classificatie- of extractietaak keert u terug naar het klassieke trio. Precisie geeft het percentage correcte classificaties, recall het percentage daadwerkelijk gedetecteerde positieve cases, en de F1-score, het harmonisch gemiddelde van beide, voorkomt dat u genoegen neemt met een model dat de zeldzame klasse nooit voorspelt om fouten te vermijden.
Metingen verzamelen
Deze indicatoren zijn nutteloos als ze in drie aparte spreadsheets leven. Een enkele collector, gevoed bij elke interactie, houdt de variant bij alongside de metric en maakt het mogelijk om met één commando een vergelijkend rapport te produceren. De onderstaande klasse ABTracker doet dit minimale werk: het logt, groepeert vervolgens per variant en berekent gemiddelden en percentages.
import datetime
class ABTracker:
"""Metric collector for A/B testing."""
def __init__(self):
self.events = []
def log_interaction(
self,
user_id: str,
variante: str,
question: str,
reponse: str,
metriques: dict
):
"""Records an interaction with its metrics."""
self.events.append({
"timestamp": datetime.datetime.now().isoformat(),
"user_id": user_id,
"variante": variante,
"question": question,
"reponse": reponse,
**metriques
})
def rapport(self) -> dict:
"""Generates a comparative A vs B report."""
groupes = {"A": [], "B": []}
for e in self.events:
groupes[e["variante"]].append(e)
rapport = {}
for variante, events in groupes.items():
if not events:
continue
rapport[variante] = {
"nb_interactions": len(events),
"csat_moyen": self._moyenne(events, "csat"),
"resolution_premier_contact": self._taux(events, "resolu"),
"temps_moyen_sec": self._moyenne(events, "temps_resolution"),
}
return rapport
def _moyenne(self, events, cle):
vals = [e[cle] for e in events if cle in e and e[cle] is not None]
return sum(vals) / len(vals) if vals else None
def _taux(self, events, cle):
vals = [e[cle] for e in events if cle in e]
return sum(vals) / len(vals) * 100 if vals else None
tracker = ABTracker()
Wachten op statistische significantie
Trek geen te vroeg conclusies. Na twintig interacties per groep heeft een CSAT-kloof van 0,4 punt geen waarde: drie tevreden klanten volstaan om deze te produceren. U hebt voldoende interacties nodig om resultaten significant te maken, en de onderstaande benchmarks geven u de orde van grootte om naar te streven voordat u zelfs maar naar de cijfers kijkt.
Zodra u dat volume bereikt, beslist een statistische test voor u. De Mann-Whitney-test werkt goed voor tevredenheidsscores, dit zijn ordinale ratings die zelden normaal verdeeld zijn. De p-waarde beantwoordt een precieze vraag: wat is de kans op het observeren van zo’n grote kloof als de twee modellen eigenlijk gelijk waren? Onder de 0,05 wordt de hypothese van louter toeval moeilijk verdedigbaar.
from scipy import stats
def test_significativite(scores_a: list[float], scores_b: list[float]):
"""Tests whether the difference between A and B is significant."""
stat, p_value = stats.mannwhitneyu(scores_a, scores_b, alternative="two-sided")
moy_a = sum(scores_a) / len(scores_a)
moy_b = sum(scores_b) / len(scores_b)
print(f"Mean A: {moy_a:.3f}")
print(f"Mean B: {moy_b:.3f}")
print(f"p-value: {p_value:.4f}")
if p_value < 0.05:
gagnant = "B (fine-tuned)" if moy_b > moy_a else "A (base)"
print(f"Significant difference — {gagnant} is better")
else:
print("No significant difference")
Geleidelijk opschalen
Zelfs een succesvolle test rechtvaardigt niet om overnight al het verkeer om te schakelen: een fout die slechts één op de duizend voorkomt, blijft onzichtbaar op een steekproef en wordt zeer zichtbaar bij volledig volume. Werk in fasen van één week en controleer uw metrics bij elke stap voordat u de volgende opent.
- Fase 1 (1 week): 10% verkeer op het fine-tuned model
- Fase 2 (1 week): 30% als de metrics positief zijn
- Fase 3 (1 week): 50% voor de hoofd-A/B-test
- Fase 4: 100% als de test conclusief is
Als een fase uw metrics verslechtert, keer dan terug naar de vorige in plaats van de volgende te openen in de hoop dat het cijfer vanzelf herstelt. Een week besteed aan het begrijpen van waarom, kost altijd minder dan een maand verkeer bediend door een teleurstellend model.
Belangrijkste punten
- Zakelijke metrics zijn belangrijker dan trainingsverlies
- Gebruik deterministische hashing voor A/B-toewijzing
- Wacht op statistische significantie voordat u concludeert (p < 0,05)
- Implementeer geleidelijk: 10%, 30%, 50%, 100%
- Meet kosten en latentie naast kwaliteit