Es gibt zwei Hauptursachen für Fehler in Machine-Learning-Modellen:
- Bias beschreibt ein Modell, das vereinfachende Annahmen trifft, damit sich die Zielfunktion leichter approximieren lässt; ein Modell könnte zum Beispiel „lernen“, dass jeder 1,75 m große Mann weltweit Größe M trägt – klar voreingenommen.
- Varianz beschreibt die Streuung in der Modellvorhersage; also, wie stark sich die Vorhersage ändert, wenn wir die Trainingsdaten austauschen.
Um genauere Ergebnisse zu erzielen, wollen wir Bias und Varianz im Modell verringern. Das ist nicht trivial. Bias und Varianz stehen sich entgegen – reduzierst du das eine, steigt das andere. Dieses Spannungsfeld nennt man den Bias-Varianz-Trade-off.
In diesem Artikel lernst du:
- Wie du erkennst, ob ein Modell unter hohem Bias oder hoher Varianz leidet
- Wie du ein Modell mit diesen Symptomen diagnostizierst
- Wie du ein Modell mit gutem Fit aufbaust
Bevor wir die Fehlersymptome erkennen, tauchen wir tiefer in den Bias-Varianz-Trade-off ein.
Ein Blick auf den Bias-Varianz-Trade-off
Alle überwachenden Lernalgorithmen verfolgen dasselbe Ziel: die Abbildungsfunktion (f_hat) für eine Zielvariable (y) gegeben einiger Eingabedaten (X) zu schätzen. Die Funktion, die ein Machine-Learning-Modell zu approximieren versucht, nennen wir die Zielfunktion.
Wenn wir die Eingabedaten ändern, mit denen die Zielvariable approximiert wird, resultiert wahrscheinlich eine andere Zielfunktion, was die vom Modell vorhergesagten Ausgaben beeinflussen kann. Wie stark unsere Zielfunktion variiert, wenn sich die Trainingsdaten ändern, nennt man Varianz. Ein Modell mit hoher Varianz wollen wir vermeiden, denn es kann im Training glänzen, scheitert aber beim Generalisieren auf unbekannte Fälle.
In der Abbildung oben ist die approximierte Zielfunktion grün, die Regressionsgerade schwarz. Man sieht, wie gut das Modell mit der grünen Linie die Trainingsdaten „lernt“. Es versucht, alle roten und blauen Beobachtungen zu trennen. Würden wir dieses Modell mit neuen Beobachtungen trainieren, würde es eine völlig neue Zielfunktion lernen und ein ähnliches Verhalten zeigen.
Betrachte nun ein lineares Verfahren wie lineare Regression zur Approximation der Zielfunktion. Wichtig dabei: Lineare Regression unterstellt einen linearen Zusammenhang zwischen Eingabedaten und Zielvariable. Die Realität ist oft komplexer. Diese einfache Annahme macht die Zielfunktion jedoch schneller lernbar und leichter interpretierbar – auf Kosten von Flexibilität. Dieses Paradigma nennen wir Bias.
In der Abbildung oben stellt die rote Linie die gelernte Zielfunktion dar. Viele Beobachtungen weichen stark von den vom Modell vorhergesagten Werten ab.
Wir können den Bias eines Modells reduzieren, indem wir es flexibler machen – das erhöht jedoch die Varianz. Umgekehrt lässt sich die Varianz senken, indem wir das Modell vereinfachen – dadurch steigt der Bias. Aus diesem Verhältnis gibt es kein Entkommen. Am besten wählst und konfigurierst du ein Modell so, dass es die richtige Balance zwischen Bias und Varianz trifft.
Durch unbekannte Einflüsse auf die Zielfunktion wird es immer einen gewissen Fehler geben – den irreduziblen Fehler. In der Grafik erkennst du ihn am Fehler unterhalb des Minimums der Total-Error-Kurve. Um das ideale Modell zu bauen, müssen wir eine Balance zwischen Bias und Varianz finden, sodass der Gesamtfehler minimiert wird. Das zeigt die gestrichelte Linie „Optimum Model Complexity“.
Vertiefen wir Bias und Varianz jetzt mit Lernkurven.
Die Anatomie einer Lernkurve
Lernkurven zeigen die Modellleistung in Abhängigkeit von der Größe des Trainingsdatensatzes. Alternativ können sie die Leistung über einen definierten Zeitraum abbilden. Typischerweise nutzen wir sie, um Algorithmen zu diagnostizieren, die inkrementell aus Daten lernen. Dazu wird das Modell auf Trainings- und Validierungsdaten ausgewertet und die gemessene Performance geplottet.
Stell dir vor, wir modellieren den Zusammenhang zwischen Eingaben und Ausgaben mit einem Machine-Learning-Algorithmus. Wir starten, indem wir das Modell mit einer einzigen Instanz trainieren und gegen hundert Instanzen validieren. Was passiert wohl? Richtig: Das Modell lernt die eine Trainingsinstanz perfekt – es gäbe keine Fehler.
Eine einzelne Zuordnung von Input zu Output zu „merken“ ist leicht. Schwierig wird es, bei neuen, unbekannten Fällen genaue Vorhersagen zu treffen. Weil unser Modell die Trainingsdaten zu gut gelernt hat, wird es bei der Generalisierung auf unbekannte Daten versagen. Entsprechend schneidet es auf den Validierungsdaten schlecht ab. Es entsteht also eine große Lücke zwischen der Performance auf Trainings- und Validierungsdaten. Diese Differenz nennen wir den Generalization Error.
Damit unser Algorithmus auf den Validierungsdaten bessere Vorhersagen trifft, brauchen wir mehr Daten. Neue Instanzen im Training verändern zwangsläufig die Zielfunktion unseres Modells. Wie sich die Leistung beim Wachsen des Trainingsdatensatzes entwickelt, lässt sich überwachen und als Verlauf der Trainings- und Validierungsfehler darstellen.
Die Grafik zeigt folglich zwei Verläufe:
- Training Curve: Die aus den Trainingsdaten berechnete Kurve; sie zeigt, wie gut das Modell lernt.
- Validation Curve: Die aus den Validierungsdaten berechnete Kurve; sie zeigt, wie gut das Modell auf unbekannte Fälle generalisiert.
Diese Kurven zeigen, wie sich die Modellleistung mit wachsender Datenmenge entwickelt – daher der Name Lernkurven.
Hinweis: Dasselbe Verfahren lässt sich auch nutzen, um zu sehen, wie ein Modell über die Zeit lernt. Statt die Leistung mit wachsender Datenmenge zu verfolgen, beobachten wir den Lernfortschritt über die Zeit. Beispiel: Du lernst eine neue Sprache. Dein Fortschritt ließe sich wöchentlich bewerten und numerisch festhalten – etwa über 52 Wochen.
Du kennst jetzt die Anatomie einer Lernkurve. Setzen wir das mit einem Datensatz aus der Praxis um, um ein Gefühl dafür zu bekommen.
Use Case: Immobilienbewertungen vorhersagen
Wir verwenden den Datensatz: Market Historical Data Set of Real Estate Valuation. Die Daten stammen aus dem Bezirk Sindian, Neu-Taipeh, Taiwan, und enthalten historische Marktdaten.
Unsere Aufgabe ist es, die Immobilienbewertung anhand der folgenden Merkmale vorherzusagen:
- X1 = Transaktionsdatum (zum Beispiel 2013.250 = März 2013, 2013.500 = Juni 2013, usw.)
- X2 = Alter des Hauses (Einheit: Jahre)
- X3 = Entfernung zur nächsten MRT-Station (Einheit: Meter)
- X4 = Anzahl der fußläufig erreichbaren Convenience Stores im Wohnumfeld (Ganzzahl)
- X5 = Geografische Koordinate, Breite (Einheit: Grad)
- X6 = Geografische Koordinate, Länge (Einheit: Grad)
Die Zielvariable ist definiert als:
- Y = Hauspreis pro Flächeneinheit (10.000 Neue Taiwan-Dollar/Ping; Ping ist eine lokale Einheit, 1 Ping = 3,3 Quadratmeter)
Da die Zielgröße stetig ist, handelt es sich um ein Regressionsproblem.
Werfen wir zunächst einen Blick auf die Daten:
import pandas as pd
data = pd.read_excel("/content/gdrive/MyDrive/real_estate_valuation_data.xlsx")
print(data.info())
data.head()
>>>>
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 414 entries, 0 to 413
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 No 414 non-null int64
1 X1 transaction date 414 non-null float64
2 X2 house age 414 non-null float64
3 X3 distance to the nearest MRT station 414 non-null float64
4 X4 number of convenience stores 414 non-null int64
5 X5 latitude 414 non-null float64
6 X6 longitude 414 non-null float64
7 Y house price of unit area 414 non-null float64
dtypes: float64(6), int64(2)
memory usage: 26.0 KB
None
No X1 transaction date X2 house age X3 distance to the nearest MRT station X4 number of convenience stores X5 latitude X6 longitude Y house price of unit area
0 1 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 3 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 4 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 5 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Es gibt ein zusätzliches Merkmal namens No, das in der Dokumentation nicht erwähnt wird. Möglich, dass es sich um einen Index handelt. Der Einfachheit halber entfernen wir es. Außerdem entsprechen die Spaltennamen nicht der Dokumentation, daher bereinigen wir sie.
# rename the columns
renamed_columns = [col.split()[0] for col in data.columns]
renamed_columns_map = {data.columns[i]:renamed_columns[i] for i in range(len(data.columns))}
data.rename(renamed_columns_map, axis=1, inplace=True)
# remove No column
data.drop("No", axis=1, inplace=True)
print(data.head())
# separate features and target data
features, target = data.columns[:-1], data.columns[-1]
X = data[features]
y = data[target]
So sieht der finale Datensatz aus, bevor wir Features und Ziel trennen:
X1 X2 X3 X4 X5 X6 Y
0 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Um Bias, Varianz und einen guten Fit zu demonstrieren, bauen wir drei Modelle: einen Decision Tree Regressor, eine Support Vector Machine für Regression und einen Random Forest Regressor. Anschließend plotten wir für jedes Modell Lernkurven und zeigen Diagnose-Techniken.
Lernkurven diagnostizieren
Lernkurven interpretierst du anhand ihrer Form. Sobald Form und Dynamik klar sind, lassen sich daraus Probleme im Modellverhalten ableiten.
Die Funktion learning_curve() in Scikit-learn macht es einfach, Trainings- und Validierungsscores zu überwachen – genau das brauchen wir, um eine Lernkurve zu plotten.
Diese Parameter übergeben wir an learning_curve():
- estimator: Das Modell zur Approximation der Zielfunktion
- X: Die Eingabedaten
- y: Das Ziel
- cv: Die Cross-Validation-Strategie
- scoring: Die Metrik zur Leistungsbewertung des Modells
- train_sizes: Die absoluten Anzahlen an Trainingsbeispielen für die Lernkurve; unsere Werte sind willkürlich gewählt.
Modell 1: Decision Tree Regressor
Ein Modell mit hoher Varianz ist overfit. Es lernt Trainingsdaten und zufälliges Rauschen extrem gut, performt auf Trainingsdaten top, kann aber auf unbekannte Fälle nicht generalisieren. Das beobachten wir, wenn der Algorithmus für das Problem zu flexibel ist oder zu lange trainiert wurde.
Zum Beispiel ist der Decision Tree Regressor ein nichtlinearer Algorithmus. Nichtlineare Algorithmen haben typischerweise niedrigen Bias und hohe Varianz. Das heißt, Änderungen im Datensatz führen zu großen Änderungen der Zielfunktion.
So zeigen wir hohe Varianz mit unserem Decision Tree Regressor:
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
# overfitting
decision_tree = DecisionTreeRegressor()
train_sizes, train_scores, test_scores = learning_curve(
estimator=decision_tree,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 165, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Das Modell macht bei Trainingsinstanzen kaum Fehler, versagt aber bei neuen, unbekannten Instanzen. Du siehst das an der großen Generalisierungslücke zwischen Trainings- und Validierungskurve. Eine mögliche Verbesserung ist, mehr Trainingsdaten hinzuzunehmen, was Bias einführt. Alternativ kannst du das Modell regularisieren (z. B. die maximale Baumtiefe begrenzen), damit der Baum nicht bis zur vollen Tiefe wächst.
Modell 2: Support Vector Machine
Ein Modell mit hohem Bias ist underfit. Es trifft zu simple Annahmen über die Trainingsdaten und lernt die zugrunde liegenden Muster nicht. Das führt zu hohen Fehlern auf Trainings- und Validierungsdaten. Das beobachten wir, wenn das Modell für das Problem zu einfach ist oder nicht lange genug trainiert wurde.
Die Support Vector Machine ist beispielsweise ein linearer Algorithmus. Lineare Algorithmen haben meist hohen Bias und geringe Varianz. Das heißt, es werden stärkere Annahmen über die Form der Zielfunktion getroffen. Um in unserem Modell mehr Bias einzuführen, haben wir über den Parameter C eine Regularisierung gesetzt.
So zeigen wir hohen Bias mit unserer Support Vector Machine:
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
# Underfitting
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
svm = SVR(C=0.25)
train_sizes, train_scores, test_scores = learning_curve(
estimator=svm,
X=X_scaled,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Die Generalisierungslücke zwischen Trainings- und Validierungskurve wird mit wachsender Trainingsgröße sehr klein. Das zeigt: Noch mehr Beispiele werden die Leistung kaum verbessern. Abhilfe schaffen zusätzliche Features oder ein flexibleres Modell, um die Zahl der Annahmen zu verringern.
Modell 3: Random Forest Regressor
Ein gut passendes Modell liegt zwischen Underfitting und Overfitting. Es ist auf den Trainingsdaten nicht so stark wie das überangepasste Modell, macht aber bei unbekannten Instanzen deutlich weniger Fehler. Dieses Verhalten zeigt sich, wenn der Trainingsfehler ansteigt, aber auf einem stabilen Niveau bleibt, während der Validierungsfehler auf ein stabiles Minimum sinkt.
Zur Demonstration nutzen wir einen Random Forest, also ein Ensemble aus Decision Trees. Das Modell ist ebenfalls nichtlinear, erhält aber durch die Kombination mehrerer diverser Modelle und ihrer Vorhersagen zusätzlichen Bias.
Zusätzlich haben wir über max_depth = 3 stärker regularisiert, also die maximale Tiefe jedes Baums begrenzt.
So sieht das im Code aus:
from sklearn.ensemble import RandomForestRegressor
# better
random_forest = RandomForestRegressor(max_depth=3)
train_sizes, train_scores, test_scores = learning_curve(
estimator=random_forest,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Jetzt siehst du, dass wir den Fehler auf den Validierungsdaten reduziert haben. Das geht zulasten der Trainingsperformance, insgesamt ist das Modell aber besser.
Die Generalisierungslücke ist deutlich kleiner, es werden insgesamt wenig Fehler gemacht. Außerdem sind beide Kurven ab einer Trainingsgröße von etwa 250 stabil – zusätzliche Instanzen dürften das Modell also kaum noch verbessern.
Fazit: Das Verhalten eines Modells lässt sich mit Lernkurven gut beobachten. Ziel beim Aufbau von Machine-Learning-Modellen ist ein möglichst geringer Fehler. Zwei Treiber für hohe Fehler sind Bias und Varianz – wer hier die Balance trifft, baut leistungsfähigere Modelle.
