Gestratificeerde steekproeven en kalibratie
Neem steekproeven per segment; kalibreer met gelabelde validatiesets
Gestratificeerde steekproeven en kalibratie is een gratis Claude Architect-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Claude Architect. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Claude Architect bevat in totaal 4 lessen.
Waarom geaggregeerde nauwkeurigheid misleidt
Je brengt een Claude-extractiepijplijn uit en rapporteert 97% nauwkeurigheid. Het management keurt volledige automatisering goed. Drie weken later is elke restitutiefactuur met een regel in vreemde valuta onjuist.
Het prominente getal was echt — maar het was een gemiddelde. Geaggregeerde nauwkeurigheid kan catastrofale fouten bij een specifiek documenttype of veld verbergen, omdat de veelvoorkomende gevallen de zeldzame gevallen overschaduwen.
Deze les gaat over de discipline die je eerlijk houdt voordat je automatiseert: gestratificeerde steekproeven om te meten waar je werkelijk fouten maakt, en kalibratie op gelabelde validatiesets zodat je betrouwbaarheidsscores betekenis hebben.
De hoofdregel
Onthoud het principe op examenniveau uit het domein van toezicht:
Geaggregeerde nauwkeurigheid kan slechte prestaties bij een specifiek documenttype of veld verbergen. Gebruik gestratificeerde willekeurige steekproeven plus op veldniveau gekalibreerd vertrouwen op gelabelde validatiesets voordat je automatiseert.
Twee stappen, in deze volgorde:
- Stratificeer en neem daarna steekproeven — verdeel de populatie in segmenten en neem binnen elk segment een steekproef, zodat zeldzame maar kritieke deelverzamelingen daadwerkelijk worden gemeten.
- Kalibreer het vertrouwen — zorg dat het vertrouwen van het model per veld overeenkomt met de werkelijke juistheid, aangetoond aan de hand van labels die de grondwaarheid weergeven.
Sla een van beide stappen over en je gokt in plaats van dat je bestuurt.
Waarom willekeurige steekproeven niet genoeg zijn
Een gewone willekeurige steekproef neemt vooral veelvoorkomende gevallen. Als 95% van je facturen eenvoudige bonnetjes in één valuta zijn, bevat een willekeurige steekproef van 200 ongeveer 190 eenvoudige gevallen en misschien maar een handvol moeilijke gevallen met vreemde valuta — te weinig om een foutenpercentage van 40% in die deelverzameling te ontdekken.
Gestratificeerde steekproeven lossen dit op: definieer relevante segmenten (documenttype, taal, leverancier, aanwezigheid van velden) en trek vervolgens een steekproef uit elk segment. Nu wordt de zeldzame deelverzameling gemeten met voldoende statistische zeggingskracht om duidelijk aan te tonen dat er iets mis is.
Je meet de populatie waar je je zorgen over maakt, niet de populatie die toevallig het grootst is.
Je strata kiezen
Goede strata isoleren de dimensies waarin gedrag waarschijnlijk uiteenloopt. Voor een pijplijn voor gestructureerde extractie (Scenario 6) zijn de volgende segmenten nuttig:
- Documenttype — factuur versus kassabon versus overzicht.
- Veld — totalen, datums, valuta, regelitems. Het niveau van afzonderlijke velden is belangrijk, omdat
97%als totaal60%voor het valutaveld kan verbergen. - Randvoorwaarden — documenten van meerdere pagina's, gescande documenten of documenten van lage kwaliteit, meertalige documenten, of records waarin een optioneel veld ontbreekt.
Dat laatste hangt samen met een schemaregel: markeer een mogelijk ontbrekend veld nooit als verplicht, anders verzint het model een waarde. Stratificeer op aanwezigheid en afwezigheid om verzonnen waarden op te sporen.
Een gestratificeerde steekproef trekken
Concreet: groepeer je validatiepool per segment en trek uit elk segment een vaste hoeveelheid — genoeg per stratum om de metriek per stratum te vertrouwen, en niet evenredig aan de omvang van de populatie.
import random
from collections import defaultdict
# Each record carries the dimensions we stratify on.
def segment_key(rec):
return (rec["doc_type"], rec["has_currency_line"], rec["is_multilingual"])
buckets = defaultdict(list)
for rec in validation_pool:
buckets[segment_key(rec)].append(rec)
# Fixed quota per stratum -> rare slices get real coverage,
# not just a couple of incidental samples.
PER_STRATUM = 40
sample = []
for key, recs in buckets.items():
random.shuffle(recs)
sample.extend(recs[:PER_STRATUM])
print({k: min(len(v), PER_STRATUM) for k, v in buckets.items()})Vertrouwen op veldniveau, niet alleen een oordeel
Om te kalibreren moet het model een vertrouwensscore per veld produceren, niet één algemene score. Dwing gestructureerde uitvoer af, zodat vertrouwen een getypeerd veld is dat je kunt controleren — geen proza dat je moet ontleden.
Gebruik tool_choice om te garanderen dat het model het schema teruggeeft. "any" dwingt het model om een tool aan te roepen; {"type":"tool","name":"X"} dwingt een specifieke tool af. Een JSON Schema elimineert syntaxisfouten en dwingt verplichte velden af.
extract_tool = {
"name": "emit_extraction",
"description": "Return extracted fields, each with a per-field confidence in [0,1].",
"input_schema": {
"type": "object",
"properties": {
"fields": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {"type": "string"},
"value": {"type": "string"},
"confidence": {"type": "number"}
},
"required": ["name", "value", "confidence"]
}
}
},
"required": ["fields"]
}
}
resp = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
tools=[extract_tool],
tool_choice={"type": "tool", "name": "emit_extraction"},
messages=[{"role": "user", "content": invoice_text}],
)Wat kalibratie werkelijk betekent
Een model is gekalibreerd wanneer het opgegeven vertrouwen overeenkomt met de waargenomen nauwkeurigheid: van alle velden waarvoor het model 0.90 vertrouwen aangeeft, moet ongeveer 90% volgens de grondwaarheid correct zijn.
Het onbewerkte vertrouwen van een model is meestal te hoog — het zegt 0.95, maar heeft slechts 70% van de tijd gelijk. Je kunt een drempel voor automatische acceptatie die op niet-gekalibreerde scores is gebaseerd niet vertrouwen; je zou onjuiste gegevens automatisch goedkeuren.
Voor kalibratie zijn gelabelde validatiesets nodig: door mensen geverifieerde grondwaarheid voor je gestratificeerde steekproef. Er is geen snelkoppeling — alleen het door het model zelf ingeschatte vertrouwen is precies het soort signaal dat het examen je vertelt NIET te vertrouwen voor geautomatiseerde beslissingen.
Kalibratie meten met labels
Groepeer voorspellingen op basis van het opgegeven vertrouwen en vergelijk vervolgens het opgegeven vertrouwen van elke groep met de werkelijke nauwkeurigheid op de gelabelde set. Het verschil is je kalibratiefout — en je berekent die per stratum, zodat een goed gekalibreerde 'eenvoudige' deelverzameling een gebrekkige 'moeilijke' deelverzameling niet kan verbergen.
from collections import defaultdict
# preds: list of {stratum, confidence, predicted, ground_truth}
bins = defaultdict(lambda: {"n": 0, "correct": 0, "conf_sum": 0.0})
for p in preds:
b = round(p["confidence"], 1) # 0.0..1.0 buckets
key = (p["stratum"], b)
bins[key]["n"] += 1
bins[key]["conf_sum"] += p["confidence"]
bins[key]["correct"] += int(p["predicted"] == p["ground_truth"])
for (stratum, b), s in sorted(bins.items()):
stated = s["conf_sum"] / s["n"]
actual = s["correct"] / s["n"]
print(stratum, b, f"stated={stated:.2f} actual={actual:.2f} gap={stated-actual:+.2f}")Drempels voor automatische acceptatie per segment instellen
Leid na kalibratie voor elke stratum een vertrouwensdrempel af die aan je nauwkeurigheidsnorm voldoet — accepteer bijvoorbeeld automatisch alleen waar de gekalibreerde nauwkeurigheid ≥ 99% is. De drempel verschilt per segment: eenvoudige facturen in één valuta kunnen automatisch worden geaccepteerd bij 0.85, terwijl regels met vreemde valuta 0.98 nodig hebben — of volledig door mensen gecontroleerd moeten blijven worden.
Dit vormt de brug van meten naar toezicht: strata met weinig vertrouwen of lage nauwkeurigheid worden naar een mens gestuurd; gekalibreerde strata met veel vertrouwen worden geautomatiseerd. Eén algemene drempel zou de moeilijke deelverzameling óf te veel vertrouwen óf de eenvoudige onnodig tegenhouden.
Zelfcorrectie versterkt het signaal
Het vertrouwen neemt toe wanneer het model zichzelf kan controleren. Laat het bij numerieke extractie zowel een calculated_total (som van de regelitems) als de op het document afgedrukte stated_total produceren en markeer vervolgens elke afwijking. Een verschil is een hard, deterministisch signaal — veel betrouwbaarder dan een zelf ingeschat vertrouwensgetal.
Combineer dit met herkomst: bewaar de bron van elke claim (documentnaam, citaat, pagina), zodat een gemarkeerd veld kan worden getraceerd en geverifieerd, in plaats van alleen opnieuw te worden geraden.
verify_schema = {
"name": "emit_totals",
"description": "Extract both the computed and printed total so discrepancies are detectable.",
"input_schema": {
"type": "object",
"properties": {
"line_items": {"type": "array", "items": {"type": "number"}},
"calculated_total": {"type": "number"},
"stated_total": {"type": "number"},
"source_quote": {"type": "string"}
},
"required": ["calculated_total", "stated_total", "source_quote"]
}
}
# Deterministic check beats trusting a self-rated score:
# discrepancy = abs(out['calculated_total'] - out['stated_total']) > 0.01Voer de audit buiten het kritieke pad uit
Gestratificeerde kalibratie-audits zijn grote, niet-blokkerende taken — precies waarvoor de Message Batches API bedoeld is: 50% goedkoper, met een venster van maximaal 24 uur en zonder latentie-SLA. Voer je nachtelijke kalibratiecontrole uit als batch; koppel resultaten met custom_id en dien alleen de fouten opnieuw in.
De grens is belangrijk voor het examen: gebruik de Batch API nooit voor blokkerende of tijdgevoelige controles (deze heeft geen latentie-SLA en ondersteunt geen aanroepen van tools in meerdere beurten). Een poort vóór het samenvoegen of een live-extractie blijft op de synchrone API; de periodieke audit gaat naar batch.
requests = [
{
"custom_id": f"val-{rec['id']}",
"params": {
"model": "claude-sonnet-4-5",
"max_tokens": 1024,
"tools": [extract_tool],
"tool_choice": {"type": "tool", "name": "emit_extraction"},
"messages": [{"role": "user", "content": rec["text"]}],
},
}
for rec in stratified_sample
]
batch = client.messages.batches.create(requests=requests)
# Overnight audit: no latency SLA, 50% cheaper. NOT for pre-merge gates.Korte controle: automatisering goedkeuren
Pas de regel toe op een echte beslissing om wel of niet door te gaan.
Samenvatting: meet voordat je vertrouwt
Belangrijkste punten voor het examen en voor productie:
- Geaggregeerde nauwkeurigheid verbergt fouten per type en per veld — automatiseer nooit alleen op basis van een prominent gemiddelde.
- Gestratificeerde willekeurige steekproeven verdelen op basis van de relevante dimensies (documenttype, veld, randvoorwaarden) en nemen uit elk segment een steekproef, waardoor zeldzame deelverzamelingen echte statistische zeggingskracht krijgen.
- Kalibratie brengt het opgegeven vertrouwen in overeenstemming met de waargenomen nauwkeurigheid, aangetoond op een gelabelde validatieset; het onbewerkte vertrouwen van het model is te hoog en zelf ingeschatte scores zijn geen betrouwbaar signaal voor automatisering.
- Stel drempels voor automatische acceptatie per segment in; automatiseer gekalibreerde strata met hoge nauwkeurigheid en stuur de rest naar mensen.
- Versterk het signaal met zelfcorrectie (berekend versus opgegeven totaal) en herkomst; voer de zware kalibratie-audit uit op de Batch API — nooit op een blokkerend, tijdgevoelig pad.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 26
- Lessen
- 104
Veelgestelde vragen
Is de les “Gestratificeerde steekproeven en kalibratie” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Gestratificeerde steekproeven en kalibratie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Claude Architect bevat in totaal 4 lessen.
Wat leer ik in “Gestratificeerde steekproeven en kalibratie”?
Neem steekproeven per segment; kalibreer met gelabelde validatiesets Je oefent met Claude Architect door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Claude Architect te beginnen?
Ervaring vooraf is niet nodig. Claude Architect op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Gestratificeerde steekproeven en kalibratie”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Claude Architect?
Ja. Elke les over Claude Architect bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Koppelingen tussen claims en bronnen
- Tegenstrijdige gegevens en datums
- Geaggregeerde metrics verbergen fouten
- Gestratificeerde steekproeven en kalibratie