Forklaring av forvekslingsmatrisen
De vil lage en forvekslingsmatrise fra prediksjoner og fasit, og deretter utlede sanne positive, falske negative og relaterte antall.
Forklaring av forvekslingsmatrisen er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Mer enn nøyaktighet: forstå feilene
Nøyaktighet forteller hvor stor prosentandel av prediksjonene som er riktige, men behandler alle feil som likeverdige. I virkeligheten kan ulike feil ha svært ulike konsekvenser. Et spamfilter som sender en legitim e-post til spam-mappen, er irriterende, mens en modell for medisinsk diagnostikk som overser et krefttilfelle, kan være livstruende.
Forvekslingsmatrisen er verktøyet som bryter ned klassifikatorytelsen i en 2×2-tabell (for binær klassifikasjon) som viser alle mulige kombinasjoner av faktiske og predikerte etiketter. Den viser ikke bare hvor mye modellen tar feil, men også hvordan den tar feil.
De fire feltene i forvekslingsmatrisen
For binær klassifikasjon med klassene Positiv (1) og Negativ (0) har forvekslingsmatrisen fire felt:
- True Positive (TP) — faktisk positiv, predikert positiv. Korrekt deteksjon.
- True Negative (TN) — faktisk negativ, predikert negativ. Korrekt avvisning.
- False Positive (FP) — faktisk negativ, predikert positiv. Type I-feil; falsk alarm.
- False Negative (FN) — faktisk positiv, predikert negativ. Type II-feil; manglende deteksjon.
Alle fire antallene er nødvendige for å beskrive klassifikatorens atferd fullstendig.
import numpy as np
# Medical test example:
# Positive = disease present, Negative = disease absent
y_true = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 0])
y_pred = np.array([1, 0, 1, 0, 1, 0, 1, 0, 0, 0])
TP = ((y_pred == 1) & (y_true == 1)).sum()
TN = ((y_pred == 0) & (y_true == 0)).sum()
FP = ((y_pred == 1) & (y_true == 0)).sum()
FN = ((y_pred == 0) & (y_true == 1)).sum()
print(f'TP={TP} FP={FP}')
print(f'FN={FN} TN={TN}')
print(f'Total: {TP+TN+FP+FN}')Bygging av forvekslingsmatrisen med scikit-learn
scikit-learns funksjon confusion_matrix() tar de faktiske og predikerte etikettene og returnerer matrisen som en NumPy-tabell. Konvensjonen i scikit-learn er rader = faktisk klasse og kolonner = predikert klasse.
For binær klassifikasjon med etikettene [0, 1] er matrisen organisert slik:
- Rad 0, kolonne 0 = TN (faktisk 0, predikert 0)
- Rad 0, kolonne 1 = FP (faktisk 0, predikert 1)
- Rad 1, kolonne 0 = FN (faktisk 1, predikert 0)
- Rad 1, kolonne 1 = TP (faktisk 1, predikert 1)
from sklearn.metrics import confusion_matrix
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)
model = LogisticRegression(max_iter=1000)
model.fit(X_train_s, y_train)
y_pred = model.predict(X_test_s)
cm = confusion_matrix(y_test, y_pred)
print('Confusion matrix:')
print(cm)
print('\nRows=Actual, Cols=Predicted')Visualisering av forvekslingsmatrisen som et varmekart
En forvekslingsmatrise som visualiseres som et varmekart, gjør antallene umiddelbart lesbare. Store tall på diagonalen (fra øverst til venstre til nederst til høyre) indikerer korrekte prediksjoner. Store tall utenfor diagonalen indikerer feil som bør undersøkes.
Bruk seaborns heatmap() med annot=True og fmt='d' for å vise heltallene i hvert felt. Hvis De legger til navn på målklassene, blir figuren selvforklarende uten at De trenger å slå opp en forklaring.
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
class_names = ['Malignant', 'Benign'] # breast cancer dataset
plt.figure(figsize=(7, 6))
sns.heatmap(
cm,
annot=True,
fmt='d',
cmap='Blues',
xticklabels=class_names,
yticklabels=class_names
)
plt.ylabel('Actual Label')
plt.xlabel('Predicted Label')
plt.title('Confusion Matrix — Breast Cancer Classifier')
plt.show()Utledning av nøyaktighet fra forvekslingsmatrisen
Alle klassifikasjonsmål kan utledes fra de fire feltene i forvekslingsmatrisen. Nøyaktighet er det enkleste — det er andelen prediksjoner som ligger på diagonalen (TP + TN), av alle prediksjonene:
Accuracy = (TP + TN) / (TP + TN + FP + FN)
Alle prediksjoner er korrekte. Alle prediksjoner = TP + TN + FP + FN. Hvis testsettet Deres har 100 eksempler og De har TP=40, TN=50, FP=5, FN=5, blir nøyaktigheten = 90/100 = 0.90. Men de 5 FN-feilene (oversette positive tilfeller) kan ha langt større konsekvenser enn de 5 FP-feilene.
from sklearn.metrics import confusion_matrix, accuracy_score
import numpy as np
y_true = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 0])
y_pred = np.array([1, 0, 1, 0, 1, 0, 1, 0, 0, 0])
cm = confusion_matrix(y_true, y_pred)
TN, FP, FN, TP = cm.ravel() # for 2x2 matrix
# Manual accuracy
manual_acc = (TP + TN) / (TP + TN + FP + FN)
sklearn_acc = accuracy_score(y_true, y_pred)
print(f'TP={TP}, TN={TN}, FP={FP}, FN={FN}')
print(f'Manual accuracy: {manual_acc:.2f}')
print(f'sklearn accuracy: {sklearn_acc:.2f}')Type I- og type II-feil
I statistikk og maskinlæring har feil formelle navn som gjenspeiler hvor alvorlige de er i ulike sammenhenger:
- Type I-feil = False Positive. De utløser alarm når det ikke er noe å bekymre seg for. Eksempel: å flagge en legitim transaksjon som svindel eller sende noen unødvendig til sykehus.
- Type II-feil = False Negative. De overser en reell hendelse. Eksempel: å godkjenne en svindeltransaksjon eller sende en kreftpasient hjem som frisk.
I de fleste klassifikasjonsproblemer fra den virkelige verden har type I- og type II-feil svært ulike kostnader. Derfor er ett enkelt nøyaktighetstall utilstrekkelig for beslutningstaking.
Forvekslingsmatrisen for problemer med flere klasser
For et problem med k klasser er forvekslingsmatrisen k×k. Hver rad representerer en faktisk klasse, og hver kolonne representerer en predikert klasse. Diagonalelementene er korrekte prediksjoner, mens elementene utenfor diagonalen er feilklassifiseringer.
Forvekslingsmatriser for flere klasser viser hvilke klasser modellen oftest forveksler. En siffergjenkjenner kan for eksempel ofte forveksle 4-ere og 9-ere fordi de ligner på hverandre. Denne innsikten kan styre målrettede forbedringer: samle inn flere treningseksempler av klassene som forveksles, legge til egenskaper som skiller dem, eller etterbehandle prediksjoner for disse spesifikke parene.
from sklearn.metrics import confusion_matrix
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = DecisionTreeClassifier(max_depth=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(9, 7))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Digit Confusion Matrix (10 classes)')
plt.show()Normalisert forvekslingsmatrise
Når klassene har ulikt antall eksempler (klasseubalanse), kan absolutte antall i forvekslingsmatrisen være misvisende. En normalisert forvekslingsmatrise deler hver rad på det totale antallet faktiske eksempler i klassen, slik at rå antall omregnes til gjenkallingsrater (andelen som identifiseres korrekt).
En perfekt klassifikator har 1.0 i hvert diagonalfelt og 0.0 overalt ellers. En normalisert matrise gjør det enkelt å sammenligne ytelsen per klasse, uavhengig av klassestørrelsen.
from sklearn.metrics import confusion_matrix
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
cm = confusion_matrix(y_test, y_pred)
# Normalise by row (actual class total)
cm_norm = cm.astype(float) / cm.sum(axis=1, keepdims=True)
plt.figure(figsize=(9, 7))
sns.heatmap(cm_norm, annot=True, fmt='.2f', cmap='Blues')
plt.ylabel('Actual Class')
plt.xlabel('Predicted Class')
plt.title('Normalised Confusion Matrix (row = recall per class)')
plt.show()
# Per-class recall from diagonal
print('Per-class recall:', np.diag(cm_norm).round(3))ConfusionMatrixDisplay: Det offisielle scikit-learn-verktøyet
scikit-learn tilbyr ConfusionMatrixDisplay som et verktøy på høyt nivå for å tegne forvekslingsmatriser uten at De trenger seaborn. De kan opprette det direkte fra forvekslingsmatrisen som en tabell eller ved å kalle from_estimator(), som utfører prediksjonen internt.
Hvis De setter display_labels til navnene på klassene, blir figuren umiddelbart selvforklarende. Visningen inkluderer også en valgfri fargeskala som hjelper leseren med å anslå verdiene før de nøyaktige tallene leses.
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
class_names = load_breast_cancer().target_names # ['malignant', 'benign']
# Method 1: from_estimator (runs predict internally)
disp = ConfusionMatrixDisplay.from_estimator(
model,
X_test_s,
y_test,
display_labels=class_names,
cmap='Blues'
)
disp.ax_.set_title('Confusion Matrix')Hva forvekslingsmatrisen forteller Dem
En godt trent klassifikator bør ha de fleste eksemplene på diagonalen. Når De ser store tall utenfor diagonalen, bør De undersøke årsaken:
- Mange FP (falske positive): modellen er for aggressiv — senk beslutningsterskelen eller legg til regularisering.
- Mange FN (falske negative): modellen overser for mange reelt positive tilfeller — senk terskelen eller forbedre gjenkallingen.
- Symmetriske feil mellom klasse A og B: de to klassene er for like i egenskapsrommet — legg til egenskaper som skiller dem.
- Feil konsentrert i én faktisk klasse: denne klassen er underrepresentert eller vanskeligere å lære — oversample den eller samle inn mer data.
Fra forvekslingsmatrise til full klassifikasjonsrapport
Alle målene i classification_report() er utledet fra forvirringsmatrisen. Når De forstår matrisen, forstår De alle målene på én gang. Fra TP, TN, FP og FN kan De beregne:
- Accuracy = (TP+TN)/N
- Precision = TP/(TP+FP)
- Recall = TP/(TP+FN)
- Specificity = TN/(TN+FP)
- F1 = 2×Precision×Recall/(Precision+Recall)
I neste leksjon lærer De alle disse avledede målene grundig og når hvert av dem er det riktige valget.
from sklearn.metrics import classification_report, confusion_matrix
import numpy as np
y_true = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 0])
y_pred = np.array([1, 0, 1, 0, 1, 0, 1, 0, 0, 0])
cm = confusion_matrix(y_true, y_pred)
TN, FP, FN, TP = cm.ravel()
# Compute all metrics from raw counts
precision = TP / (TP + FP) if (TP + FP) > 0 else 0
recall = TP / (TP + FN) if (TP + FN) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
print(f'Precision: {precision:.2f}')
print(f'Recall: {recall:.2f}')
print(f'F1-Score: {f1:.2f}')
print('\nscikit-learn report:')
print(classification_report(y_true, y_pred))Kunnskapssjekk
Test forståelsen Deres av begrepene innen maskinlæring med Python fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært at forvirringsmatrisen bryter klassifikatorens feil ned i sanne positive, sanne negative, falske positive og falske negative, at falske negative (type II-feil) og falske positive (type I-feil) har svært ulike konsekvenser i den virkelige verden, og at alle klassifikasjonsmål – accuracy, precision, recall og F1 – er utledet fra disse fire tallene i forvirringsmatrisen. Neste gang går vi i dybden på precision, recall og F1-score, og lærer om den kritiske avveiningen mellom dem som brukes ved evaluering av klassifikatorer i den virkelige verden.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Forklaring av forvekslingsmatrisen» gratis?
Ja – hele teksten i «Forklaring av forvekslingsmatrisen» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Forklaring av forvekslingsmatrisen»?
De vil lage en forvekslingsmatrise fra prediksjoner og fasit, og deretter utlede sanne positive, falske negative og relaterte antall. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Machine Learning Academy?
Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Forklaring av forvekslingsmatrisen»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?
Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Fra regresjon til klassifisering: Beslutninger med terskelverdi
- Logistisk regresjon og sigmoidfunksjonen
- Forklaring av forvekslingsmatrisen
- Presisjon, tilbakekalling og F1-skår i praksis