K-Fold-Kreuzvalidierung im Machine Learning

Ein Modell kann während des Trainings sehr genau wirken, bei unbekannten Testdaten jedoch deutlich an Genauigkeit verlieren. Diese Situation wird als Overfitting bezeichnet. Das bedeutet, dass sich das Modell zu stark an die Trainingsbeispiele angepasst hat. Underfitting beschreibt den umgekehrten Fall: Das Modell liefert selbst auf den Trainingsdaten schlechte Ergebnisse.

Cross-Validation hilft dabei einzuschätzen, ob ein Machine-Learning-Modell voraussichtlich zuverlässig auf neuen Daten funktioniert. Die Methode wird üblicherweise in mehreren Schritten durchgeführt:

Wie Cross-Validation funktioniert

• Fold-Erstellung: Der Datensatz wird in mehrere kleinere Gruppen aufgeteilt, die als Folds bezeichnet werden.
• Wiederholtes Training und Validieren: In jeder Runde wird das Modell auf einem Teil des Datensatzes trainiert, während ein Fold zur Validierung verwendet wird. Der Validierungs-Fold wechselt von Runde zu Runde.
• Berechnung des finalen Scores: Die Ergebnisse aller Validierungsrunden werden gemittelt, um eine stabilere Schätzung der Gesamtleistung des Modells zu erhalten.

Voraussetzungen

• Grundkenntnisse im Machine Learning – Verständnis für Modelltraining, Bewertungsmetriken und Overfitting.
• Python-Kenntnisse – Vertrautheit mit Python sowie Bibliotheken wie scikit-learn, numpy und pandas.
• Vorbereitung des Datensatzes – Ein bereinigter und vorverarbeiteter Datensatz, der für das Modelltraining bereit ist.
• Installiertes Scikit-Learn – Falls noch nicht vorhanden, lässt es sich mit pip install scikit-learn installieren.
• Verständnis von Leistungsmetriken – Kenntnisse über Accuracy, Precision, Recall, RMSE und ähnliche Kennzahlen – abhängig von der jeweiligen Aufgabe.

Gängige Cross-Validation-Methoden

• K-Fold Cross-Validation: Der Datensatz wird in k gleich große Abschnitte geteilt, und das Modell wird k-mal trainiert. In jedem Durchlauf dient ein anderer Fold als Validierungsmenge.
• Stratified K-Fold: Diese Variante sorgt bei Klassifikationsaufgaben dafür, dass in jedem Fold die gleichen Klassenverhältnisse erhalten bleiben. Das ist besonders hilfreich, wenn die Zielvariable unausgewogen ist, also kategoriale Klassen nicht gleichmäßig verteilt sind.
• Leave-One-Out (LOO): Hier wird jeweils nur eine einzelne Beobachtung zur Validierung verwendet, während alle übrigen Instanzen für das Training genutzt werden. Das wird für jede Beobachtung wiederholt.
• Time-Series Cross-Validation: Diese Methode ist für sequentielle Daten gedacht und stellt sicher, dass die Trainingsdaten zeitlich immer vor den Validierungsdaten liegen.

Cross-Validation ist hilfreich, um das beste Modell und passende Hyperparameter auszuwählen und gleichzeitig das Risiko von Overfitting zu verringern.

In diesem Leitfaden behandeln wir:

• Was K-Fold Cross-Validation ist
• Wie sie sich von einem klassischen Train-Test-Split unterscheidet
• Eine Schritt-für-Schritt-Implementierung mit scikit-learn
• Erweiterte Varianten wie Stratified K-Fold, Group K-Fold und Nested K-Fold
• Methoden zum Umgang mit unausgewogenen Datensätzen

Was ist K-Fold Cross-Validation?

K-Fold Cross-Validation ist ein Resampling-Verfahren zur Bewertung von Machine-Learning-Modellen, bei dem der Datensatz in K gleich große Folds unterteilt wird. Das Modell wird auf K-1 Folds trainiert und auf dem verbleibenden Fold validiert. Dieser Ablauf wird K-mal wiederholt, und der endgültige Leistungswert ergibt sich als Durchschnitt aller Durchläufe.

Warum K-Fold Cross-Validation verwenden?

• Im Gegensatz zu einem einzelnen Train-Test-Split verwendet K-Fold mehrere Aufteilungen und reduziert dadurch die Varianz der Leistungsschätzung. Dadurch kann das Modell unbekannte Daten besser vorhersagen.
• Jeder Datenpunkt wird in unterschiedlichen Durchläufen sowohl für das Training als auch für die Validierung verwendet. So wird der verfügbare Datensatz effizienter genutzt und die Bewertung aussagekräftiger.
• Da die Validierung mehrfach auf verschiedenen Datenabschnitten erfolgt, lassen sich Overfitting-Probleme leichter erkennen und verringern. So wird sichergestellt, dass das Modell allgemeine Muster lernt, statt Trainingsbeispiele auswendig zu lernen.
• Durch das Mitteln der Ergebnisse aus mehreren Folds liefert K-Fold Cross-Validation eine belastbarere Schätzung der tatsächlichen Modellleistung und reduziert sowohl Bias als auch Varianz.
• K-Fold Cross-Validation wird häufig zusammen mit Grid Search und Randomized Search eingesetzt, um Hyperparameter zu optimieren, ohne sich an nur einen einzelnen Train-Test-Split anzupassen.

K-Fold vs. Train-Test-Split

K-Fold Cross-Validation in Python umsetzen

Im Folgenden wenden wir K-Fold Cross-Validation mit scikit-learn an.

Schritt 1: Abhängigkeiten importieren

Zunächst importieren wir die benötigten Bibliotheken.

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import KFold, cross_val_score, train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn import linear_model, tree, ensemble

Schritt 2: Titanic-Datensatz laden und untersuchen

Für dieses Beispiel verwenden wir den Titanic-Datensatz, einen sehr bekannten Datensatz, mit dem sich die Funktionsweise der k-fold cross-validation gut nachvollziehen lässt.

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")
print(df.head(3))
print(df.info())

			

PassengerId  Survived  Pclass  \
0            1         0       3   
1            2         1       1   
2            3         1       3   

                                                Name     Sex   Age  SibSp  \
0                            Braund, Mr. Owen Harris    male  22.0      1   
1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   
2                             Heikkinen, Miss. Laina  female  26.0      0   

   Parch            Ticket     Fare Cabin Embarked  
0      0         A/5 21171   7.2500   NaN        S  
1      0          PC 17599  71.2833   C85        C  
2      0  STON/O2. 3101282   7.9250   NaN        S  
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB
None

Schritt 3: Datenvorverarbeitung

Als Nächstes ist es sinnvoll, vor dem Training eines Modells mit Datenvorverarbeitung und Feature Engineering zu beginnen.

df = df[['Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare']]  # Select relevant features
df.dropna(inplace=True)  # Remove missing values

# Encode categorical variable
label_encoder = LabelEncoder()
df['Sex'] = label_encoder.fit_transform(df['Sex'])

# Split features and target
X = df.drop(columns=['Survived'])
y = df['Survived']
df.shape
(714, 7)

Schritt 4: K-Fold-Aufteilung definieren

kf = KFold(n_splits=5, shuffle=True, random_state=42)

In diesem Beispiel bedeutet n_splits=5, dass der Datensatz in fünf Folds aufgeteilt wird. Der Parameter shuffle=True sorgt für eine zufällige Durchmischung.

Schritt 5: Modell trainieren und auswerten

model = RandomForestClassifier(n_estimators=100, random_state=42)
scores = cross_val_score(model, X, y, cv=kf, scoring='accuracy')
print(f'Cross-validation accuracy scores: {scores}')
print(f'Average Accuracy: {np.mean(scores):.4f}')

			

score = cross_val_score(tree.DecisionTreeClassifier(random_state= 42), X, y, cv= kf, scoring="accuracy")  
print(f'Scores for each fold are: {score}')  
print(f'Average score: {"{:.2f}".format(score.mean())}')

Erweiterte Cross-Validation-Techniken

1. Stratified K-Fold (für unausgewogene Datensätze)

Beim Arbeiten mit unausgewogenen Klassen stellt Stratified K-Fold sicher, dass jeder Fold dieselbe Klassenverteilung wie der vollständige Datensatz beibehält. Diese ausgewogene Verteilung macht die Methode zu einer starken Wahl für Klassifikationsprobleme mit ungleich verteilten Klassen.

from sklearn.model_selection import StratifiedKFold
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring='accuracy')
print(f'Average Accuracy (Stratified K-Fold): {np.mean(scores):.4f}')

Average Accuracy (Stratified K-Fold): 0.8124

2. Repeated K-Fold Cross-Validation

Repeated K-Fold führt K-Fold mehrmals mit unterschiedlichen Aufteilungen aus, um die Varianz weiter zu verringern. Diese Methode wird häufig verwendet, wenn der Datensatz eher einfach ist und Modelle wie die logistische Regression gut darauf angepasst werden können.

from sklearn.model_selection import RepeatedKFold
rkf = RepeatedKFold(n_splits=5, n_repeats=10, random_state=42)
scores = cross_val_score(model, X, y, cv=rkf, scoring='accuracy')
print(f'Average Accuracy (Repeated K-Fold): {np.mean(scores):.4f}')

Average Accuracy (Repeated K-Fold): 0.8011

3. Nested K-Fold Cross-Validation (für Hyperparameter-Tuning)

Nested K-Fold führt die Hyperparameter-Optimierung in einer inneren Schleife durch, während die Modellleistung in einer äußeren Schleife bewertet wird. So lässt sich Overfitting während des Tunings besser reduzieren.

from sklearn.model_selection import GridSearchCV, cross_val_score
param_grid = {'n_estimators': [50, 100, 150], 'max_depth': [None, 10, 20]}
gs = GridSearchCV(model, param_grid, cv=5)
scores = cross_val_score(gs, X, y, cv=5)
print(f'Average Accuracy (Nested K-Fold): {np.mean(scores):.4f}')

4. Group K-Fold (für nicht unabhängige Stichproben)

Wenn ein Datensatz Gruppen enthält, etwa mehrere Bilder desselben Patienten, sorgt Group K-Fold dafür, dass Stichproben derselben Gruppe nicht gleichzeitig in Training und Validierung auftauchen. Das ist besonders nützlich bei hierarchischen Datenstrukturen.

from sklearn.model_selection import GroupKFold
gkf = GroupKFold(n_splits=5)
groups = np.random.randint(0, 5, size=len(y))
scores = cross_val_score(model, X, y, cv=gkf, groups=groups, scoring='accuracy')
print(f'Average Accuracy (Group K-Fold): {np.mean(scores):.4f}')

FAQs

Wie führt man K-Fold Cross-Validation in Python aus?

Verwenden Sie cross_val_score() aus scikit-learn und übergeben Sie KFold als Wert für den Parameter cv.

Was ist der Unterschied zwischen K-Fold und Stratified K-Fold?

K-Fold teilt die Daten zufällig auf, während Stratified K-Fold dafür sorgt, dass die Klassenverhältnisse in jedem Fold konsistent bleiben.

Wie wähle ich die richtige Anzahl an Folds?

• 5-Fold oder 10-Fold ist in den meisten Fällen der übliche Standard.
• Eine höhere Anzahl an Folds, zum Beispiel 20, kann den Bias reduzieren, erhöht aber auch den Rechenaufwand.

Was macht die KFold-Klasse in Python?

Sie teilt den Datensatz in n_splits Folds auf, damit Training und Validierung wiederholt durchgeführt werden können.

Fazit

Damit ein Machine-Learning-Modell auch auf unbekannten Daten zuverlässig funktioniert, ist Cross-Validation ein unverzichtbarer Schritt. K-Fold Cross-Validation gehört zu den wirkungsvollsten Verfahren, um zu verhindern, dass sich das Modell zu stark an die Trainingsdaten anpasst, und gleichzeitig die Balance zwischen Bias und Varianz zu erhalten. Durch die Aufteilung des Datensatzes in mehrere Folds und das iterative Trainieren und Validieren in jeder Runde entsteht eine bessere Einschätzung darüber, wie sich das Modell bei unbekannten Daten verhalten wird.

In Python lässt sich K-Fold Cross-Validation mit Bibliotheken wie scikit-learn einfach umsetzen. Dort stehen Werkzeuge wie KFold und StratifiedKFold zur Verfügung, um auch mit unausgewogenen Datensätzen umzugehen. Wenn Sie K-Fold Cross-Validation in Ihren Workflow integrieren, können Sie Hyperparameter gezielter abstimmen, Modelle verlässlicher vergleichen und die Generalisierungsfähigkeit für reale Anwendungen verbessern.

Ganz gleich, ob Sie Regressions-, Klassifikations- oder Deep-Learning-Modelle entwickeln – dieser Validierungsansatz ist ein zentraler Bestandteil moderner Machine-Learning-Pipelines.