Du lernst, warum allein oft täuscht, wie und funktionieren, wann oder wichtiger sind, was und bedeuten und wie du einordnest.
Bei kann eine hohe Accuracy blenden, obwohl das Modell das eigentliche Problem kaum löst.
Du arbeitest in einer Schokoladenfabrik. Von 100 Tafeln sind nur 5 fehlerhaft. Wenn du einfach sagst: „Alles ist okay“, liegst du 95 Mal richtig.
Das klingt stark, ist aber inhaltlich schwach, weil genau die 5 problematischen Tafeln unentdeckt bleiben. Genau das macht Accuracy allein so tückisch.
misst den Anteil korrekter Vorhersagen. Sie ist leicht verständlich, aber bei unbalancierten Klassen oft irreführend.
Wenn fast alle Fälle negativ sind, kann ein Modell mit fast immer „negativ“ erstaunlich gut aussehen, obwohl es die positiven Fälle kaum erkennt.
Was ist gemessen? In unserem Fall der Anteil aller richtig geprüften Schokoladentafeln, egal ob sie okay oder defekt sind.
So liest man den Wert: In unserem Fall heißt Accuracy: „In X % der Fälle liegt das Modell richtig, egal ob 0 oder 1.“
Was ist hier der schlimmste Fehler? Eine defekte Tafel zu übersehen. Das ist ein False Negative, obwohl die Gesamtzahl noch gut aussehen kann.
from sklearn.metrics import accuracy_score
actual = [0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
predicted = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
print(accuracy_score(actual, predicted))Was nimmst du mit?
Eine einzige hohe Zahl kann beruhigend klingen und trotzdem fachlich gefährlich sein. Genau deshalb brauchst du mehr als nur Accuracy.
TP, FP, TN und FN zeigen nicht nur, ob du richtig lagst, sondern welche Art von Fehlern du gemacht hast.
Ein Spam-Filter soll Werbemails aussortieren. Manche Spam-Mails landen trotzdem im Posteingang. Andere wichtige Nachrichten verschwinden fälschlich im Spam-Ordner.
Beides ist falsch, aber nicht auf dieselbe Weise. Genau diese Unterscheidung macht die sichtbar.
und sind richtige Entscheidungen. ist falscher Alarm. ist ein verpasster Treffer.
Wichtig: „Positiv“ bedeutet hier nicht „gut“, sondern „der Fall, den das Modell erkennen soll“.
Was ist gemessen? In unserem Fall vier Sortierfehler und Treffer eines Spam-Filters: richtige Spam-Treffer, falscher Alarm, richtige normale Mails und übersehener Spam.
So liest man den Wert: Die Matrix sagt nicht nur „wie oft richtig“, sondern „welche Art von falsch“ passiert ist.
Was ist hier der schlimmste Fehler? In unserem Fall eine wichtige Mail fälschlich als Spam wegzusortieren. Das ist ein False Positive, wenn „positiv“ = Spam ist.
Nutze dieselben echten und vorhergesagten Labels wie im Notebook und baue die Confusion Matrix selbst mit `sklearn.metrics` auf. Ergänze die fehlende Zeile und prüfe danach, ob die vier Felder in der richtigen Reihenfolge erscheinen.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.metrics import confusion_matrix
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
matrix = # ??? DEINE LÖSUNG ???
print(matrix)Die Funktion erwartet zuerst die echten Labels und dann die Vorhersagen. Die Ausgabe ist eine 2x2-Matrix mit TN, FP, FN und TP.
from sklearn.metrics import confusion_matrix
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
matrix = confusion_matrix(actual, predicted)
print(matrix)Erwartete Ausgabe: `[[4 2]\n [1 3]]`
from sklearn.metrics import confusion_matrix, accuracy_score
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
matrix = confusion_matrix(actual, predicted)
tn, fp, fn, tp = matrix.ravel()
print(matrix)
print(f"TN = {tn}, FP = {fp}, FN = {fn}, TP = {tp}")
print(f"Accuracy: {accuracy_score(actual, predicted):.2f}")TN, FP, FN und TP vorliegen. `accuracy_score` fasst alles danach zusätzlich zu einer Gesamtzahl zusammen.Was nimmst du mit?
Die Confusion Matrix ist wie ein Fehlerprotokoll. Erst durch sie wird klar, welche Art von Irrtum dein Modell tatsächlich macht.
Wenn du „positiv“ sagst: Wie oft liegst du damit wirklich richtig?
Bei einem Corona-Schnelltest willst du wissen: Wenn der Test positiv ist, wie oft ist die Person wirklich krank? Genau das ist Precision.
Wenn viele positive Ergebnisse falscher Alarm sind, sinkt die praktische Nützlichkeit der Warnung deutlich.
teilt die echten Treffer durch alle positiven Vorhersagen: TP / (TP + FP).
Sie ist besonders wichtig, wenn falscher Alarm teuer oder lästig ist, etwa bei Kreditkartenbetrug, Spam oder unnötigen Eingriffen. Der ist dabei der Regler, der festlegt, ab wann ein Fall als positiv zählt. Wichtig: Das hat nichts mit „positiv formuliert“ oder „negativ formuliert“ in Alltagssprache zu tun, sondern nur mit der internen Entscheidungsgrenze des Modells.
Was ist gemessen? In unserem Fall, wie verlässlich ein positives Schnelltest-Ergebnis ist.
So liest man den Wert: Wenn das Modell in unserem Fall „1 = krank“ sagt, stimmt das in X % der Fälle.
Was ist hier der schlimmste Fehler? Falscher Alarm. Genau deshalb schauen wir hier auf False Positives und damit auf Precision.
Berechne für dieselben Vorhersagen die `Precision`. Ergänze die fehlende Zeile und prüfe danach, wie verlässlich positive Testmeldungen in diesem kleinen Beispiel sind.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.metrics import precision_score
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
precision = # ??? DEINE LÖSUNG ???
print(f"Precision: {precision:.2f}")Die Funktion heißt `precision_score`. Sie erwartet zuerst `actual` und danach `predicted`.
from sklearn.metrics import precision_score
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
precision = precision_score(actual, predicted)
print(f"Precision: {precision:.2f}")Erwartete Ausgabe: `Precision: 0.60`
Was nimmst du mit?
Precision ist die Metrik für Situationen, in denen „positiv“ nicht leichtfertig vergeben werden darf.
Von allen echten positiven Fällen: Wie viele erwischt dein Modell überhaupt?
Bei einer Sicherheitskontrolle am Flughafen ist ein übersehener gefährlicher Gegenstand oft schlimmer als eine zusätzliche Kontrolle eines harmlosen Passagiers.
Genau dann wird Recall wichtiger: Wie viele echte problematische Fälle findest du wirklich?
teilt die echten Treffer durch alle tatsächlich positiven Fälle: TP / (TP + FN).
Recall ist entscheidend, wenn verpasste Treffer gefährlich, teuer oder peinlich sind, etwa bei Krebsvorsorge oder Betrugserkennung.
Was ist gemessen? In unserem Fall, wie viele echte problematische Fälle die Sicherheitskontrolle tatsächlich findet.
So liest man den Wert: Von allen echten 1-Fällen findet das Modell X %.
Was ist hier der schlimmste Fehler? Ein False Negative, also ein gefährlicher Gegenstand, der unentdeckt bleibt.
Berechne für dieselben Vorhersagen jetzt zusätzlich den `Recall`. Die Precision-Zeile ist schon da. Du ergänzt den Recall und vergleichst danach beide Werte.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.metrics import precision_score, recall_score
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
precision = precision_score(actual, predicted)
recall = # ??? DEINE LÖSUNG ???
print(f"Precision: {precision:.2f}")
print(f"Recall: {recall:.2f}")Die Funktion für Recall hat denselben Aufbau wie `precision_score`: erst `actual`, dann `predicted`.
from sklearn.metrics import precision_score, recall_score
actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
precision = precision_score(actual, predicted)
recall = recall_score(actual, predicted)
print(f"Precision: {precision:.2f}")
print(f"Recall: {recall:.2f}")Erwartete Ausgabe: `Precision: 0.60` und `Recall: 0.75`
Was nimmst du mit?
Recall ist die richtige Frage, wenn du möglichst wenig übersehen willst, auch wenn das manchmal mehr falsche Alarme kostet.
Wenn du Precision und Recall gemeinsam betrachten willst, hilft der F1-Score als harmonischer Mittelweg.
Ein Schüler hat in Mathe eine 1, in Deutsch aber eine 6. Ein anderer hat in beiden Fächern eine 2. Wer wirkt verlässlicher? Der zweite, weil er keine extreme Schwäche hat.
Der F1-Score funktioniert ähnlich: Er belohnt Balance und bestraft große Schieflagen zwischen Precision und Recall.
Der ist das harmonische Mittel von Precision und Recall. Er wird klein, wenn einer der beiden Werte stark abfällt.
Das macht ihn zu einer praktischen Einzelmetrik, wenn du Modelle vergleichen willst, ohne den Zielkonflikt zu vergessen.
Was ist gemessen? In unserem Fall ein gemeinsamer Balance-Wert aus Precision und Recall.
So liest man den Wert: F1 ist ein Mittelwert, der nur hoch ist, wenn Precision und Recall beide ordentlich sind.
Was ist hier der schlimmste Fehler? Kein einzelner Fehler allein, sondern eine Schieflage: Ein Wert sieht gut aus, der andere bricht ein.
from sklearn.metrics import f1_score
f1 = f1_score(actual_labels, predicted_labels)
print(f"F1-Score: {f1:.3f}")Was nimmst du mit?
F1 ist kein Zauberwert, aber ein guter Kompromiss, wenn du ein Modell nicht auf Kosten eines einzigen Zielwerts optimieren willst.
Statt nur einen Schwellenwert zu betrachten, zeigt die ROC-Kurve das Verhalten des Modells über alle möglichen Thresholds.
Ein Lautstärkeregler verändert, was du noch hörst und was nicht mehr. Ein Threshold macht bei Klassifikation etwas Ähnliches: Er verschiebt, wie vorsichtig oder mutig das Modell entscheidet.
Die ROC-Kurve zeigt, wie sich dieses Verhalten über alle Reglerstellungen hinweg verändert.
Die stellt gegen dar. Modelle nahe der Diagonale sind kaum besser als Zufall.
ist die Fläche unter der Kurve. 0.5 entspricht ungefähr Zufall, 1.0 wäre perfekt.
Was ist gemessen? In unserem Fall das Trennverhalten des Modells über viele Thresholds hinweg, nicht nur an einem einzelnen Punkt.
So liest man den Wert: Wenn ich den Threshold ändere, bewege ich mich entlang der Kurve: mehr Treffer gegen mehr Fehlalarme. Die AUC fasst dieses Gesamtbild in einer Zahl zusammen.
Was ist hier der schlimmste Fehler? Kein einzelner Zellenfehler, sondern ein Modell, das über viele Einstellungen kaum besser trennt als Zufall.
Nimm ein kleines Wahrscheinlichkeits-Beispiel und lasse dir daraus die ROC-Kurve und die AUC berechnen. Ergänze beide fehlenden Zeilen und prüfe, ob die AUC zum Trennverhalten passt.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.metrics import roc_curve, roc_auc_score
y_true = [0, 0, 1, 1]
y_prob = [0.1, 0.4, 0.35, 0.8]
fpr, tpr, thresholds = # ??? DEINE LÖSUNG ???
auc = # ??? DEINE LÖSUNG ???
print(f"AUC: {auc:.2f}")
print(f"Punkte auf der Kurve: {len(thresholds)}")`roc_curve` braucht echte Labels und Wahrscheinlichkeiten. `roc_auc_score` arbeitet mit denselben beiden Eingaben.
from sklearn.metrics import roc_curve, roc_auc_score
y_true = [0, 0, 1, 1]
y_prob = [0.1, 0.4, 0.35, 0.8]
fpr, tpr, thresholds = roc_curve(y_true, y_prob)
auc = roc_auc_score(y_true, y_prob)
print(f"AUC: {auc:.2f}")
print(f"Punkte auf der Kurve: {len(thresholds)}")Erwartete Ausgabe: `AUC: 0.75` und `Punkte auf der Kurve: 5`
from sklearn.metrics import roc_curve, roc_auc_score
fpr, tpr, thresholds = roc_curve(y_actual, y_probabilities)
auc = roc_auc_score(y_actual, y_probabilities)Was nimmst du mit?
ROC und AUC helfen besonders dann, wenn du Modelle insgesamt vergleichen willst und dich nicht an einen einzigen Threshold klammern möchtest.
Bei Regression zählen keine Klassen, sondern Abstände: Wie weit liegt die Vorhersage vom echten Wert entfernt?
Wenn du die Temperatur für morgen schätzt, sind 2 Grad daneben weniger schlimm als 8 Grad daneben. Genau solche Abstände messen Regressionsmetriken.
Je nachdem, ob du große Fehler besonders hart bestrafen willst oder eher den durchschnittlichen Abstand verstehen möchtest, greifst du zu einer anderen Kennzahl.
ist leicht zu verstehen. bestraft große Fehler stärker. bringt die quadratische Sicht zurück in die Originaleinheit. fragt nach erklärter Varianz.
Keine dieser Metriken ist automatisch „die beste“. Sie beantworten unterschiedliche Fragen.
Was ist gemessen? In unserem Fall Abstände zwischen vorhergesagter und echter Temperatur.
So liest man den Wert: MAE sagt, wie weit du im Mittel danebenliegst. RMSE klingt ähnlich, bestraft große Ausrutscher aber stärker. R² fragt, wie viel Struktur dein Modell überhaupt erklärt.
Was ist hier der schlimmste Fehler? Ein großer Ausreißer. Genau den nimmt MSE und damit auch RMSE besonders hart auseinander.
Berechne für vier Vorhersagen erst den mittleren absoluten Fehler, dann den mittleren quadratischen Fehler und daraus den RMSE. So siehst du klar, welche Kennzahl was bedeutet.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.metrics import mean_absolute_error, mean_squared_error
y_true = [3.0, -0.5, 2.0, 7.0]
y_pred = [2.5, 0.0, 2.0, 8.0]
mae = mean_absolute_error(y_true, y_pred)
mse = # ??? DEINE LÖSUNG ???
rmse = # ??? DEINE LÖSUNG ???
print(f"MAE: {mae:.3f}")
print(f"MSE: {mse:.3f}")
print(f"RMSE: {rmse:.3f}")Berechne zuerst den MSE mit mean_squared_error(...). Der RMSE ist dann einfach die Quadratwurzel davon.
from sklearn.metrics import mean_absolute_error, mean_squared_error
y_true = [3.0, -0.5, 2.0, 7.0]
y_pred = [2.5, 0.0, 2.0, 8.0]
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
rmse = mse ** 0.5
print(f"MAE: {mae:.3f}")
print(f"MSE: {mse:.3f}")
print(f"RMSE: {rmse:.3f}")Erwartete Ausgabe: `MAE: 0.500`, `MSE: 0.375` und `RMSE: 0.612`
Was nimmst du mit?
Bei Regression solltest du immer wissen, ob du vor allem Durchschnittsfehler verstehen oder große Fehlgriffe besonders hart bestrafen willst.
Die beste Metrik hängt nicht nur vom Modell ab, sondern vor allem von der fachlichen Konsequenz deiner Fehler.
Ein Arzt, ein Spam-Filter und ein Immobilienportal haben völlig unterschiedliche Ziele. Deshalb wäre es fachlich schief, überall blind dieselbe Metrik zu verwenden.
Gute Evaluation ist kein Standardrezept, sondern eine bewusste Entscheidung entlang der Frage: Welche Fehler tun uns am meisten weh?
Bei Klassifikation stehen Precision, Recall, F1 und AUC im Vordergrund. Bei Regression eher MAE, RMSE und R².
Unbalancierte Klassen, teure False Positives oder gefährliche False Negatives verändern die Wahl der Metrik oft deutlich. Deshalb kannst du einen Recall von 0.90 aus zwei verschiedenen Projekten nicht sinnvoll direkt vergleichen, wenn die positive Klasse oder die Fehlerkosten fachlich ganz anders definiert sind.
Was ist gemessen? Hier wird nicht einfach eine hübsche Zahl gesucht, sondern die Metrik ausgewählt, die zum echten Risiko des Falls passt.
So liest man den Wert: Die „beste“ Metrik heißt in unserem Fall: die Kennzahl, die den wichtigsten Fehler sichtbar macht.
Was ist hier der schlimmste Fehler? Nicht der rechnerische Fehler allein, sondern die falsche Priorität. Eine schöne Zahl hilft nicht, wenn sie am eigentlichen Risiko vorbeigeht.
Was nimmst du mit?
Eine gute Metrik ist kein Dekorationselement am Ende, sondern Teil der fachlichen Verantwortung deines Modells.