Aggregerade mätvärden döljer fel
97 % totalt kan dölja en enda felande dokumenttyp.
Aggregerade mätvärden döljer fel är en gratis lektion i Claude Architect på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Claude Architect, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Claude Architect innehåller totalt 4 lektioner.
Rubriksiffran ljuger
Er extraktionspipeline rapporterar 97 % noggrannhet. Instrumentpanelen lyser grönt, intressenterna är nöjda och någon föreslår att den mänskliga granskningen stängs av helt.
Stopp. Ett enda aggregerat tal är en av de farligaste artefakterna i ett Claude-system i produktion. De 97 procenten är ett genomsnitt över en blandad population. Genomsnitt är utmärkta på att jämna ut exakt de fel som skadar er mest.
I den här lektionen lär ni er varför noggrannhet som endast bygger på aggregat är ett dokumenterat antimönster och vad ni bör mäta i stället innan ni automatiserar bort den mänskliga tillsynen.
En vilseledande genomsnitts anatomi
Föreställ er att er pipeline behandlar tre dokumenttyper i lika stor volym. Det sammanvägda resultatet är 97 %. Det ser enhetligt ut, eller hur?
Men sammanvägda tal viktas efter volym, inte efter risk. En liten dokumenttyp med höga konsekvenser kan dränkas helt. Aggregatet säger ingenting om var de 3 procenten fel hamnar — och i praktiken är fel nästan aldrig jämnt fördelade.
# Same 97% aggregate, two very different realities
docs = {
"invoices": {"n": 1000, "correct": 990}, # 99.0%
"receipts": {"n": 1000, "correct": 985}, # 98.5%
"contracts": {"n": 1000, "correct": 935}, # 93.5%
}
total = sum(d["n"] for d in docs.values())
hits = sum(d["correct"] for d in docs.values())
print(f"aggregate = {hits/total:.1%}") # 97.0% — hides contracts
for name, d in docs.items():
print(name, f"{d['correct']/d['n']:.1%}")En dokumenttyp som fallerar
Här är det feltillstånd som tentan vill att ni ska känna igen: aggregerad noggrannhet kan dölja dåliga resultat för en viss dokumenttyp eller ett visst fält.
Avtal med 93,5 % kan vara era mest värdefulla dokument och de dokument som medför störst ansvarsrisk. Ett fåtal felaktigt extraherade klausuler från avtal kan kosta mer än vad tusentals korrekt hanterade kvitton någonsin har sparat in. Ändå rapporterar instrumentpanelen glatt 97 % och uppmuntrar er att automatisera.
Talet är inte fel. Det besvarar bara fel fråga. "Hur bra är vi i genomsnitt?" är sällan den fråga som spelar roll. "Var är vi svagast, och hur mycket kostar den svagheten?" är frågan.
Fel på fältnivå döljs ännu djupare
Det blir ännu mer subtilt. Även inom en enda dokumenttyp kan felet finnas i ett enda fält. En avtalsextraherare kan identifiera parter, datum och adresser perfekt — och i tysthet förvränga termination_clause eller liability_cap 20 % av gångerna.
Om ni slår ihop dessa fält ser ni fortfarande ett bekvämt resultat. Stratifiera därför efter båda axlarna: efter dokumenttyp OCH efter fält. Cellen där en kritisk dokumenttyp möter ett kritiskt fält är den plats där den verkliga risken koncentreras.
# Stratify a labeled validation set by (doc_type, field)
import collections
stats = collections.defaultdict(lambda: [0, 0]) # [correct, total]
for row in labeled_validation_set:
key = (row["doc_type"], row["field"])
stats[key][1] += 1
stats[key][0] += int(row["pred"] == row["gold"])
for (doc, field), (ok, n) in sorted(stats.items()):
acc = ok / n
flag = " <-- REVIEW" if acc < 0.95 else ""
print(f"{doc:10} {field:18} {acc:.1%} (n={n}){flag}")Stratifierat slumpmässigt urval
Hur synliggör ni dessa dolda celler? Inte genom att ta 100 slumpmässiga dokument — slumpmässigt urval återskapar volymfördelningen, så sällsynta men kritiska typer får nästan ingen täckning.
Använd stratifierat slumpmässigt urval: dela in populationen i strata (dokumenttyp, källa och fältets kritikalitet) och gör sedan ett slumpmässigt urval inom varje stratum. Nu får er lågvolymstyp av avtal ett statistiskt meningsfullt urval i stället för tre lyckosamma dragningar.
Detta är den teknik som rekommenderas på tentan för att upptäcka det som aggregat döljer.
from collections import defaultdict
import random
def stratified_sample(docs, key_fn, per_stratum=50):
strata = defaultdict(list)
for d in docs:
strata[key_fn(d)].append(d)
sample = []
for stratum, items in strata.items():
k = min(per_stratum, len(items))
sample += random.sample(items, k) # random WITHIN stratum
return sample
audit_set = stratified_sample(all_docs, key_fn=lambda d: d["doc_type"])Kalibrerad konfidens på fältnivå
Stratifierat urval visar var ni står offline. För att i produktion avgöra för varje dokument om det ska godkännas automatiskt eller skickas till en människa behöver ni konfidens på fältnivå, kalibrerad mot en märkt valideringsmängd.
"Kalibrerad" är det bärande ordet. Ett rått, konfidensliknande poängvärde betyder ingenting förrän ni mot facit har kontrollerat att dokument som märkts med 0,9 faktiskt är korrekta ungefär 90 % av gångerna. Kalibrera först; först därefter kan en tröskel som "godkänn automatiskt över 0,97" betyda det ni tror att den betyder.
# Calibrate, then gate per field
def route_extraction(field_name, value, confidence, thresholds):
# thresholds[field] derived from a LABELED validation set,
# tighter for high-stakes fields
if confidence >= thresholds[field_name]:
return "auto_accept"
return "human_review"
thresholds = {
"vendor_name": 0.92,
"liability_cap": 0.99, # critical -> stricter gate
"termination_clause": 0.99,
}Självkorrigering synliggör avvikelser
Kalibrerad konfidens är inte den enda signalen. Vid numerisk extraktion kan ni låta modellen visa sitt eget arbete så att ni kan upptäcka fel deterministiskt.
Extrahera båda calculated_total (summerat från radposterna) och stated_total (det tryckta totalbeloppet). När de skiljer sig åt har ni hittat en avvikelse som inget aggregatmått någonsin skulle avslöja — en verifierbar varningssignal på dokumentnivå som skickas direkt till granskning.
# Self-correction: extract both, compare deterministically
schema = {
"type": "object",
"properties": {
"line_items": {"type": "array", "items": {"type": "number"}},
"calculated_total": {"type": "number"}, # model sums line items
"stated_total": {"type": "number"} # printed on the doc
},
"required": ["line_items", "calculated_total", "stated_total"]
}
def needs_review(out):
return abs(out["calculated_total"] - out["stated_total"]) > 0.01Försök inte igen med sådant som kalibreringen avslöjar
När ett dokument med låg konfidens eller en avvikelse upptäcks ska ni vara precisa med åtgärden. Retry-with-feedback korrigerar formatfel, strukturella fel och räknefel — skicka originaldokumentet, den felaktiga utdatan och det exakta valideringsfelet tillbaka till modellen.
Men ett nytt försök hjälper inte när informationen helt enkelt saknas i källan. Om avtalet aldrig anger ett ansvarstak kan ingen mängd nya promptar trolla fram ett — och en modell som fabricerar ett är exakt det fel som era mätvärden måste upptäcka. Frånvarande data ska eskaleras, inte skickas för ett nytt försök.
def handle_low_confidence(doc, output, error):
if error.kind in ("format", "arithmetic", "schema"):
# retry with original doc + wrong output + exact error
return retry_with_feedback(doc, output, error)
if error.kind == "absent":
# info not in source -> never retry; route to human
return escalate_to_human(doc, reason="field absent in source")Scheman får inte tvinga fram fabricering
Detta hänger ihop med en regel för strukturerad utdata som direkt påverkar era mätvärden. Markera ett schemafält som obligatoriskt endast om det alltid finns. Gör aldrig ett fält som kan saknas obligatoriskt — modellen fabricerar ett värde för att uppfylla schemat, och ett fabricerat värde räknas fortfarande som ett svar med hög konfidens.
En sådan fabricering kan passera obemärkt genom en kontroll av aggregerad noggrannhet och samtidigt förstöra ert mest kritiska fält. Gör valfria fält valfria och använd en enum med värdet "other" samt ett fritextfält för detaljer, så att schemat kan utökas.
{
"type": "object",
"properties": {
"vendor_name": {"type": "string"},
"liability_cap": {"type": ["number", "null"]},
"doc_category": {
"type": "string",
"enum": ["invoice", "receipt", "contract", "other"]
},
"category_detail": {"type": "string"}
},
"required": ["vendor_name", "doc_category"]
}Proveniens gör fel möjliga att granska
För att utreda ett dolt fel måste Ni kunna spåra varje extraherat påstående tillbaka till dess ursprung. Upprätthåll kopplingar mellan påståenden och källor: källdokumentets namn, det exakta citatet, platsen och publiceringsdatumet.
När en stratifierad granskning flaggar kontraktsstratumet kan en granskare, tack vare proveniens, gå direkt till citatet som gav upphov till ett felaktigt liability_cap — i stället för att läsa om hela dokumentet. Proveniens förvandlar ”vårt mått verkar vara fel någonstans” till ”det här fältet, från det här citatet, på den här sidan, är felaktigt”.
extraction = {
"field": "liability_cap",
"value": 500000,
"provenance": {
"source_doc": "acme_msa_2026.pdf",
"quote": "liability shall not exceed five hundred thousand dollars",
"page": 7,
"published": "2026-01-15"
}
}Fatta beslut utifrån belägg, inte magkänsla
Sammanför detta till ett beslut om automatisering. Ni har rätt att minska den mänskliga översynen av ett stratum först när beläggen för just det stratumet stödjer det.
- Den stratifierade granskningen visar att stratumet når den målnoggrannhet som krävs.
- Konfidensen på fältnivå är kalibrerad mot märkta data.
- Självkorrigering och proveniens fångar upp kvarvarande fel.
Observera också vad som inte finns med på listan: modellens självskattade konfidens (1–10) eller sentimentpoäng är en dålig utlösare för eskalering. Bra utlösare är tröskelöverträdelser, luckor i policyer, uteblivna framsteg och uttryckliga önskemål från människor — inte modellens egen otränade självbedömning.
Snabbtest: Tolka 97 %
En scenariobaserad fråga om mått och översyn.
Sammanfattning: Gör dolda fel synliga
Viktigaste lärdomarna:
- Aggregerad noggrannhet döljer fel per typ och per fält — den viktas efter volym, inte efter risk.
- Stratifiera innan Ni litar på resultatet: stratifierat slumpmässigt urval efter dokumenttyp och fält synliggör svaga celler som slumpmässiga urval missar.
- Kalibrera konfidensen på fältnivå mot ett märkt valideringsdataset innan Ni använder någon tröskel för automatiskt godkännande.
- Självkorrigering (extrahera calculated_total och stated_total) och proveniens (påståendets källcitat, sida och datum) fångar upp och förklarar kvarvarande fel.
- Kräv inte fält som kanske saknas (fabricering), och eskalera inte utifrån självskattad konfidens eller sentiment — använd tröskelöverträdelser, luckor i policyer, uteblivna framsteg och uttryckliga önskemål från människor.
Förtjäna automatisering per stratum, baserat på belägg. Den gröna instrumentpanelen är början på undersökningen, inte slutet.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 26
- Lektioner
- 104
Vanliga frågor
Är lektionen ”Aggregerade mätvärden döljer fel” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Claude Architect, inklusive ”Aggregerade mätvärden döljer fel”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Claude Architect innehåller totalt 4 lektioner.
Vad lär jag mig i ”Aggregerade mätvärden döljer fel”?
97 % totalt kan dölja en enda felande dokumenttyp. Ni övar på Claude Architect med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Claude Architect?
Du behöver inga förkunskaper. Utbildningen i Claude Architect på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Aggregerade mätvärden döljer fel”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Claude Architect-lektionen?
Ja. Varje Claude Architect-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Kopplingar mellan påståenden och källor
- Motstridiga data och datum
- Aggregerade mätvärden döljer fel
- Stratifierat urval och kalibrering