Verwirrungsmatrix: Warum Genauigkeit allein bei KI-Modellen irreführt

Eine KI mit 95 % Genauigkeit klingt nach einem Erfolg. Doch was, wenn das Modell in einem Szenario mit 95 % legitimen und nur 5 % betrügerischen Transaktionen einfach nie Betrug vorhersagt? Die scheinbar hohe Genauigkeit wird zur Falle – und die Verwirrungsmatrix (auch Konfusionsmatrix genannt) ist der einzige Weg, solche Verzerrungen zu erkennen.

Die vier Seiten jeder Vorhersage: Was die Matrix wirklich zeigt

Jede Entscheidung eines Modells lässt sich in vier Kategorien einteilen. Nehmen wir als Beispiel einen medizinischen Test: Die Matrix zeigt, wo das Modell richtig lag – und wo es scheiterte.

| Vorhersage | Positiv | Negativ | | |------------|---------|---------|------| | Tatsächlich positiv | TP | FN | | | Tatsächlich negativ | FP | TN | |

• True Positive (TP): Das Modell sagt „krank“ voraus – und liegt richtig. Beispiel: Der Test erkennt eine bösartige Geschwulst.
• True Negative (TN): Das Modell sagt „gesund“ voraus – und liegt richtig. Beispiel: Der Test bestätigt, dass keine Krankheit vorliegt.
• False Positive (FP): Das Modell sagt „krank“ voraus – doch der Patient ist gesund. Dies nennt man auch Typ-I-Fehler. Im Alltag führt das zu unnötigen Untersuchungen.
• False Negative (FN): Das Modell sagt „gesund“ voraus – doch der Patient ist tatsächlich krank. Dies ist ein Typ-II-Fehler und kann lebensbedrohlich sein, etwa wenn Krebs übersehen wird.

Der entscheidende Punkt: FP und FN haben oft völlig unterschiedliche Konsequenzen. Während ein falscher Alarm (FP) ärgerlich sein mag, kann ein übersehener Fall (FN) katastrophale Folgen haben. Genauigkeit allein verrät nichts über diese Unterschiede – die Verwirrungsmatrix schon.

Praxistipp: So erstellen Sie Ihre erste Verwirrungsmatrix

Ein einfaches Beispiel mit echten Daten zeigt, wie schnell Verzerrungen sichtbar werden. Hier nutzen wir den Breast Cancer Wisconsin-Datensatz aus scikit-learn, der gutartige (benigne) und bösartige (maligne) Tumore enthält.

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

Zuerst laden wir die Daten, teilen sie in Trainings- und Testsets auf und trainieren ein Random-Forest-Modell:

data = load_breast_cancer()
X, y = data.data, data.target  # 0 = maligne, 1 = benigne

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y  # Beibehaltung der Klassenverteilung
)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

Die Rohdaten der Matrix offenbaren bereits kritische Muster:

cm = confusion_matrix(y_test, y_pred)
print("Verwirrungsmatrix:")
print(cm)

Ausgabe:

[[40  2]
 [ 1 71]]

• True Positives (TP): 71 (korrekt als benigne vorhergesagt)
• True Negatives (TN): 40 (korrekt als maligne vorhergesagt)
• False Positives (FP): 2 (fälschlich als benigne eingestuft, obwohl maligne)
• False Negatives (FN): 1 (fälschlich als maligne eingestuft, obwohl benigne)

Das Modell erreichte eine Genauigkeit von 97,4 % (111 von 114 korrekten Vorhersagen). Doch der entscheidende Fehler: 2 bösartige Tumore wurden übersehen – ein FN-Fall, der im medizinischen Kontext gravierende Folgen hätte.

Warum Visualisierung die Analyse vereinfacht

Zahlen allein reichen oft nicht aus. Eine grafische Darstellung macht die Muster sofort erkennbar. Mit scikit-learns ConfusionMatrixDisplay lässt sich die Matrix als Heatmap darstellen – einmal als absolute Häufigkeiten und einmal als prozentuale Verteilung pro Klasse.

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# Absolute Häufigkeiten
disp1 = ConfusionMatrixDisplay(
    confusion_matrix=cm,
    display_labels=data.target_names
)
disp1.plot(ax=axes[0], colorbar=False, cmap='Blues')
axes[0].set_title('Absolute Häufigkeiten')

# Normalisierte Darstellung (Zeilenweise Prozentwerte)
cm_normalized = confusion_matrix(y_test, y_pred, normalize='true')
disp2 = ConfusionMatrixDisplay(
    confusion_matrix=cm_normalized,
    display_labels=data.target_names
)
disp2.plot(ax=axes[1], colorbar=False, cmap='Blues')
axes[1].set_title('Normalisierte Verteilung (pro Klasse)')

plt.tight_layout()
plt.savefig('verwirrungsmatrix.png', dpi=100)
plt.show()

Die normalisierte Ansicht zeigt, welcher Anteil jeder Klasse korrekt identifiziert wurde. Beispiel: Falls nur 80 % der bösartigen Tumore erkannt werden, wird dies sofort sichtbar – selbst wenn die Gesamtgenauigkeit hoch bleibt.

Klassenungleichgewicht: Warum Genauigkeit eine Illusion schafft

Ein klassisches Beispiel aus dem Betrugserkennungssystem zeigt, wie trügerisch Genauigkeit sein kann. Angenommen, ein Datensatz enthält:

• 950 legitime Transaktionen (95 %)
• 50 betrügerische Transaktionen (5 %)

Ein naives Modell, das nie Betrug vorhersagt, erreicht eine Genauigkeit von 95 % – doch es fängt null Betrugsfälle ein. Ein smarteres Modell erkennt zwar 35 der 50 Betrugsfälle, löst aber 20 falsche Alarme aus. Seine Genauigkeit steigt auf 96,5 %.

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

# Datensatz mit Ungleichgewicht
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 0=legit, 1=Betrug

# Modell A: Immer "kein Betrug"
y_pred_lazy = np.zeros(1000, dtype=int)

# Modell B: Erkennt 35 Betrugsfälle, aber 20 falsche Alarme
y_pred_smart = np.zeros(1000, dtype=int)
fraud_indices = np.where(y_true == 1)[0]
y_pred_smart[fraud_indices[:35]] = 1  # 35 echte Betrugsfälle erkannt
y_pred_smart[:20] = 1  # 20 falsche Alarme auf legitime Transaktionen

print("Modell A: Immer 'kein Betrug' sagt")
print(f"Genauigkeit: {accuracy_score(y_true, y_pred_lazy):.3f}")
print(f"Betrug erkannt: {confusion_matrix(y_true, y_pred_lazy)[1][1]} von 50")

print("\nModell B: Erkennt Betrug aktiv")
print(f"Genauigkeit: {accuracy_score(y_true, y_pred_smart):.3f}")
cm_b = confusion_matrix(y_true, y_pred_smart)
print(f"Betrug erkannt: {cm_b[1][1]} von 50")

Ergebnis:

• Modell A: Genauigkeit 95,0 %, Betrugsfälle erkannt: 0
• Modell B: Genauigkeit 96,5 %, Betrugsfälle erkannt: 35

Die Verwirrungsmatrix entlarvt das naivere Modell sofort – während die Genauigkeit nur minimal besser erscheint. In der Praxis entscheiden Metriken wie Präzision, Rekall oder F1-Score darüber, ob ein Modell im realen Einsatz funktioniert.

Fazit: Die Verwirrungsmatrix als Grundpfeiler der Modellbewertung

Genauigkeit ist ein nützlicher Ausgangspunkt, doch sie verrät nichts über die Verteilung der Fehler. Die Verwirrungsmatrix hingegen zeigt:

• Welche Fehlerarten besonders häufig auftreten
• Ob das Modell für die jeweilige Anwendung geeignet ist (z. B. medizinische Diagnostik vs. Spam-Filter)
• Wie unausgewogene Daten das Modell beeinflussen

Egal, ob Sie ein Klassifizierungsmodell für Betrugserkennung, medizinische Diagnostik oder Kundenservice entwickeln – die Verwirrungsmatrix sollte immer Ihr erster Schritt sein, um echte Performance zu messen. Ohne sie riskieren Sie, Modelle zu deployen, die zwar hohe Genauigkeit vortäuschen, aber im Ernstfall versagen.