Machine Learning Academy · Les

Classificatiemetrics: accuracy, precision, recall en F1

U berekent alle vier de metrics voor dezelfde voorspellingen en begrijpt welke metric prioriteit verdient afhankelijk van de kosten van false positives en false negatives.

Les 1 van 413 stappen

Classificatiemetrics: accuracy, precision, recall en F1 is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.

Waarom nauwkeurigheid vaak niet genoeg is

Nauwkeurigheid — het aandeel correcte voorspellingen — is de meest intuïtieve maatstaf, maar is misleidend wanneer klassen niet in balans zijn. Neem een medische test voor een ziekte die 1% van de patiënten treft. Een model dat altijd ‘gezond’ voorspelt, behaalt 99% nauwkeurigheid, maar is volledig nutteloos: het mist elk daadwerkelijk ziektegeval. Bij fraudedetectie, kankerscreening of het voorspellen van zeldzame gebeurtenissen verbergt nauwkeurigheid dat het model er niet in slaagt de zeldzame maar kritieke positieve klasse te detecteren. Daarom hebben we maatstaven nodig die de prestaties op elke klasse afzonderlijk meten: precisie, recall en de F1-score.

import numpy as np

# 1000 patients: 990 healthy, 10 sick
y_true = [0]*990 + [1]*10
y_pred_dummy = [0]*1000  # Always predict healthy

correct = sum(p == t for p, t in zip(y_pred_dummy, y_true))
accuracy = correct / len(y_true)
print(f'Dummy accuracy: {accuracy:.1%}')  # 99.0% -- misleadingly high!
print('But 0 sick patients correctly identified!')
print('This is why we need precision and recall.')

De verwarringsmatrix: de werkelijke situatie

De verwarringsmatrix vormt de basis van alle classificatiemaatstaven. Bij binaire classificatie is dit een tabel van 2 bij 2: True Positives (TP) — correct voorspeld als positief; True Negatives (TN) — correct voorspeld als negatief; False Positives (FP) — voorspeld als positief maar in werkelijkheid negatief (type-I-fout); False Negatives (FN) — voorspeld als negatief maar in werkelijkheid positief (type-II-fout). Elke classificatiemaatstaf wordt afgeleid uit een bepaalde combinatie van deze vier getallen. Door de onbewerkte verwarringsmatrix te bekijken, ziet u welk type fout het model het vaakst maakt.

from sklearn.metrics import confusion_matrix
import numpy as np

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

cm = confusion_matrix(y_true, y_pred)
print('Confusion Matrix:')
print(cm)
# [[TN, FP],
#  [FN, TP]]
TN, FP, FN, TP = cm.ravel()
print(f'TP={TP}, TN={TN}, FP={FP}, FN={FN}')

Nauwkeurigheid: eenvoudig maar beperkt

Nauwkeurigheid = (TP + TN) / (TP + TN + FP + FN). Deze maatstaf beantwoordt de vraag: welk aandeel van alle voorspellingen was correct? Nauwkeurigheid is alleen een eerlijke maatstaf wanneer klassen ongeveer in balans zijn en de kosten van fout-positieve en fout-negatieve voorspellingen vergelijkbaar zijn. Bij herkenning van handgeschreven cijfers is bijvoorbeeld ongeveer 10% van elke cijferklasse in balans, waardoor nauwkeurigheid een redelijke maatstaf is. Gebruik nauwkeurigheid wanneer: klassen in balans zijn en alle fouten evenveel kosten. Vermijd deze maatstaf wanneer: klassen scheef verdeeld zijn (één klasse overheerst) of fout-negatieve voorspellingen meer kosten dan fout-positieve (of andersom).

from sklearn.metrics import accuracy_score, confusion_matrix
import numpy as np

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

acc = accuracy_score(y_true, y_pred)
print(f'Accuracy = {acc:.2f}')  # (TP+TN) / total

# Manual calculation
TN, FP, FN, TP = confusion_matrix(y_true, y_pred).ravel()
acc_manual = (TP + TN) / (TP + TN + FP + FN)
print(f'Manual: ({TP}+{TN}) / ({TP}+{TN}+{FP}+{FN}) = {acc_manual:.2f}')

Precisie: kwaliteit van positieve voorspellingen

Precisie = TP / (TP + FP). Deze maatstaf beantwoordt de vraag: welk aandeel van alle voorbeelden die we als positief voorspelden, is daadwerkelijk positief? Precisie is de maatstaf die u optimaliseert wanneer fout-positieve voorspellingen kostbaar zijn. Bij spamdetectie markeert een spamfilter met hoge precisie legitieme e-mail zelden als spam. Bij het testen van geneesmiddelen betekent hoge precisie dat we zelden een geneesmiddel goedkeuren dat niet werkt. Lage precisie betekent dat veel van onze positieve voorspellingen onjuist zijn: we overspoelen gebruikers met valse alarmen. Precisie zegt niets over fout-negatieve voorspellingen: een model dat slechts één duidelijk geval als positief voorspelt, heeft precisie 1,0 maar mist alle andere gevallen.

from sklearn.metrics import precision_score, confusion_matrix
import numpy as np

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

prec = precision_score(y_true, y_pred)
print(f'Precision = {prec:.2f}')

# Manual calculation
TN, FP, FN, TP = confusion_matrix(y_true, y_pred).ravel()
print(f'Manual: TP/(TP+FP) = {TP}/({TP}+{FP}) = {TP/(TP+FP):.2f}')
print('Of all PREDICTED positives, this fraction are truly positive.')

Recall: dekking van daadwerkelijke positieve gevallen

Recall = TP / (TP + FN) (ook sensitiviteit of true-positivepercentage genoemd). Deze maatstaf beantwoordt de vraag: welk aandeel van alle voorbeelden die daadwerkelijk positief zijn, hebben we gevonden? Recall is de maatstaf die u optimaliseert wanneer fout-negatieve voorspellingen kostbaar zijn. Bij kankerscreening betekent hoge recall dat we de meeste patiënten identificeren die daadwerkelijk kanker hebben. Bij fraudedetectie betekent hoge recall dat we de meeste frauduleuze transacties onderscheppen. Lage recall betekent dat we te veel daadwerkelijke positieve gevallen missen — gevaarlijk in medische of beveiligingscontexten. Recall en precisie staan op gespannen voet: wanneer u de ene verhoogt, verlaagt u doorgaans de andere.

from sklearn.metrics import recall_score, confusion_matrix
import numpy as np

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

rec = recall_score(y_true, y_pred)
print(f'Recall = {rec:.2f}')

# Manual calculation
TN, FP, FN, TP = confusion_matrix(y_true, y_pred).ravel()
print(f'Manual: TP/(TP+FN) = {TP}/({TP}+{FN}) = {TP/(TP+FN):.2f}')
print('Of all ACTUAL positives, this fraction were correctly identified.')

De afweging tussen precisie en recall

Precisie en recall zijn omgekeerd gerelateerd wanneer u de classificatiedrempel aanpast. Wanneer u de drempel verlaagt (en agressiever positief voorspelt), neemt recall toe (u vindt meer daadwerkelijke positieve gevallen), maar neemt precisie af (meer fout-positieve gevallen komen erdoor). Een hogere drempel heeft het tegenovergestelde effect. Er is geen enkele drempel die beide maatstaven tegelijk maximaliseert. Welke maatstaf u prioriteit geeft, hangt af van het bedrijfsprobleem: geef bij e-mailfiltering prioriteit aan precisie (val gebruikers niet lastig met valse spamwaarschuwingen); geef bij ziektescreening prioriteit aan recall (mis geen zieke patiënten).

from sklearn.metrics import precision_score, recall_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np

X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)

clf = LogisticRegression(max_iter=10000)
clf.fit(X_tr, y_tr)
proba = clf.predict_proba(X_te)[:, 1]

for thresh in [0.3, 0.5, 0.7, 0.9]:
    y_pred = (proba >= thresh).astype(int)
    prec = precision_score(y_te, y_pred, zero_division=0)
    rec  = recall_score(y_te, y_pred)
    print(f'threshold={thresh}: precision={prec:.3f}, recall={rec:.3f}')

F1-score: harmonisch gemiddelde van precisie en recall

F1-score = 2 * (Precision * Recall) / (Precision + Recall). De F1-score is het harmonisch gemiddelde van precisie en recall. In tegenstelling tot het rekenkundig gemiddelde bestraft het harmonisch gemiddelde extreme waarden: een model met precision=1.0 en recall=0.0 krijgt F1=0, niet 0.5. Daardoor is F1 een eerlijke gecombineerde maatstaf die vereist dat zowel precisie als recall redelijk hoog zijn. F1 is de standaardmaatstaf voor tekstclassificatie met niet-gebalanceerde klassen (NLP-benchmarks rapporteren deze altijd), fraudedetectie en elk probleem waarbij een scheve klasseverdeling nauwkeurigheid misleidend maakt.

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

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

prec = precision_score(y_true, y_pred)
rec  = recall_score(y_true, y_pred)
f1   = f1_score(y_true, y_pred)

print(f'Precision = {prec:.3f}')
print(f'Recall    = {rec:.3f}')
print(f'F1-Score  = {f1:.3f}')
print(f'Manual F1 = 2 * ({prec:.3f} * {rec:.3f}) / ({prec:.3f} + {rec:.3f}) = {2*prec*rec/(prec+rec):.3f}')

Fbeta-score: gewogen balans tussen precisie en recall

De Fbeta-score generaliseert F1 door een parameter beta toe te voegen die bepaalt hoeveel gewicht recall krijgt ten opzichte van precisie: F_beta = (1 + beta^2) * Precision * Recall / (beta^2 * Precision + Recall). Bij beta=1 is dit de standaard-F1-score. Bij beta=2 (F2) weegt recall tweemaal zo zwaar als precisie — nuttig wanneer het missen van positieve gevallen tweemaal zo kostbaar is als valse alarmen. Bij beta=0.5 (F0.5) krijgt precisie meer gewicht — nuttig in aanbevelingssystemen waarin de nauwkeurigheid van suggesties belangrijker is dan de dekking.

from sklearn.metrics import fbeta_score
import numpy as np

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

for beta in [0.5, 1.0, 2.0]:
    score = fbeta_score(y_true, y_pred, beta=beta)
    print(f'F{beta:.1f} = {score:.3f}')

print()
print('beta=0.5: precision weighted 2x -> use when false alarms costly')
print('beta=1.0: balanced precision/recall -> standard F1')
print('beta=2.0: recall weighted 2x -> use when missing positives costly')

Gemiddelden voor meerdere klassen: macro, micro en gewogen

Bij classificatie met meerdere klassen moet u de precisie, recall en F1 per klasse samenvoegen tot één getal. Macro-gemiddelde: bereken de maatstaf onafhankelijk voor elke klasse en neem daarna het gemiddelde — alle klassen tellen even zwaar mee, ongeacht hun omvang. Gewogen gemiddelde: hetzelfde, maar gewogen op basis van de klasse-ondersteuning — grotere klassen krijgen meer invloed. Micro-gemiddelde: tel eerst TP, FP en FN voor alle klassen bij elkaar op en bereken daarna de maatstaf — dit is gelijk aan nauwkeurigheid voor precisie, recall en F1 wanneer geen voorbeelden meerdere labels hebben. Gebruik macro voor niet-gebalanceerde gegevenssets waarin kleine minderheidsklassen belangrijk zijn.

from sklearn.metrics import f1_score
import numpy as np

# Multi-class predictions
y_true = [0, 0, 1, 1, 2, 2, 2]
y_pred = [0, 1, 1, 1, 2, 0, 2]

print('Macro F1:    ', f1_score(y_true, y_pred, average='macro').round(3))
print('Micro F1:    ', f1_score(y_true, y_pred, average='micro').round(3))
print('Weighted F1: ', f1_score(y_true, y_pred, average='weighted').round(3))
print('Per-class F1:', f1_score(y_true, y_pred, average=None).round(3))
print()
print('Macro treats all classes equally (even rare ones)')
print('Weighted rewards correct prediction of common classes')

classification_report: alle maatstaven in één overzicht

classification_report() genereert een opgemaakte tabel met precisie, recall, F1-score en support (het aantal echte instanties) voor elke klasse, plus macro- en gewogen gemiddelden. Dit is de standaarduitvoer die u in elk evaluatierapport voor machine learning opneemt. De kolom ‘support’ is vooral belangrijk: een klasse met support=5 heeft schattingen van precisie en recall met veel ruis en moet voorzichtig worden geïnterpreteerd. Controleer altijd de supportwaarden naast de F1-scores om de betrouwbaarheid van de maatstaven te beoordelen.

from sklearn.metrics import classification_report
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42)

clf = RandomForestClassifier(random_state=42)
clf.fit(X_tr, y_tr)
y_pred = clf.predict(X_te)

print(classification_report(
    y_te, y_pred,
    target_names=load_iris().target_names
))

Gebalanceerde nauwkeurigheid voor niet-gebalanceerde klassen

Gebalanceerde nauwkeurigheid is het rekenkundig gemiddelde van de sensitiviteit (recall voor elke klasse). Voor binaire classificatie geldt: balanced_accuracy = (TPR + TNR) / 2, waarbij TNR (True Negative Rate) = TN / (TN+FP). In tegenstelling tot standaardnauwkeurigheid geeft gebalanceerde nauwkeurigheid elke klasse evenveel gewicht, ongeacht het aantal voorbeelden. Een model dat altijd de meerderheidsklasse voorspelt, krijgt een gebalanceerde nauwkeurigheid van 0,5 — terecht aangeduid als niet beter dan willekeurig. Gebruik gebalanceerde nauwkeurigheid wanneer klassen niet in balans zijn en u één maatstaf wilt die de prestaties op alle klassen gelijkwaardig weerspiegelt, zonder dat u maatstaven per klasse hoeft te berekenen.

from sklearn.metrics import balanced_accuracy_score, accuracy_score
import numpy as np

# Imbalanced: 990 class 0, 10 class 1
y_true = np.array([0]*990 + [1]*10)
y_dummy = np.zeros(1000, dtype=int)  # Always predict class 0

acc_standard = accuracy_score(y_true, y_dummy)
acc_balanced = balanced_accuracy_score(y_true, y_dummy)

print(f'Standard accuracy: {acc_standard:.3f}')  # 99% -- misleading
print(f'Balanced accuracy: {acc_balanced:.3f}')  # 0.5 -- correctly shows no skill
print()
print('Balanced accuracy correctly penalises ignoring the minority class')

Korte controle

Test uw begrip van de concepten uit deze les over Machine Learning met Python.

Samenvatting van de les

In deze les hebt u geleerd: nauwkeurigheid is misleidend bij niet-gebalanceerde klassen — gebruik de verwarringsmatrix als weergave van de werkelijke situatie, precisie meet de kwaliteit van positieve voorspellingen (minimaliseer fout-positieve voorspellingen) en recall meet de dekking van daadwerkelijke positieve gevallen (minimaliseer fout-negatieve voorspellingen), en de F1-score combineert beide op harmonische wijze tot een gebalanceerde maatstaf. Hierna verkennen we ROC-curven en AUC-ROC voor model-evaluatie die onafhankelijk is van de drempel.

Gratis beginnen

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
30
Lessen
120

Veelgestelde vragen

Is de les “Classificatiemetrics: accuracy, precision, recall en F1” gratis?

Ja — de volledige tekst van “Classificatiemetrics: accuracy, precision, recall en F1” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.

Wat leer ik in “Classificatiemetrics: accuracy, precision, recall en F1”?

U berekent alle vier de metrics voor dezelfde voorspellingen en begrijpt welke metric prioriteit verdient afhankelijk van de kosten van false positives en false negatives. Je oefent met Machine Learning Academy 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 Machine Learning Academy te beginnen?

Ervaring vooraf is niet nodig. Machine Learning Academy 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 1 van 4.

Hoe lang duurt de les “Classificatiemetrics: accuracy, precision, recall en F1”?

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 Machine Learning Academy?

Ja. Elke les over Machine Learning Academy 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

  1. Classificatiemetrics: accuracy, precision, recall en F1
  2. ROC-curves en AUC-ROC
  3. Regressiemetrics: MAE, MSE, RMSE en R-squared
  4. De juiste metric voor uw bedrijfsprobleem kiezen
← Terug naar Machine Learning Academy