Machine Learning: Die Konfusionsmatrix verstehen

Eine Konfusionsmatrix ist eine Tabelle, die die Vorhersageergebnisse eines Klassifikationsmodells zusammenfasst, indem tatsächliche Labels mit vorhergesagten Labels verglichen werden. Sie ist der Ausgangspunkt für die Berechnung von Precision, Recall, F1-Score und den meisten anderen Klassifikationsmetriken.

Dieses Kapitel behandelt:

• Was die vier Zellen (TP, FP, TN, FN) bedeuten und warum jede davon wichtig ist
• Wie man gängige Metriken aus diesen Zellen berechnet
• Das Erstellen und Visualisieren einer Konfusionsmatrix in Python mit scikit-learn und seaborn
• Konfusionsmatrizen bei mehreren Klassen
• Häufige Fallstricke — insbesondere bei unausgeglichenen Datensätzen

Was ist eine Konfusionsmatrix?

Für einen binären Klassifikator (zwei mögliche Klassen: positiv und negativ) ist die Konfusionsmatrix eine 2×2-Tabelle:

Jede Zelle zählt eine bestimmte Art von Ergebnis:

Eine einfache Eselsbrücke: Das erste Wort (True / False) gibt an, ob die Vorhersage korrekt war; das zweite Wort (Positive / Negative) gibt an, was das Modell vorhergesagt hat.

Aus der Matrix abgeleitete Metriken

Die vier Zählwerte fließen in jede standardmäßige Klassifikationsmetrik ein:

Wann Precision vs. Recall priorisiert werden sollte

• Recall priorisieren, wenn das Übersehen eines positiven Falls kostspielig ist — medizinisches Screening, Betrugserkennung, Spam-Filter, die jede Spam-Nachricht abfangen müssen.
• Precision priorisieren, wenn Fehlalarme kostspielig sind — Operationsempfehlungen, Kennzeichnung juristischer Dokumente, Push-Benachrichtigungssysteme.
• F1-Score gleicht beides aus und ist die Standardmetrik, wenn der Datensatz unausgeglichen ist.

Ausgearbeitetes numerisches Beispiel

Angenommen, ein Modell untersucht 100 Patienten auf eine Krankheit:

• TP = 50 (kranke Patienten korrekt identifiziert)
• FP = 5 (gesunde Patienten fälschlicherweise als krank eingestuft)
• FN = 10 (kranke Patienten übersehen)
• TN = 35 (gesunde Patienten korrekt freigegeben)

Schrittweise Berechnungen:

Accuracy  = (50 + 35) / 100 = 0.85  (85 %)
Precision = 50 / (50 + 5)  ≈ 0.909 (90.9 %)
Recall    = 50 / (50 + 10) ≈ 0.833 (83.3 %)
F1-Score  = 2 × 0.909 × 0.833 / (0.909 + 0.833) ≈ 0.869 (86.9 %)

Beachte, dass die Accuracy (85 %) akzeptabel erscheint, der Recall jedoch nur 83 % beträgt — das bedeutet, dass 10 von 60 kranken Patienten übersehen wurden. In einem medizinischen Kontext ist diese Lücke weitaus bedeutsamer als die Accuracy-Kennzahl allein.

Eine Konfusionsmatrix in Python erstellen

Mit scikit-learn

sklearn.metrics stellt confusion_matrix() und einen fertigen Textbericht über classification_report() bereit.

from sklearn.metrics import confusion_matrix, classification_report

# Ground-truth labels and model predictions
y_true = [1, 1, 0, 0, 1, 0, 1, 0, 1, 0]
y_pred = [1, 0, 0, 1, 1, 0, 1, 0, 1, 1]

cm = confusion_matrix(y_true, y_pred)
print("Confusion Matrix:")
print(cm)
print()
print(classification_report(y_true, y_pred, target_names=["Negative", "Positive"]))

confusion_matrix() gibt ein NumPy-Array zurück. Standardmäßig sind die Zeilen tatsächliche Klassen und die Spalten vorhergesagte Klassen (entsprechend der oben gezeigten Tabellenanordnung). Das Array-Layout ist:

[[TN  FP]
 [FN  TP]]

Metriken manuell berechnen

Du kannst die vier Zellen extrahieren und die Metriken selbst berechnen, um sie zu überprüfen:

from sklearn.metrics import confusion_matrix

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

tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()

accuracy  = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp)
recall    = tp / (tp + fn)
f1        = 2 * precision * recall / (precision + recall)

print(f"TP={tp}, FP={fp}, FN={fn}, TN={tn}")

print(f"Accuracy : {accuracy:.3f}")
print(f"Precision: {precision:.3f}")
print(f"Recall   : {recall:.3f}")
print(f"F1-Score : {f1:.3f}")

Erwartete Ausgabe:

TP=4, FP=2, FN=1, TN=3
Accuracy : 0.700
Precision: 0.667
Recall   : 0.800
F1-Score : 0.727

Visualisierung mit seaborn

Eine Heatmap macht die Konfusionsmatrix leichter lesbar, besonders bei Mehrklassenproblemen:

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix

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

cm = confusion_matrix(y_true, y_pred)

sns.heatmap(
    cm,
    annot=True,
    fmt="d",
    cmap="Blues",
    xticklabels=["Negative", "Positive"],
    yticklabels=["Negative", "Positive"],
)
plt.xlabel("Predicted label")
plt.ylabel("True label")
plt.title("Confusion Matrix")
plt.tight_layout()
plt.savefig("confusion_matrix.png", dpi=150)
plt.show()

annot=True gibt die Anzahl in jeder Zelle aus; fmt="d" formatiert sie als ganze Zahlen.

Konfusionsmatrizen bei mehreren Klassen

Wenn es mehr als zwei Klassen gibt, erweitert sich die Konfusionsmatrix zu einem N×N-Raster. Jede Zeile repräsentiert weiterhin tatsächliche Klassen; jede Spalte repräsentiert vorhergesagte Klassen. Die Diagonalzellen sind korrekte Vorhersagen; außerdiagonale Zellen sind Fehler.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

# Three classes: cat, dog, rabbit
y_true = ["cat", "dog", "rabbit", "cat", "dog", "rabbit",
          "cat", "dog", "cat", "rabbit"]
y_pred = ["cat", "dog", "rabbit", "dog", "dog", "cat",
          "cat", "rabbit", "cat", "rabbit"]

labels = ["cat", "dog", "rabbit"]
cm = confusion_matrix(y_true, y_pred, labels=labels)
print(cm)

disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot(cmap="Blues")
plt.title("Multi-Class Confusion Matrix")
plt.tight_layout()
plt.savefig("cm_multiclass.png", dpi=150)
plt.show()

ConfusionMatrixDisplay (ab scikit-learn 0.24 verfügbar) ist eine bequeme Einzeiler-Alternative zur seaborn-Heatmap und erfordert keine seaborn-Abhängigkeit.

Bei Mehrklassenproblemen werden Precision und Recall pro Klasse berechnet und dann gemittelt. classification_report() bietet drei Mittelungsstrategien:

• macro — ungewichteter Durchschnitt über alle Klassen (behandelt alle Klassen gleich).
• weighted — nach Support gewichteter Durchschnitt (Anzahl der tatsächlichen Instanzen pro Klasse).
• micro — aggregiert TP/FP/FN über alle Klassen vor der Division (ergibt die Gesamtgenauigkeit bei ausgeglichenen Datensätzen).

Häufige Fallstricke

Accuracy ist bei unausgeglichenen Datensätzen irreführend

Stell dir einen Datensatz vor, bei dem 95 % der Stichproben negativ sind. Ein Modell, das immer negativ vorhersagt, erreicht 95 % Accuracy, hat aber einen Recall von null — es erkennt keinen einzigen positiven Fall. Die Konfusionsmatrix zeigt dies sofort: die gesamte erste Zeile (Tatsächlich Positiv) besteht nur aus FN.

Kombiniere Accuracy immer mit Precision, Recall oder F1-Score bei unausgeglichenen Daten. Siehe das Kapitel Train/Test Split für die Erstellung eines repräsentativen Splits und das Kapitel AUC-ROC Curve für eine schwellenwertunabhängige Evaluierungsmetrik.

Die falsche Mittelungsstrategie wählen

Die Verwendung der macro-Mittelung bei stark unausgeglichenen Klassen überschätzt den Score seltener Klassen. Verwende weighted für ein realistisches Bild der Gesamtmodellqualität auf dem vollständigen Datensatz.

Normalisierung vergessen

Rohe Zählwerte hängen von der Datensatzgröße ab. Wenn Modelle verglichen werden, die auf Datensätzen unterschiedlicher Größe trainiert wurden, normalisiere die Matrix, indem jede Zeile durch ihre Summe geteilt wird (übergib normalize='true' an confusion_matrix()):

cm_normalized = confusion_matrix(y_true, y_pred, normalize="true")
print(cm_normalized.round(2))

Jede Zeile summiert sich nun zu 1.0 und zeigt den Anteil jeder tatsächlichen Klasse, der korrekt vorhergesagt wurde.

Konfusionsmatrix vs. andere Evaluierungswerkzeuge

Wichtige Erkenntnisse

• Eine Konfusionsmatrix unterteilt Vorhersagen in TP, FP, TN und FN — vier Zählwerte, die zeigen, welche Fehler ein Modell macht, nicht nur wie viele.
• Accuracy allein reicht nicht aus; prüfe immer Precision, Recall und F1-Score, insbesondere bei unausgeglichenen Daten.
• Verwende sklearn.metrics.confusion_matrix() zur Berechnung und seaborn oder ConfusionMatrixDisplay zur Visualisierung.
• Mehrklassenmatrizen folgen derselben Konvention (Zeile = tatsächlich, Spalte = vorhergesagt) und skalieren auf N×N.
• Passe die Mittelungsstrategie (macro, weighted, micro) an die Klassenverteilung deines Datensatzes an.