Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Leer Statistieken | Modellen Vergelijken
Classificatie met Python

Statistieken

Veeg om het menu te tonen

Tot nu toe hebben we nauwkeurigheid gebruikt als de belangrijkste maatstaf om de prestaties van het model te evalueren. Nauwkeurigheid kent echter enkele beperkingen. We bespreken nu de nadelen hiervan en introduceren verschillende aanvullende maatstaven – gebaseerd op TP, TN, FP en FN – die helpen deze problemen aan te pakken.

ConfusionMatrix

Nauwkeurigheid

Nauwkeurigheid geeft het aandeel correcte voorspellingen weer:

accuracy=correctcorrect+incorrect=TP+TNTP+TN+FP+FN\text{accuracy} = \frac{\text{correct}}{\text{correct} + \text{incorrect}} = \frac{\textcolor{green}{\text{TP}} + \textcolor{green}{\text{TN}}}{\textcolor{green}{\text{TP}} + \textcolor{green}{\text{TN}} + \textcolor{red}{\text{FP}} + \textcolor{red}{\text{FN}}}

Echter, nauwkeurigheid heeft zijn nadelen. Stel je bijvoorbeeld voor dat je probeert te voorspellen of een patiënt een zeldzame ziekte heeft. De dataset bevat 99,9% gezonde patiënten en slechts 0,1% met de ziekte. In dit geval zou altijd voorspellen dat de patiënt gezond is resulteren in een nauwkeurigheid van 0,999 – terwijl zo'n model volledig nutteloos is.

Dergelijke datasets worden onevenwichtig genoemd, en in zulke gevallen is gebalanceerde nauwkeurigheid een betere maatstaf om te gebruiken.

Gebalanceerde nauwkeurigheid

Gebalanceerde nauwkeurigheid berekent het aandeel correcte positieve voorspellingen en het aandeel correcte negatieve voorspellingen afzonderlijk, en neemt vervolgens het gemiddelde hiervan. Deze benadering geeft gelijke belangrijkheid aan elke klasse, ongeacht hoe onevenwichtig de dataset is.

balanced_accuracy=12TPP+12TNNaccuracy=TP+TNP+N\begin{aligned} \text{balanced\_accuracy} &= \frac12 \cdot \frac{\textcolor{green}{\text{TP}}}{\text{P}} + \frac12 \cdot \frac{\textcolor{green}{\text{TN}}}{\text{N}}\\ \text{accuracy} &= \frac{\textcolor{green}{\text{TP}} + \textcolor{green}{\text{TN}}}{\text{P} + \text{N}} \end{aligned}

Waarbij

  • P=TP+FN\text{P} = \textcolor{green}{\text{TP}} + \textcolor{red}{\text{FN}} – totaal aantal positieve gevallen (klasse 1);
  • N=TN+FP\text{N} = \textcolor{green}{\text{TN}} + \textcolor{red}{\text{FP}} – totaal aantal negatieve gevallen (klasse 0).

In het voorbeeld van de zeldzame ziekte zou de gebalanceerde nauwkeurigheid van een model dat altijd "gezond" voorspelt 0,5 zijn – waarmee het probleem duidelijk wordt gemaakt. Dit probleem wordt dus aangepakt.

Echter, gebalanceerde nauwkeurigheid maakt nog steeds geen onderscheid tussen type 1- en type 2-fouten – net als gewone nauwkeurigheid. Daar komen precisie en herinnering om de hoek kijken.

Precisie

De precisie-maat geeft aan hoeveel van de waarden die het model als positief voorspelde, daadwerkelijk positief waren. Het is het aandeel van het aantal echte positieve voorspellingen ten opzichte van alle positieve voorspellingen die door het model zijn gedaan:

precision=TPTP+FP\text{precision} = \frac{\textcolor{green}{\text{TP}}}{\textcolor{green}{\text{TP}} + \textcolor{red}{\text{FP}}}

Door gebruik te maken van de precisie-maat kan worden begrepen hoe vaak een type 1-fout voorkomt. Hoge precisie betekent dat type 1-fouten zeldzaam zijn, terwijl lage precisie aangeeft dat type 1-fouten vaak voorkomen.

Recall

De recall-maat geeft het aandeel van de daadwerkelijk positieve gevallen aan die het model correct heeft voorspeld:

recall=TPTP+FN\text{recall} = \frac{\textcolor{green}{\text{TP}}}{\textcolor{green}{\text{TP}} + \textcolor{red}{\text{FN}}}

De recall-metriek geeft inzicht in hoe vaak een type 2-fout voorkomt. Een hoge recall betekent dat type 2-fouten zeldzaam zijn, terwijl een lage recall aangeeft dat ze vaak voorkomen.

Zowel precisie als recall hebben echter beperkingen. Bijvoorbeeld, een model dat alleen de positieve klasse (1) voorspelt, behaalt perfecte recall, maar de precisie is slecht. Omgekeerd zal een model dat slechts één positieve instantie correct voorspelt en de rest als negatief labelt, perfecte precisie hebben, maar zeer slechte recall.

Dit laat zien dat het eenvoudig is om een model te bouwen met perfecte precisie of perfecte recall, maar veel moeilijker om een model te maken dat op beide goed presteert. Daarom is het belangrijk om beide metriekwaarden te overwegen – en gelukkig is er een metriek die ze combineert.

F1-score

De F1-score is het harmonisch gemiddelde van precisie en recall. Het harmonisch gemiddelde heeft de voorkeur boven het gewone (rekenkundige) gemiddelde omdat het situaties bestraft waarin één van de waarden (precisie of recall) laag is, waardoor het een meer gebalanceerde maat is voor de prestaties van een model.

F1=21precision+1recall=2precisionrecallprecision+recall\text{F1} = \frac{2}{\frac{1}{\text{precision}} + \frac{1}{\text{recall}}} = \frac{2 \cdot \text{precision} \cdot \text{recall}}{\text{precision} + \text{recall}}

De F1-score combineert zowel precisie als recall in één metriek. De score is alleen hoog als zowel precisie als recall relatief hoog zijn, waardoor het een nuttige maat is wanneer beide fouttypen in balans moeten worden gehouden.

Het kiezen van de juiste metriek hangt af van de specifieke taak. Nauwkeurigheid (of gebalanceerde nauwkeurigheid voor onevenwichtige datasets) is intuïtief en geeft een algemeen beeld van de algehele prestaties van het model. Als meer gedetailleerd inzicht nodig is in de soorten fouten die het model maakt, helpt precisie bij het identificeren van type 1-fouten, terwijl herinnering type 2-fouten benadrukt. De F1-score toont hoe goed het model in balans is wat betreft zowel type 1- als type 2-fouten.

MetricsSummary
Note
Meer Leren

Een andere veelgebruikte metriek is ROC/AUC, waarover je meer kunt lezen in dit artikel.

Metrieken in Python

Scikit-learn biedt implementaties voor al deze metriek in de module sklearn.metrics:

from sklearn.metrics import accuracy_score, balanced_accuracy_score, precision_score, recall_score, f1_score

accuracy = accuracy_score(y_true, y_pred)
balanced_accuracy = balanced_accuracy_score(y_true, y_pred)
precision = precision_score(y_true, y_pred)
recall = recall_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred)

Als je metriek zoals precisie, recall en F1-score allemaal tegelijk wilt verkrijgen, biedt sklearn de functie classification_report() aan:

12345678910111213
import pandas as pd import seaborn as sns from sklearn.metrics import classification_report from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/titanic.csv') X, y = df.drop('Survived', axis=1), df['Survived'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1) random_forest = RandomForestClassifier().fit(X_train, y_train) y_pred = random_forest.predict(X_test) # Display a classification report print(classification_report(y_test, y_pred))
Note
Opmerking

Support verwijst naar het aantal daadwerkelijke voorkomens van elke klasse in de testset. Macro avg berekent het gemiddelde van elke metriek (precisie, recall, F1) over alle klassen gelijkmatig, zonder rekening te houden met klasse-ongelijkheid. Weighted avg berekent ook het gemiddelde van de metriek over alle klassen, maar geeft meer gewicht aan klassen met meer instanties (gebaseerd op hun support).

question mark

Welke evaluatiemaatstaf biedt een balans tussen precisie en recall, en geeft één score die beide weerspiegelt?

Selecteer het correcte antwoord

Was alles duidelijk?

Hoe kunnen we het verbeteren?

Bedankt voor je feedback!

Sectie 5. Hoofdstuk 2

Vraag AI

expand

Vraag AI

ChatGPT

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 5. Hoofdstuk 2
some-alt