Scikit-learn Kreuzvalidierung

Einführung

Im maschinellen Lernen teilen wir unsere Daten oft in einen Trainingsdatensatz und einen Testdatensatz auf, um die Leistung eines Modells zu bewerten. Diese Bewertung kann jedoch stark davon abhängen, welche Datenpunkte im Trainingsdatensatz und welche im Testdatensatz landen. Eine robustere Methode ist die Kreuzvalidierung (Cross-Validation, CV).

Warum Kreuzvalidierung?

• Reduziert das Risiko von Overfitting: Testet das Modell auf mehreren Datenaufteilungen
• Bessere Generalisierungsschätzung: Zuverlässigere Leistung auf ungesehenen Daten
• Maximiert die Datennutzung: Jede Stichprobe wird sowohl für das Training als auch für das Testen verwendet

Bei der Kreuzvalidierung wird der Datensatz in mehrere "Folds" (Teile) aufgeteilt und das Modell dann mehrmals trainiert und bewertet, wobei jedes Mal ein anderer Fold zum Testen verwendet wird. Dies liefert uns eine zuverlässigere Schätzung der Modellleistung auf ungesehenen Daten.

In diesem Lab lernen Sie, wie Sie die leistungsstarken und praktischen Funktionen von scikit-learn verwenden, um eine Kreuzvalidierung auf einem Klassifikator mit dem berühmten Iris-Datensatz durchzuführen. Sie lernen, cross_val_score zu verwenden, um Leistungswerte zu erhalten, und dann deren Mittelwert und Standardabweichung zu berechnen, um die Stabilität und die Gesamtgenauigkeit des Modells besser zu verstehen.

Importiere cross_val_score aus sklearn.model_selection

In diesem Schritt importieren Sie zunächst die notwendige Funktion für die Durchführung der Kreuzvalidierung. Die Funktion cross_val_score ist das primäre Werkzeug in scikit-learn für diesen Zweck. Sie vereinfacht den Prozess des Aufteilens von Daten, des Trainierens des Modells und des Bewertens über mehrere Folds hinweg.

Öffnen Sie zuerst die Datei main.py im Verzeichnis ~/project über den Dateiexplorer auf der linken Seite Ihrer IDE.

Fügen Sie nun die Importanweisung für cross_val_score zu Ihrem main.py-Skript hinzu. Platzieren Sie sie zusammen mit den anderen Imports am Anfang der Datei.

from sklearn.model_selection import cross_val_score

Ihre Datei main.py sollte nun wie folgt aussehen:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Laden des Iris-Datensatzes
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialisieren eines Support Vector Classifier (SVC)
## Erklärte Parameter:
## - kernel='linear': Verwendet einen linearen Kernel für linear trennbare Daten wie Iris
## - C=1: Regularisierungsparameter (höhere Werte = weniger Regularisierung)
## - random_state=42: Stellt reproduzierbare Ergebnisse über mehrere Ausführungen sicher
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Ihr Code wird unterhalb dieser Zeile eingefügt ---

Sie können das Skript ausführen, um sicherzustellen, dass keine Syntaxfehler vorliegen. Öffnen Sie ein Terminal in Ihrer IDE und führen Sie den folgenden Befehl aus:

python3 main.py

Sie sollten keine Ausgabe sehen, was erwartet wird, da wir noch keinen Code hinzugefügt haben, der eine Ausgabe erzeugt.

Initialisiere KFold mit n_splits=5 aus sklearn.model_selection

Während cross_val_score das Aufteilen von Daten automatisch handhaben kann, ist es gute Praxis, den zugrunde liegenden Mechanismus zu verstehen. Die gängigste Kreuzvalidierungsstrategie ist K-Fold, bei der der Datensatz in 'k' Folds aufgeteilt wird. Das Modell wird auf k-1 Folds trainiert und auf dem verbleibenden Fold getestet, wobei dieser Vorgang k Mal wiederholt wird.

KFold-Parameter:

• n_splits=5: Teilt die Daten in 5 gleiche Teile (Folds) auf
• shuffle=False (Standard): Behält die ursprüngliche Datenreihenfolge bei
• random_state: Steuert die Randomisierung, wenn shuffle=True gesetzt ist

Die Klasse KFold in scikit-learn ist ein Kreuzvalidierungs-Iterator, der Trainings-/Testindizes zur Aufteilung von Daten bereitstellt. Obwohl wir im nächsten Schritt eine einfachere Abkürzung verwenden werden, ist das Verständnis von KFold grundlegend.

Lassen Sie uns KFold importieren und sehen, wie man es initialisiert. Fügen Sie die folgenden Zeilen zu Ihrer main.py-Datei hinzu.

Fügen Sie zuerst die Importanweisung am Anfang hinzu:

from sklearn.model_selection import KFold

Dann können Sie es initialisieren. Für dieses Lab werden wir uns jedoch auf den cv-Parameter von cross_val_score verlassen, was ein direkterer Ansatz ist. Der Zweck dieses Schritts ist es, Sie mit dem KFold-Konzept vertraut zu machen. Der Einfachheit halber und um dem Ablauf des Labs zu folgen, werden wir den Initialisierungscode für KFold nicht zu unserem Skript hinzufügen. Wir werden im nächsten Schritt direkt cv=5 verwenden, was intern eine K-Fold-Strategie nutzt. Dies ist die gängigste und direkteste Methode zur Durchführung der Kreuzvalidierung.

Fahren wir mit dem nächsten Schritt fort, in dem wir dieses Konzept in der Praxis anwenden werden. Da in diesem Schritt kein Code hinzugefügt wurde, können Sie auf "Continue" klicken, um fortzufahren.

Führe Kreuzvalidierung mit cross_val_score(clf, X, y, cv=5) durch

Nun ist es an der Zeit, die Kreuzvalidierung durchzuführen. Wir werden die zuvor importierte Funktion cross_val_score verwenden. Diese Funktion nimmt mehrere Argumente entgegen:

cross_val_score-Parameter:

• estimator: Das zu bewertende Modell (unser clf-Klassifikator)
• X: Die Feature-Datenmatrix
• y: Das Array der Ziel-Labels
• cv=5: Kreuzvalidierungsstrategie (Integer = k-fold, oder CV-Splitter-Objekt)
• scoring: Bewertungsmetrik (Standard verwendet die Score-Methode des Schätzers)
• n_jobs: Anzahl der zu verwendenden CPU-Kerne (Standard=1, -1 für alle Kerne)

Durch Setzen von cv=5 weisen wir scikit-learn an, eine 5-fache Kreuzvalidierung durchzuführen. Es teilt die Daten automatisch in 5 Folds auf, trainiert und testet das Modell dann 5 Mal und gibt ein Array zurück, das den Score für jeden Durchlauf enthält.

Fügen Sie den folgenden Code am Ende Ihrer main.py-Datei hinzu, unterhalb der Kommentarzeile:

## Durchführung einer 5-fachen Kreuzvalidierung
scores = cross_val_score(clf, X, y, cv=5)

## Ausgabe des Scores-Arrays
print("Scores:", scores)

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

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Laden des Iris-Datensatzes
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialisieren eines Support Vector Classifier (SVC)
## Erklärte Parameter:
## - kernel='linear': Verwendet einen linearen Kernel für linear trennbare Daten wie Iris
## - C=1: Regularisierungsparameter (höhere Werte = weniger Regularisierung)
## - random_state=42: Stellt reproduzierbare Ergebnisse über mehrere Ausführungen sicher
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Ihr Code wird unterhalb dieser Zeile eingefügt ---

## Durchführung einer 5-fachen Kreuzvalidierung
scores = cross_val_score(clf, X, y, cv=5)

## Ausgabe des Scores-Arrays
print("Scores:", scores)

Führen Sie nun das Skript in Ihrem Terminal aus:

python3 main.py

Sie sehen die Ausgabe, die ein Array von 5 Scores anzeigt, einen für jeden Fold der Kreuzvalidierung.

Scores: [0.96666667 1.         0.96666667 0.96666667 1.        ]
Mean score: 0.9800000000000001
Standard deviation: 0.016329931618554516

Ihre Scores können je nach exakter Aufteilung leicht abweichen, sollten aber ähnlich sein. Dieses Array gibt Ihnen einen detaillierten Einblick, wie das Modell auf verschiedenen Teilmengen der Daten abgeschnitten hat.

Berechne den mittleren CV-Score mit scores.mean()

Ein Array von Scores ist informativ, aber für eine schnelle Zusammenfassung der Modellleistung berechnen wir normalerweise den Mittelwert dieser Scores. Dieser einzelne Wert gibt uns eine allgemeine Vorstellung von der Genauigkeit des Modells.

Die Funktion cross_val_score gibt ein NumPy-Array zurück, das viele nützliche Methoden enthält, einschließlich .mean(). Wir können diese Methode direkt auf unserer scores-Variable aufrufen.

Fügen Sie die folgenden Zeilen am Ende Ihres main.py-Skripts hinzu, um den mittleren Score zu berechnen und auszugeben:

## Berechnung und Ausgabe des Mittelwerts der Scores
mean_score = scores.mean()
print("Mean score:", mean_score)

Ihre main.py-Datei sollte nun den folgenden Code enthalten:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Laden des Iris-Datensatzes
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialisieren eines Support Vector Classifier (SVC)
## Erklärte Parameter:
## - kernel='linear': Verwendet einen linearen Kernel für linear trennbare Daten wie Iris
## - C=1: Regularisierungsparameter (höhere Werte = weniger Regularisierung)
## - random_state=42: Stellt reproduzierbare Ergebnisse über mehrere Ausführungen sicher
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Ihr Code wird unterhalb dieser Zeile eingefügt ---

## Durchführung einer 5-fachen Kreuzvalidierung
scores = cross_val_score(clf, X, y, cv=5)

## Ausgabe des Scores-Arrays
print("Scores:", scores)

## Berechnung und Ausgabe des Mittelwerts der Scores
mean_score = scores.mean()
print("Mean score:", mean_score)

Führen Sie das Skript erneut aus:

python3 main.py

Die Ausgabe enthält nun den Mittelwert der 5 Scores, was Ihnen eine einzelne, repräsentative Leistungsmetrik liefert.

Scores: [0.96666667 1.         0.96666667 0.96666667 1.        ]
Mean score: 0.9800000000000001

Berechne die Standardabweichung der CV-Scores mit scores.std()

Der mittlere Score gibt uns die durchschnittliche Leistung an, aber er sagt uns nichts über die Konsistenz dieser Leistung. Die Standardabweichung der Scores liefert uns ein Maß für diese Varianz.

Interpretation der Standardabweichung:

• Niedrige Standardabweichung (< 0.05): Das Modell zeigt eine konsistente Leistung über alle Datenteilmengen.
• Mittlere Standardabweichung (0.05-0.15): Moderate Variation, für die meisten Fälle akzeptabel.
• Hohe Standardabweichung (> 0.15): Große Leistungsschwankungen, kann auf Datenprobleme oder Modellinstabilität hinweisen.

Eine niedrige Standardabweichung bedeutet, dass die Leistung des Modells über verschiedene Teildatensätze hinweg stabil ist, während eine hohe Standardabweichung darauf hindeutet, dass die Leistung stärker variiert.

Genau wie .mean() verfügt auch das NumPy-Array über eine .std()-Methode zur Berechnung der Standardabweichung.

Fügen Sie den letzten Code-Schnipsel zu Ihrem main.py-Skript hinzu, um die Standardabweichung zu berechnen und auszugeben:

## Berechnung und Ausgabe der Standardabweichung der Scores
std_dev = scores.std()
print("Standard deviation:", std_dev)

Ihr finales main.py-Skript ist nun vollständig und sollte wie folgt aussehen:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Laden des Iris-Datensatzes
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialisieren eines Support Vector Classifier (SVC)
## Erklärte Parameter:
## - kernel='linear': Verwendet einen linearen Kernel für linear trennbare Daten wie Iris
## - C=1: Regularisierungsparameter (höhere Werte = weniger Regularisierung)
## - random_state=42: Stellt reproduzierbare Ergebnisse über mehrere Ausführungen sicher
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Ihr Code wird unterhalb dieser Zeile eingefügt ---

## Durchführung einer 5-fachen Kreuzvalidierung
scores = cross_val_score(clf, X, y, cv=5)

## Ausgabe des Scores-Arrays
print("Scores:", scores)

## Berechnung und Ausgabe des Mittelwerts der Scores
mean_score = scores.mean()
print("Mean score:", mean_score)

## Berechnung und Ausgabe der Standardabweichung der Scores
std_dev = scores.std()
print("Standard deviation:", std_dev)

Führen Sie das Skript ein letztes Mal aus:

python3 main.py

Die endgültige Ausgabe zeigt das Array der Scores, ihren Mittelwert und ihre Standardabweichung an, was Ihnen eine umfassende Bewertung der Modellleistung liefert.

Scores: [0.96666667 1.         0.96666667 0.96666667 1.        ]
Mean score: 0.9800000000000001
Standard deviation: 0.016329931618554516

Zusammenfassung

Herzlichen Glückwunsch zum Abschluss dieses Labs! Sie haben erfolgreich gelernt, wie man eine k-fache Kreuzvalidierung mit scikit-learn durchführt und interpretiert.

In diesem Lab haben Sie:

• Die Bedeutung der Kreuzvalidierung für eine robuste Modellbewertung verstanden.
• Die Funktion cross_val_score verwendet, um einfach eine 5-fache Kreuzvalidierung für einen Support Vector Classifier durchzuführen.
• Die Ergebnisse analysiert, indem der Mittelwert und die Standardabweichung der Kreuzvalidierungsergebnisse berechnet und ausgegeben wurden.

Praktische Tipps für die Kreuzvalidierung:

• Verwenden Sie in den meisten Szenarien eine 5-fache oder 10-fache Kreuzvalidierung (CV).
• Ziehen Sie eine stratifizierte Kreuzvalidierung (stratified CV) für unausgeglichene Datensätze in Betracht.
• Verwenden Sie cross_validate anstelle von cross_val_score für mehrere Metriken.
• Setzen Sie immer random_state für reproduzierbare Ergebnisse.

Diese Technik ist ein grundlegender Bestandteil des Machine-Learning-Workflows und stellt sicher, dass die Leistung Ihres Modells zuverlässig ist und nicht nur das Ergebnis einer glücklichen Trainings-Test-Aufteilung. Sie können dieses Wissen nun anwenden, um Ihre eigenen Machine-Learning-Modelle mit größerer Zuversicht zu bewerten.