Richtige Modelltests: Trainings- und Testdaten sauber trennen

Wenn Sie Ihr erstes maschinelles Lernmodell trainiert und mit den gleichen Daten getestet haben, war das Ergebnis vermutlich beeindruckend. Doch in der Praxis versagt es dann oft kläglich. Der Grund? Ein häufiger Anfängerfehler, der als "Data Peeking" oder "Data Leakage" bekannt ist. Hier erfahren Sie, wie Sie es vermeiden und Ihre Modelle zuverlässig bewerten.

Warum das Testen auf denselben Daten scheitert

Stellen Sie sich vor, Sie erstellen eine Prüfung für Ihre Schüler, die Sie bereits in der letzten Woche als Hausaufgabe verteilt hatten. Die Antworten sind bekannt, und plötzlich erreichen alle 100 %. Doch was sagt das über ihr tatsächliches Wissen aus? Nichts. Genau das Gleiche passiert mit maschinellen Lernmodellen, die auf denselben Daten trainiert und getestet werden.

Ein Modell, das nur auswendig lernt statt Muster zu erkennen, wird in der Realität versagen. Die scheinbar hohe Genauigkeit ist eine Illusion – das Modell hat lediglich die Trainingsdaten memoriert. Nur durch einen sauberen Test auf unbekannten Daten lässt sich feststellen, ob es wirklich generalisieren kann.

Der erste Schritt: Die Aufteilung in Trainings- und Testdaten

Die Lösung ist einfach: Teilen Sie Ihre Daten vor dem Training in zwei separate Gruppen auf:

• Trainingsdatensatz: Hier lernt das Modell die Zusammenhänge.
• Testdatensatz: Diese Daten bleiben bis zur finalen Bewertung verschlossen und dienen ausschließlich der Überprüfung.

Einmal aufgeteilt, sollte der Testdatensatz nie wieder berührt werden – ähnlich einem versiegelten Umschlag, den Sie erst nach Abschluss der Modellentwicklung öffnen. In Python lässt sich dies mit der Bibliothek scikit-learn einfach umsetzen:

from sklearn.model_selection import train_test_split
import numpy as np

# Beispiel-Datensatz mit 1000 Einträgen und 5 Merkmalen
X = np.random.rand(1000, 5)
y = np.random.randint(0, 2, 1000)  # Binäre Zielvariable

# Aufteilung: 80 % Trainingsdaten, 20 % Testdaten
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,  # 20 % für den Test
    random_state=42  # Reproduzierbare Aufteilung
)

print(f"Trainingsgröße: {X_train.shape[0]} Einträge")  # 800
print(f"Testgröße: {X_test.shape[0]} Einträge")        # 200

Der Parameter random_state=42 stellt sicher, dass die Aufteilung bei jedem Durchlauf identisch bleibt. Ohne diese Festlegung würden die Ergebnisse bei jedem Lauf variieren, was Debugging und Vergleich erschwert.

Die optimale Aufteilungsgröße wählen

Die Frage nach dem idealen Verhältnis zwischen Trainings- und Testdaten hängt von der Datenmenge ab:

• Kleine Datensätze (unter 1.000 Einträge): 70 % Trainingsdaten, 30 % Testdaten.
• Große Datensätze (über 100.000 Einträge): 90 % Trainingsdaten, 10 % Testdaten reichen aus.

Bei zu kleinen Testdatensätzen wird die Bewertung unzuverlässig – Sie testen möglicherweise nur auf wenigen, untypischen Beispielen. Bei großen Datensätzen genügt ein kleinerer Testanteil, da die 10 % immer noch eine repräsentative Stichprobe darstellen.

Der unsichtbare Feind: Data Leakage

Ein häufiger und tückischer Fehler ist Data Leakage – das ungewollte Vermischen von Trainings- und Testdaten während der Vorverarbeitung. Selbst wenn die Aufteilung korrekt erfolgt, kann eine falsche Reihenfolge der Schritte die Ergebnisse verfälschen.

Typ 1: Direktes Trainieren auf allen Daten

Der offensichtlichste Fehler: Das Modell wird auf dem gesamten Datensatz trainiert und getestet. Das Ergebnis ist zwar perfekt, aber völlig bedeutungslos.

# FALSCH: Modell trainiert auf allen Daten
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X, y)  # X enthält alle Daten
score = model.score(X, y)  # Test auf denselben Daten
print(score)  # Hohe Genauigkeit – aber wertlos!

# RICHTIG: Separate Aufteilung nutzen
model.fit(X_train, y_train)
score = model.score(X_test, y_test)  # Test auf unbekannten Daten
print(score)  # Realistische Bewertung

Typ 2: Vorverarbeitung vor der Aufteilung

Noch heimtückischer ist die Skalierung der Daten vor der Aufteilung. Standardisierung oder Normalisierung sollten erst auf den Trainingsdaten erfolgen, nicht auf dem gesamten Datensatz.

from sklearn.preprocessing import StandardScaler

# FALSCH: Skalierung vor Aufteilung
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # Nutzt alle Daten für Mittelwert/Standardabweichung
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2)

# RICHTIG: Aufteilung zuerst, dann Skalierung
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # Nur Trainingsdaten nutzen
X_test_scaled = scaler.transform(X_test)        # Gleiche Skalierung auf Testdaten anwenden

Der Unterschied ist entscheidend: Im falschen Beispiel beeinflusst der Testdatensatz die Skalierung, was zu einer Verzerrung führt. Die Testdaten sind dann nicht mehr wirklich unbekannt.

Cross-Validation: Zuverlässigere Bewertung durch mehrfache Aufteilungen

Ein einzelner Train-Test-Split birgt selbst bei korrekter Anwendung Risiken – besonders bei kleinen Datensätzen. Wenn die zufällige Aufteilung unglücklich ausfällt, könnte der Testdatensatz untypische Beispiele enthalten, die das Ergebnis verfälschen.

Die Lösung ist Cross-Validation: Statt einer einmaligen Aufteilung wird der Datensatz in K Faltungen unterteilt. Das Modell wird K-mal trainiert und getestet, wobei jede Faltung einmal als Testmenge dient. Die finale Bewertung ist der Durchschnitt aller Durchläufe.

Ein Beispiel mit K=5 (5-fache Cross-Validation):

Faltung 1: [TEST ] [train] [train] [train] [train]
Faltung 2: [train] [TEST ] [train] [train] [train]
Faltung 3: [train] [train] [TEST ] [train] [train]
Faltung 4: [train] [train] [train] [TEST ] [train]
Faltung 5: [train] [train] [train] [train] [TEST ]

Jeder Eintrag wird genau einmal getestet, was eine robustere Bewertung ermöglicht. In Python lässt sich dies mit cross_val_score umsetzen:

from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

# Beispiel: Iris-Datensatz
iris = load_iris()
X, y = iris.data, iris.target

model = KNeighborsClassifier(n_neighbors=3)
# 5-fache Cross-Validation
scores = cross_val_score(model, X, y, cv=5)

print(f"Genauigkeit pro Faltung: {scores.round(3)}")
print(f"Durchschnittliche Genauigkeit: {scores.mean().round(3)}")

Cross-Validation liefert eine deutlich zuverlässigere Einschätzung der Modellleistung als ein einzelner Testlauf.

Fazit: Saubere Datenaufteilung als Grundpfeiler jedes ML-Projekts

Die Trennung von Trainings- und Testdaten ist kein optionaler Schritt, sondern eine unverzichtbare Praxis in der Entwicklung maschineller Lernmodelle. Data Leakage und unglückliche Aufteilungen können zu völlig verzerrten Ergebnissen führen – selbst wenn der Code korrekt aussieht.

Denken Sie daran:

• Teilen Sie Ihre Daten vor jeder Vorverarbeitung auf.
• Halten Sie den Testdatensatz bis zum finalen Test verschlossen.
• Nutzen Sie Cross-Validation für robustere Bewertungen.

Mit diesen Prinzipien stellen Sie sicher, dass Ihr Modell nicht nur auf Papier, sondern auch in der Praxis funktioniert. Der erste Schritt zu einem wirklich zuverlässigen KI-System beginnt mit der richtigen Datenaufteilung.