Precision vs recall: de essentiële gids voor machine learning

Een machinelearningmodel met 98% nauwkeurigheid klinkt indrukwekkend–maar is het dat wel? Bij zeldzame gebeurtenissen zoals fraude of ziekte geeft accuracy vaak een vals gevoel van zekerheid.

Daar komen precision en recall om de hoek kijken. In dit artikel bekijken we hoe deze twee metrieken verder gaan dan simpele accuracy: ze meten niet alleen hoe vaak je het goed hebt, maar ook precies hoe je het fout hebt.

Wil je verder dan theorie en classificatie echt in de vingers krijgen? Dan is de cursus Fraud Detection in Python de perfecte volgende stap.

Waarom accuracy niet genoeg is

In de meeste situaties is accuracy de voor de hand liggende metriek om te meten hoe goed een statistisch of machinelearningmodel een bepaald label voorspelt. Je berekent het door het aantal correct voorspelde instanties te vergelijken met het totale aantal observaties. 

Over het algemeen geldt: als een model consequent met hoge nauwkeurigheid het juiste label identificeert, werkt het goed. Maar bij onevenwichtige datasets, waarin de ene klasse veel meer voorbeelden bevat dan de andere, raakt accuracy vertekend. Zulke datasets komen vaak voor bij fraudedetectie of ziektediagnoses.

Stel dat een model fraude classificeert met een accuracy van 98%. Op het eerste gezicht lijkt dat fantastisch. Maar wat als fraude slechts 2% van de transacties in de dataset uitmaakt? In dat geval kan een model altijd voor "geen fraude" kiezen en nog steeds die 98% halen, terwijl het nul fraudegevallen vangt – niet wat we willen. 

Duidelijk is dat dit soort situaties om fijnmazigere metrieken vraagt. Twee veelgebruikte metrieken zijn precision en recall. 

Wat zijn precision en recall?

Hier is de korte versie:

• Precision (kwaliteit): Meet hoe betrouwbaar je positieve voorspellingen zijn. Als het model "fraude" zegt, is het dan ook echt fraude?
• Recall (kwantiteit): Meet hoe goed je de daadwerkelijke positieve gevallen hebt opgepikt. Heeft het model alle fraude gevangen, of is er wat tussendoor geglipt?

Om te begrijpen hoe je deze metrieken berekent, moeten we eerst de terminologie uit een confusion matrix definiëren.

True positive, false positive en negatives 

Neem een creditcardmaatschappij die een machinelearningmodel gebruikt om frauduleuze creditcardtransacties te detecteren. Stel dat er in een steekproef van 10.000 transacties 9.800 legitieme transacties en 200 fraudegevallen waren.

Om de effectiviteit van het model te meten, wijs je één van "fraude" of "geen fraude" aan als de positieve klasse en de andere als de negatieve klasse. Omdat de fraudegevallen de focus hebben, labelen we die als de "positieve" gevallen. (Dat impliceert natuurlijk niet dat fraude ethisch positief is; het label “positief” geeft alleen aan welke klasse onze interesse heeft.)

Wanneer het model draait, worden transacties met een risicoscore boven een bepaalde drempelwaarde, zeg 70%, als fraude beschouwd. De als frauduleus voorspelde gevallen worden vergeleken met de gevallen die het daadwerkelijk zijn.

Om al deze data overzichtelijk te houden, gebruiken we de volgende nomenclatuur. 

• True positives (TP): 160 fraudegevallen werden correct als fraude voorspeld.
• True negatives (TN): 9500 gevallen werden correct als niet-fraude geïdentificeerd.
• False positives (FP): 300 gevallen zijn ten onrechte als fraude aangemerkt.
• False negatives (FN): 40 gevallen zijn ten onrechte als niet-fraude gemarkeerd.

De tweede letter (P of N) geeft aan of de voorspelling positief of negatief was, en de eerste letter of die voorspelling waar (T) of onwaar (F) was. 

Een "false positive" betekent dat het systeem het geval als positief voorspelde, maar dat het eigenlijk negatief was. Een false negative is bijvoorbeeld een geval dat negatief werd voorspeld, maar in werkelijkheid positief is.

Confusion matrix

Al deze informatie wordt vaak weergegeven in de zogeheten confusion matrix, die bijhoudt hoe vaak het model verkeerde voorspellingen verwart met de werkelijke uitkomsten (FN, FP). De confusion matrix helpt ons onderscheid maken tussen wat het model voorspelde en wat er daadwerkelijk gebeurde. De confusion matrix van ons voorbeeld ziet er zo uit:

Nu bekijken we de rij- en kolomtotaalwaarden. De rijsommen geven het totaal aan voorspelde gevallen, en de kolomsommen het totaal aan werkelijke waarden.

Wat stellen deze totalen voor?

• Het eerste rijtotaal (460) is het totale aantal voorspelde fraudegevallen (TP + FP).
• Het tweede rijtotaal (9.540) is het totale aantal voorspelde legitieme gevallen (FN + TN).
• Het eerste kolomtotaal (200) is het totale aantal werkelijke fraudegevallen (TP + FN).
• Het tweede kolomtotaal (9.800) is het totale aantal werkelijke legitieme gevallen (FP + TN).
• Het totaaltotaal (10.000) is de totale omvang van onze steekproef.

Wat is precision?

Precision meet de kwaliteit van je positieve voorspellingen. Het vertelt ons hoeveel van de als positief voorspelde gevallen ook daadwerkelijk positief waren. 

Een precies model geeft weinig valse alarmen. Als het model zegt dat iets waar is, is het dat meestal ook. Als een online game bijvoorbeeld iemand bant voor valsspelen, moet dat terecht zijn. Te veel onterechte bans vervreemden legitieme gebruikers en leiden tot negatieve reviews. 

In de hierboven gebruikte terminologie is precision gelijk aan de verhouding tussen true positives en voorspelde positieven.

In het voorbeeld hierboven is precision 160/460, of ongeveer 34,8%.

Wat is recall?

Recall meet de dekking. Het laat zien hoeveel van de werkelijke positieven ook zo zijn voorspeld. Het is gedefinieerd als de verhouding tussen true positives en het totaal aantal werkelijke positieven.

Denk aan kankerscreening voor een eerste vervolgonderzoek. Is het beter om te veel of te weinig te diagnosticeren? De meesten zullen voor het eerste kiezen. 

Bij vroege screening kan een vals alarm schrikken zijn. Maar het is rampzalig om te horen dat je geen kanker hebt terwijl dat wel zo is, zeker omdat je dan mogelijk levensreddende behandeling mist.

In het voorbeeld hierboven is recall 160/200, ofwel 80%.

De trade-off tussen precision en recall

Er is een touwtrekverhouding tussen precision en recall. Typisch geldt: als precision toeneemt, daalt recall, en omgekeerd.

Om te zien waarom, keren we terug naar het fraudevoorbeeld. 

De meeste fraude werd gepakt, maar er waren veel false positives. Stel dat het management, vanwege klachten van klanten, besloot om de beslisdrempel te verhogen van 0,7 naar 0,8. Om als fraude te worden aangemerkt, moet een transactie nu minimaal 0,8 scoren in plaats van 0,7.

Dit maakte het model voorzichtiger. Het voorspelde minder vaak fraude. Minder transacties werden onterecht als fraude aangemerkt, maar wel ten koste van meer echt frauduleuze gevallen die doorheen glipten. Na de drempelwijziging daalde het aantal false positives van 300 naar 60, maar steeg het aantal false negatives van 40 naar 80. 

De confusion matrix van het nieuwe model ziet er zo uit:

Zoals we zien, waren 120 van de 180 voorspelde fraudegevallen daadwerkelijk fraude, dus de precision steeg van 34,8% naar 66,7%. 

De prijs voor deze hogere precision is een lagere recall: 120 van de 200 fraudegevallen werden zo voorspeld, wat betekent dat recall daalde van oorspronkelijk 80% naar nu slechts 60%.

Het model pakt nu in totaal minder fraude, maar als het fraude vlaggt, is het veel zekerder. Dit laat zien hoe belangrijk het is om beide metrieken in balans te brengen, waar we later op terugkomen. 

De precision-recall-curve

Om de trade-off tussen precision en recall te visualiseren, gebruiken data scientists de Precision-Recall (PR)-curve. 

Deze grafiek zet precision uit op de y-as en recall op de x-as voor elke mogelijke beslisdrempel (van 0 tot 1). Als je de drempel verlaagt om meer positieve gevallen te vangen (hogere recall), krijg je onvermijdelijk meer valse alarmen (lagere precision). 

Het "perfecte" model zou de rechterbovenhoek bereiken (100% precision en recall), maar in de praktijk kies je een punt op deze curve dat aan je specifieke businessvereisten voldoet.

In ons fraudevoorbeeld hebben we een model dat een fraudescore geeft voor elke transactie. Als de score van een transactie minstens de drempel haalt, wordt deze als fraude gemarkeerd. Als we de drempel verlagen, krijgen we meer voorspelde positieven, wat doorgaans meer true positives oplevert (hogere recall) maar ook meer valse alarmen (lagere precision).

Laten we bekijken hoe dit er in de praktijk uit kan zien. Stel dat je bedrijf 10.000 transacties per dag verwerkt. Aangezien het fraudecijfer op 2% wordt geschat, verwacht je 200 frauduleuze transacties per dag. Stel ook dat het fraudeteam 200 gemarkeerde transacties (voorspelde positieven) per dag kan beoordelen.

Je evalueert een paar drempels en vindt deze resultaten:

• Bij een drempel van 0,9 zijn er 100 voorspelde positieven, met een precision van 0,8 (80 werkelijke fraude, 20 valse alarmen), en een recall van 0,4 (je vangt 80 van de 200 fraudegevallen). Je benut de capaciteit niet volledig, want je markeert er maar 100 per dag terwijl je er 200 kunt beoordelen. 
• Bij een drempel van 0,5 zijn er 500 voorspelde positieven, met een precision van 0,35 (175 werkelijke fraude, 325 valse alarmen), en een recall van 0,875 (je vangt 175 van de 200 fraudegevallen). Bij deze drempel zit je over de capaciteit, omdat je geen 500 gemarkeerde gevallen kunt beoordelen.
• Bij een drempel van 0,7 zijn er 200 voorspelde positieven, met een precision van 0,6 (120 werkelijke fraude, 80 valse alarmen), en een recall van 0,6 (je vangt 120 van de 200 fraudegevallen). Dit wordt waarschijnlijk de drempel die je gebruikt, omdat je de volledige capaciteit benut en toch een redelijke recall van 0,6 haalt.

De curve vertelt je welke precision je kunt “kopen” bij een gegeven recall (of andersom).

Wanneer gebruik je precision vs. recall

Door de trade-off tussen precision en recall hangt de juiste metriek af van jouw specifieke usecase.

Wanneer kies je voor precision

Er is een omgekeerde relatie tussen precision en false positives. Een precies model onderscheidt dus goed tussen true positives en false positives. Het is betrouwbaar.

Optimaliseer voor precision wanneer de kosten van een false positive hoog zijn. Voorbeelden:

• Onomkeerbare acties: Geautomatiseerde rechtspraak of het blokkeren van accounts. Een onschuldige beschuldigen of een account permanent verwijderen door een model fout (false positive) veroorzaakt onherstelbare schade.
• Kostbare interventies: Boren naar olie of een fabriekslijn stilleggen. Als handelen op een positieve voorspelling miljoenen kost, moet je zeker weten dat de voorspelling klopt.
• Spammails filteren: E-mailinboxen. Een spammail zien (false negative) is irritant, maar een belangrijke sollicitatie in de spamfolder laten verdwijnen (false positive) is onacceptabel.

Wanneer kies je voor recall

Er is ook een omgekeerde relatie tussen recall en false negatives. Veel false negatives zorgen voor een lage recall. Een model met hoge recall onderscheidt dus goed tussen true positives en false negatives. Het is veilig.

Als het belangrijker is om geen echte gevallen te missen dan om valse alarmen te vermijden, geef dan prioriteit aan recall boven precision. Voorbeelden van usecases:

• Medische veiligheid: Ziektescreening (bijv. kanker of sepsis). Een zieke patiënt missen kan fataal zijn, terwijl een vals alarm tot verder onderzoek leidt – een acceptabele kostenpost.
• Cybersecurity: Malwaredetectie of netwerk-inbraakdetectie. Het is beter om een paar onschuldige logins als verdacht te markeren dan een enkele hacker ongezien binnen te laten.
• Productiekwaliteit: Defectdetectie. Een defect product versturen (false negative) veroorzaakt veiligheidsrisico’s en reputatieschade, dus is het beter een paar twijfelgevallen te weren dan een slecht exemplaar door te laten.

F1-score om precision en recall in balans te brengen

Weet je niet zeker of je moet optimaliseren voor precision of recall, of wil je simpelweg beide meewegen, raadpleeg dan de F1-score. 

De F1-score is gedefinieerd als het harmonisch gemiddelde van precision en recall en wordt gebruikt wanneer je een balans tussen beide metrieken wilt nastreven. 

Als precision en recall gelijk zijn, is de F1-score gelijk aan die waarde. Als één van de twee naar nul gaat, zal F1 echter ook erg laag zijn.

In het bovenstaande voorbeeld is precision 66,7% en recall 60%. Met de formule hierboven krijgen we een F1-score van ongeveer 63,2%:

De volgende table vergelijkt de F1-score met accuracy, precision en recall.

Precision en recall berekenen in Python

Er zijn veel manieren om precision, recall en de F1-score in Python te berekenen. Hieronder geef ik twee benaderingen: de formules direct toepassen en de aangewezen functies in het pakket scikit-learn gebruiken.

Precision en recall berekenen met de formules

Als je de getallen uit de confusion matrix kent, kun je de metrieken eenvoudig berekenen met de hierboven gegeven formules.

# Confusion matrix numbers
TP = 120
FP = 60
FN = 80
TN = 9740

# Formulas
precision = TP / (TP + FP)
recall = TP / (TP + FN)
f1 = 2 * precision * recall / (precision + recall)

# Output
print(f"{'Precision':<10} {precision:.1%}")
print(f"{'Recall':<10} {recall:.1%}")
print(f"{'F1':<10} {f1:.1%}")Mogelijk gemaakt door

Precision	66.7%
Recall		60.0%
F1		63.2%Mogelijk gemaakt door

De output van deze code komt overeen met onze eerdere berekeningen.

Precision en recall berekenen met scikit-learn

Je kunt ook de bibliotheek scikit-learn gebruiken om metrieken uit de data zelf te berekenen. In het volgende voorbeeld simuleren we y_true en y_predicted. Vervolgens berekenen we precision met de methode precision_score(y_true, y_false). Recall en de F1-score berekenen we op vergelijkbare wijze. Tot slot printen we de resultaten.

import numpy as np
from sklearn.metrics import precision_score, recall_score, f1_score

# Simulate Data (y_true and y_pred)
TP, FP, FN, TN = 120, 60, 80, 9740
y_true = np.array(TP * [1] + FP * [0] + FN * [1] + TN * [0])
y_pred = np.array(TP * [1] + FP * [1] + FN * [0] + TN * [0])

# Compute metrics with scikit-learn
precision = precision_score(y_true, y_pred, zero_division=0)
recall = recall_score(y_true, y_pred, zero_division=0)
f1 = f1_score(y_true, y_pred, zero_division=0)

# Print aligned output using f-strings (no manual spaces, no colon)
print(f"{'Precision':<10} {precision:.1%}")
print(f"{'Recall':<10} {recall:.1%}")
print(f"{'F1':<10} {f1:.1%}")Mogelijk gemaakt door

Precision	66.7%
Recall		60.0%
F1		63.2%Mogelijk gemaakt door

Zoals verwacht komen deze getallen overeen met onze eerdere berekeningen.

Conclusie

Hoewel accuracy een handig vertrekpunt is, verbergt het vaak de details die je nodig hebt om te begrijpen waarom een model faalt. Precision en recall geven een helderder beeld door je te dwingen te kijken naar de trade-off tussen valse alarmen en gemiste detecties. 

Uiteindelijk is de juiste metriek kiezen niet alleen een rekensom; het is een praktische keuze over welk type fout jouw systeem zich kan veroorloven.

Klaar om je eigen machinelearningmodellen te bouwen? Begin vandaag nog met de skill track Machine Learning Fundamentals in Python!