Scikit-learn Modellbewertung

Einführung

Nach dem Training eines Machine-Learning-Modells ist es entscheidend, seine Leistung zu bewerten, um zu verstehen, wie gut es auf neue, ungesehene Daten generalisiert. Scikit-learn, eine leistungsstarke Python-Bibliothek für maschinelles Lernen, bietet in seinem Modul sklearn.metrics eine umfassende Sammlung von Werkzeugen zur Modellbewertung.

In diesem Lab lernen Sie, wie Sie ein Klassifikationsmodell anhand einiger der gängigsten Metriken bewerten. Wir verwenden einen vordefinierten Satz von wahren Labels und vorhergesagten Labels, um uns ausschließlich auf den Bewertungsprozess zu konzentrieren. Sie lernen, Folgendes zu berechnen:

• Genauigkeitswert (Accuracy Score)
• Konfusionsmatrix (Confusion Matrix)
• Präzisionswert (Precision Score)
• Rückruf-Wert (Recall Score)
• F1-Wert (F1 Score)

Am Ende dieses Labs werden Sie mit diesen grundlegenden Scikit-learn-Funktionen vertraut sein, um die Leistung Ihrer Klassifikationsmodelle zu beurteilen.

Berechnung des Accuracy Scores mit accuracy_score aus sklearn.metrics

In diesem Schritt berechnen wir die Genauigkeit der Vorhersagen unseres Modells. Die Genauigkeit (Accuracy) ist eine der einfachsten Klassifikationsmetriken. Sie misst das Verhältnis der korrekt vorhergesagten Instanzen zur Gesamtzahl der Instanzen.

Die Funktion accuracy_score aus sklearn.metrics berechnet diesen Wert. Sie nimmt die wahren Labels und die vorhergesagten Labels als Argumente entgegen.

Öffnen Sie zunächst die Datei evaluate.py im Dateiexplorer auf der linken Seite. Die Datei enthält bereits die Listen y_true und y_pred. Fügen Sie nun den folgenden Code am Ende der Datei hinzu, um die Funktion accuracy_score zu importieren, die Genauigkeit zu berechnen und das Ergebnis auszugeben.

from sklearn.metrics import accuracy_score

## Genauigkeit berechnen
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Ihre vollständige Datei evaluate.py sollte nun wie folgt aussehen:

## In diesem Lab verwenden wir einen vordefinierten Satz von wahren Labels und vorhergesagten Labels,
## um verschiedene Bewertungsmetriken zu verstehen.

## y_true repräsentiert die tatsächlichen, Ground-Truth-Labels für unsere Datenpunkte.
## Bei einer binären Klassifizierung könnte 0 'negativ' und 1 'positiv' bedeuten.
y_true = [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]

## y_pred repräsentiert die von unserem hypothetischen Klassifikationsmodell vorhergesagten Labels.
y_pred = [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]

print("Setup abgeschlossen. Wahre und vorhergesagte Labels sind in evaluate.py definiert.")
print(f"Wahre Labels:    {y_true}")
print(f"Vorhergesagte Labels: {y_pred}")

from sklearn.metrics import accuracy_score

## Genauigkeit berechnen
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Lassen Sie uns nun das Skript ausführen. Öffnen Sie das Terminal in Ihrer IDE und führen Sie den folgenden Befehl aus:

python3 evaluate.py

Sie sollten die folgende Ausgabe sehen, die den Genauigkeitswert enthält. Eine Genauigkeit von 0,8 bedeutet, dass 80 % der Vorhersagen korrekt waren.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8

Erstellung der Konfusionsmatrix mit confusion_matrix aus sklearn.metrics

In diesem Schritt generieren wir eine Konfusionsmatrix (Confusion Matrix). Während die Genauigkeit (Accuracy) eine schnelle Zusammenfassung der Leistung liefert, kann sie irreführend sein, insbesondere bei unausgeglichenen Datensätzen. Eine Konfusionsmatrix bietet eine detailliertere Aufschlüsselung der Leistung eines Klassifikators, indem sie die Anzahl der korrekten und falschen Vorhersagen für jede Klasse anzeigt.

Die Matrix ist eine Tabelle mit vier Kombinationen von vorhergesagten und tatsächlichen Werten:

• True Negatives (TN): Das Modell hat die negative Klasse korrekt vorhergesagt.
• False Positives (FP): Das Modell hat fälschlicherweise die positive Klasse vorhergesagt.
• False Negatives (FN): Das Modell hat fälschlicherweise die negative Klasse vorhergesagt.
• True Positives (TP): Das Modell hat die positive Klasse korrekt vorhergesagt.

Wir verwenden die Funktion confusion_matrix aus sklearn.metrics. Fügen Sie den folgenden Code am Ende Ihrer Datei evaluate.py hinzu.

from sklearn.metrics import confusion_matrix

## Konfusionsmatrix generieren
cm = confusion_matrix(y_true, y_pred)

print("Confusion Matrix:")
print(cm)

Führen Sie das Skript nun erneut im Terminal aus:

python3 evaluate.py

Die Ausgabe enthält nun die Konfusionsmatrix.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]

Diese Matrix sagt uns:

• TN = 4 (Oben links)
• FP = 1 (Oben rechts)
• FN = 1 (Unten links)
• TP = 4 (Unten rechts)

Berechnung des Precision Scores mit precision_score aus sklearn.metrics

In diesem Schritt berechnen wir den Präzisionswert (Precision Score). Die Präzision beantwortet die Frage: "Von allen Instanzen, die das Modell als positiv vorhergesagt hat, welcher Anteil war tatsächlich positiv?" Sie ist ein Maß für die Exaktheit eines Klassifikators.

Die Präzision wird berechnet als: Precision = True Positives / (True Positives + False Positives)

Eine niedrige Präzision deutet auf eine hohe Anzahl von False Positives hin. Wir verwenden die Funktion precision_score aus sklearn.metrics.

Fügen Sie den folgenden Code am Ende Ihrer Datei evaluate.py hinzu, um die Präzision zu berechnen und auszugeben.

from sklearn.metrics import precision_score

## Präzision berechnen
precision = precision_score(y_true, y_pred)

print(f"Precision: {precision}")

Führen Sie das Skript im Terminal aus:

python3 evaluate.py

Sie sehen den Präzisionswert, der zur Ausgabe hinzugefügt wurde. Basierend auf unserer Konfusionsmatrix (TP=4, FP=1) beträgt die Präzision 4 / (4 + 1) = 0,8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8

Berechnung des Recall Scores mit recall_score aus sklearn.metrics

In diesem Schritt berechnen wir die Rückrufquote (Recall Score). Der Rückruf, auch bekannt als Sensitivität oder True Positive Rate, beantwortet die Frage: "Von allen tatsächlichen positiven Instanzen, welcher Anteil wurde vom Modell korrekt identifiziert?" Er ist ein Maß für die Vollständigkeit eines Klassifikators.

Der Rückruf wird berechnet als: Recall = True Positives / (True Positives + False Negatives)

Ein niedriger Rückruf deutet auf eine hohe Anzahl von False Negatives hin. Wir verwenden die Funktion recall_score aus sklearn.metrics.

Fügen Sie den folgenden Code am Ende Ihrer Datei evaluate.py hinzu.

from sklearn.metrics import recall_score

## Rückruf berechnen
recall = recall_score(y_true, y_pred)

print(f"Recall: {recall}")

Führen Sie das Skript im Terminal aus:

python3 evaluate.py

Die Ausgabe enthält nun die Rückrufquote. Basierend auf unserer Konfusionsmatrix (TP=4, FN=1) beträgt der Rückruf 4 / (4 + 1) = 0,8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8

Berechnung des F1-Scores mit f1_score aus sklearn.metrics

In diesem letzten Schritt berechnen wir den F1-Score. Der F1-Score ist der harmonische Mittelwert aus Präzision (Precision) und Rückruf (Recall). Er versucht, ein Gleichgewicht zwischen beiden zu finden. Während sich die Präzision auf die Minimierung von False Positives konzentriert und der Rückruf auf die Minimierung von False Negatives, liefert der F1-Score eine einzelne Metrik, die beide berücksichtigt.

Der F1-Score wird berechnet als: F1 Score = 2 * (Precision * Recall) / (Precision + Recall)

Er ist besonders nützlich, wenn Sie ein Gleichgewicht zwischen Präzision und Rückruf benötigen und wenn eine ungleiche Klassenverteilung vorliegt. Wir verwenden die Funktion f1_score aus sklearn.metrics.

Fügen Sie das letzte Code-Snippet zu Ihrer Datei evaluate.py hinzu.

from sklearn.metrics import f1_score

## F1-Score berechnen
f1 = f1_score(y_true, y_pred)

print(f"F1 Score: {f1}")

Führen Sie das Skript ein letztes Mal im Terminal aus:

python3 evaluate.py

Die endgültige Ausgabe zeigt alle von uns berechneten Metriken an. Bei einer Präzision und einem Rückruf von 0,8 wird auch der F1-Score 0,8 betragen.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8
F1 Score: 0.8

Zusammenfassung

Herzlichen Glückwunsch zum Abschluss des Labs! Sie haben erfolgreich gelernt, wie man ein Klassifikationsmodell mit verschiedenen Schlüsselmetriken aus der scikit-learn-Bibliothek evaluiert.

In diesem Lab haben Sie geübt:

• Die Genauigkeit (Accuracy) mit accuracy_score zu berechnen, um einen allgemeinen Eindruck von der Modellleistung zu erhalten.
• Eine Konfusionsmatrix (Confusion Matrix) mit confusion_matrix zu generieren, um eine detaillierte Ansicht von True/False Positives und Negatives zu erhalten.
• Die Präzision (Precision) mit precision_score zu berechnen, um die Exaktheit des Modells zu messen.
• Den Rückruf (Recall) mit recall_score zu berechnen, um die Vollständigkeit des Modells zu messen.
• Den F1-Score mit f1_score zu berechnen, um ein Gleichgewicht zwischen Präzision und Rückruf zu finden.

Diese Metriken sind grundlegende Werkzeuge für jeden Data Scientist oder Machine Learning Engineer. Ihr Verständnis ermöglicht es Ihnen, die Stärken und Schwächen Ihres Modells besser zu diagnostizieren und das richtige Modell für Ihr spezifisches Problem auszuwählen.