F1-score in machine learning: een gebalanceerde maat voor precisie en recall

Bij het bouwen van ML-gedreven modellen is het evalueren van de prestaties net zo belangrijk als de training. Hoewel nauwkeurigheid vaak de standaardmaat is, kan die misleidend zijn, vooral bij onevenwichtige datasets waarin één klasse de data domineert. 

De F1-score is het harmonisch gemiddelde van precisie en recall. Het balanceert de afweging tussen false positives en false negatives en geeft een nauwkeurigere maat voor modelprestaties.

Bij toepassingen zoals fraudedetectie, medische diagnose, spamfiltering en foutdetectie is nauwkeurigheid alleen niet genoeg om het volledige beeld te geven. Een model kan een hoge nauwkeurigheid behalen, maar als het zeldzame kritieke gevallen niet detecteert, kan het meer kwaad dan goed doen. De F1-score dekt dit risico af. Als je nog nieuw bent met evaluatiemetrieken, bekijk dan eerst de basis in Machine Learning Fundamentals in Python voordat we verdergaan.

Wat is de F1-score?

De F1-score meet de balans tussen precisie en recall voor een model. De score loopt van 0 tot 1, waarbij 1 perfecte precisie en recall aangeeft, en 0 duidt op slechte prestaties.

• Precisie helpt in te schatten hoeveel van alle positieve voorspellingen van het model ook echt juist waren.
• Recall is handig om te analyseren hoeveel van alle echte positieven correct door het model zijn geclassificeerd. 

De F1-score combineert beide in één getal en bestraft modellen die op één maat goed presteren maar op de andere niet. Een model dat bijvoorbeeld veel herkent (hoge recall) maar niet erg precies is, kan alle positieve instanties oppikken, maar te veel false positives opleveren. De F1-maat zorgt ervoor dat beide maten samen worden meegenomen. 

F1-score: formule en uitleg

De formule voor de F1-score is:

Waarbij precisie als volgt is gedefinieerd:

En de formule voor recall is:

Hierbij staat TP voor True Positives, FP voor False Positives en FN voor False Negatives.

Het harmonisch gemiddelde wordt gebruikt in plaats van het rekenkundig gemiddelde omdat het eerste grote verschillen zwaarder afstraft. Bij hoge precisie maar lage recall (of omgekeerd) zal de F1-score aanzienlijk dalen, wat een disbalans weerspiegelt.

F1-score vs. nauwkeurigheid

Nauwkeurigheid bepaalt het aantal correcte voorspellingen ten opzichte van het totaal aan voorspellingen:

Hoewel dit goed werkt bij gebalanceerde klassen, is nauwkeurigheid misleidend bij onevenwichtige problemen.

Voorbeeld:

Als een spamfiltersysteem 90% spam en 10% niet-spamberichten bevat, behaalt een naïeve classifier die alle e-mails als "spam" classificeert 90% nauwkeurigheid, maar classificeert nooit niet-spam correct. Daar heb je in de praktijk niets aan.

Hier is de F1-maat nauwkeuriger, omdat die rekening houdt met de kosten van false positives en false negatives, wat nauwkeurigheid niet doet.

F1-score voor binaire en multiclass-classificatie

Binaire classificatie

Bij binaire classificatie wordt de F1-score berekend ten opzichte van de positieve klasse. In medische tests kan de positieve klasse bijvoorbeeld "ziekte aanwezig" betekenen.

Multiclass-classificatie

Bij multiclass-problemen worden F1-scores uitgebreid met behulp van gemiddelde-methoden:

Deze flexibiliteit maakt de F1-score toepasbaar voor een breed scala aan classificatieproblemen.

De F1-score berekenen in Python

De scikit-learn-bibliotheek bevat eenvoudige functies om de F1-score te berekenen.

Voorbeeld binaire classificatie

Begin met het evalueren van een eenvoudig binair classificatieprobleem waarbij voorspellingen 0 of 1 zijn. De functie f1_score() berekent de F1-score rechtstreeks op basis van de echte en voorspelde labels.

from sklearn.metrics import f1_score

# True labels
y_true = [0, 1, 1, 1, 0, 1, 0, 1]

# Predicted labels
y_pred = [0, 1, 0, 1, 0, 1, 1, 1]

# Calculate F1 Score
print("F1 Score:", round(f1_score(y_true, y_pred, average='binary'),2))Mogelijk gemaakt door

F1 Score: 0.8Mogelijk gemaakt door

Voorbeeld multiclass-classificatie

Vervolgens kun je dezelfde aanpak uitbreiden naar multiclass-problemen, waarbij het model meer dan twee klassen voorspelt. De parameter average bepaalt hoe F1-scores over klassen worden samengevoegd—veelgebruikte opties zijn 'macro', 'micro' en 'weighted'.

from sklearn.metrics import f1_score, classification_report

y_true = [0, 1, 2, 2, 0, 1, 2, 1, 2]
y_pred = [0, 2, 1, 2, 0, 0, 2, 1, 2]

# Macro, Micro, Weighted F1
print("Macro F1:", round(f1_score(y_true, y_pred, average='macro'),2))
print("Micro F1:", round(f1_score(y_true, y_pred, average='micro'),2))
print("Weighted F1:", round(f1_score(y_true, y_pred, average='weighted'),2))

# Detailed report
print(classification_report(y_true, y_pred))Mogelijk gemaakt door

Macro F1: 0.65
Micro F1: 0.67
Weighted F1: 0.64
              precision    recall  f1-score   support

           0       0.67      1.00      0.80         2
           1       0.50      0.33      0.40         3
           2       0.75      0.75      0.75         4

    accuracy                           0.67         9
   macro avg       0.64      0.69      0.65         9
weighted avg       0.65      0.67      0.64         9Mogelijk gemaakt door

Wanneer we F1 of Fβ berekenen bij multi-class of multi-label classificatie, moeten we beslissen hoe we scores over verschillende klassen middelen. De parameter average in scikit-learn biedt een paar opties:

• Binary wordt gebruikt in het geval van twee klassen. We focussen op de positieve klasse en berekenen precision, recall en F1 primair voor die klasse.

• Micro houdt in dat we de bijdragen van alle klassen aggregeren en die vervolgens middelen om de gemiddelde maat te berekenen. In de praktijk somt het de totale true positives, false negatives en false positives over klassen op en berekent daarna precisie, recall en F1 op basis van deze sommen. Micro-gemiddelden zijn waardevol om de algehele prestatie te zien, los van klasse-ongelijkheid.

• Macro: we berekenen de maat voor elke klasse en middelen die vervolgens ongewogen. Dit behandelt alle klassen gelijk en is daarom redelijk als alle klassen even belangrijk zijn, ook als de dataset onevenwichtig is.

• Gewogen lijkt op macro, maar geeft niet elke klasse een gelijke weging. Het weegt de scores met het aantal echte instanties per klasse. Dit betekent dat grotere klassen zwaarder wegen in de uiteindelijke score. Gewogen middelen is nuttig wanneer we een gebalanceerd beeld willen zonder de klassenverdeling te negeren.

• Samples: wordt gebruikt bij multi-label problemen, waar één sample tot meer dan één klasse kan behoren. Hier wordt de maat per instantie berekend en vervolgens over alle instanties gemiddeld.

Deze middelingsopties stellen ons in staat de F1- of Fβ-score af te stemmen op het problemscenario. Als we bijvoorbeeld zeldzame ziekten classificeren waarbij minderheidsklassen van groot belang zijn, zijn macro of Fβ, waarbij β > 1, geschikt. Maar als we juist klasgewijze nauwkeurigheid over alle klassen zoeken, geven micro of gewogen middelen een beter beeld.

Voor meer geavanceerde behoeften biedt scikit-learn ook fbeta_score(), dat F1 generaliseert. Een dieper begrip van zulke tools maakt deel uit van de Machine Learning Scientist in Python career track.

De F1-score generaliseren met de Fβ-score

De Fβ-score generaliseert de F1-score afhankelijk van of precisie of recall de hoofdrol speelt:

•  𝛃 > 1 geeft meer gewicht aan recall.
•  𝛃 < 1  legt meer nadruk op precisie.

Voorbeelden

• F2-score is toepasbaar bij medische diagnoses, waar een gemiste ziekte (false negative) erger is dan een loos alarm.
• F0,5-score is te verkiezen bij spamfiltering, waar false positives (echte e-mails die worden aangezien voor spam) kostbaarder zijn.

Usecase: diabetes detecteren met F1 vs. nauwkeurigheid

Stel een medische dataset voor waarin slechts 5% van de patiënten daadwerkelijk diabetes heeft. Een model dat is getraind op diabetesdetectie kan een nauwkeurigheid van 95% hebben. Maar die 95% nauwkeurigheid kun je eenvoudig bereiken door altijd voor iedereen "geen diabetes" te voorspellen, waardoor het model nutteloos is.

Gebruik in plaats daarvan de F1-score om het model te meten.

from sklearn.metrics import f1_score, fbeta_score, confusion_matrix

# Suppose these are results from a diabetes detection model
y_true = [0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]  # true outcomes
y_pred = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1]  # model predictions

print("Accuracy:", round((sum([yt == yp for yt, yp in zip(y_true, y_pred)]) / len(y_true)),2))
print("F1 Score:", round(f1_score(y_true, y_pred),2))
print("F2 Score (recall-focused):", round(fbeta_score(y_true, y_pred, beta=2),2))Mogelijk gemaakt door

Accuracy: 0.88
F1 Score: 0.8
F2 Score (recall-focused): 0.71Mogelijk gemaakt door

Waarom hier F1 of F2 kiezen?

• Nauwkeurigheid is misleidend door de sterke klasse-ongelijkheid.
• De F1-score zorgt ervoor dat zowel false positives (normale patiënten ten onrechte als diabetisch classificeren) als false negatives (diabetes niet diagnosticeren) worden meegewogen.

In deze usecase is recall waardevol, omdat een gemiste diagnose levensveranderend kan zijn. De F2-score is daarom geschikter, omdat die meer gewicht aan recall geeft.

Dit laat zien hoe de F1-familie van metriek een praktischer en bruikbaarder maat biedt dan nauwkeurigheid in klinische toepassingen.

Belangrijkste punten

De F1-score herinnert ons eraan dat modelevaluatie meer is dan een cijferwedstrijd. Het gaat erom de afwegingen achter elke voorspelling te begrijpen. Dat is belangrijk, want in echte toepassingen kan het missen van één kritisch geval serieuze gevolgen hebben.

Terwijl je modellen blijft bouwen en verfijnen, helpt gevoel ontwikkelen voor metriek zoals F1 je om contextbewustere keuzes te maken over prestaties. Wil je deze concepten op echte datasets toepassen, bekijk dan de Machine Learning Scientist with Python career track, waar je leert hoe je modellen effectief evalueert, afstemt en uitrolt voor uiteenlopende usecases.