Du lernst, warum Modelle zu viele Details auswendig lernen, was harte und weiche Schranken unterscheiden, wann Ridge oder Lasso sinnvoll sind, wie Elastic Net beide Ideen mischt und wie du Alpha mit Grid Search statt per Bauchgefühl findest.
Ein Modell ohne Bremse kann Trainingsdaten perfekt treffen und auf neuen Daten trotzdem scheitern.
Stell dir ein riesiges Buffet vor. Jemand lädt sich von allem etwas auf den Teller, auch von den exotischen Gerichten, die zufällig nur heute da sind. Beim nächsten Restaurantbesuch sucht er genau diese Spezialitäten wieder und ist enttäuscht, weil sie gar nicht da sind.
Ein überangepasstes Modell macht etwas Ähnliches: Es lernt jeden kleinen Zufall aus den Trainingsdaten mit. Auf neuen Daten fehlt dann die Orientierung.
Overfitting bedeutet: Trainingsfehler sehr klein, Testfehler deutlich größer. Das Modell hat Details statt Muster gelernt.
fügt eine Strafe für zu große Koeffizienten hinzu. Dadurch wird das Modell gezwungen, ruhiger und robuster zu bleiben.
MSE = Bias² + Varianz + Noise. Regularisierung zielt vor allem auf die Varianz, weil sie zu nervöse Modelle dämpft.Was nimmst du mit?
Ein Modell ist nicht gut, weil es alte Daten perfekt auswendig kann. Es ist gut, wenn es auf neue Fälle stabil bleibt.
Harte Schranken begrenzen direkt, wie groß die Koeffizienten zusammen werden dürfen.
Beim Wocheneinkauf hilft ein klares Budget. Du darfst kaufen, was du willst, aber die Summe aller Produkte muss unter deiner Grenze bleiben. Irgendwann ist Schluss.
Genau so kannst du auch ein Modell behandeln: Die Koeffizienten dürfen nicht beliebig groß werden. Das Budget heißt in der Theorie oft t.
Bei einer harten Schranke wird die Summe der Gewichte direkt begrenzt.
L1 nutzt Beträge: Σ |βⱼ| ≤ t. L2 nutzt Quadrate: Σ βⱼ² ≤ t. Das Quadrat heißt hier einfach: Koeffizient mal sich selbst. Große Gewichte werden dadurch viel stärker bestraft als kleine.
Die Form der erlaubten Region ist wichtig: Beim Diamanten von L1 liegen Ecken auf den Achsen. Dieser Diamant entsteht in zwei Dimensionen durch |β₁| + |β₂| ≤ t. Dort landen Lösungen leichter exakt auf null.
t ist dein Einkaufsbudget. Kleines t = strenge Diät. Großes t = fast freie Auswahl.t = 0 bleiben nur Koeffizienten von null. Große Budgets wirken fast wie unregularisierte Regression.Was nimmst du mit?
Eine harte Schranke ist wie ein Einkaufslimit: nicht jedes Gewicht darf wachsen, nur weil es gerade praktisch erscheint.
Statt einer harten Grenze kann das Modell große Koeffizienten noch wählen, muss dafür aber einen Preis zahlen.
Eine harte Schranke ist wie ein Fahrverbot: mehr als 50 km/h geht einfach nicht. Ein Strafterm ist weicher. Du darfst schneller fahren, aber mit jedem Kilometer wird der Strafzettel teurer.
Genau das macht im Modell. Große Koeffizienten sind nicht verboten, aber sie verteuern die Kostenfunktion.
Die Kostenfunktion wird erweitert: Fehlerterm plus Strafterm. Damit verschiebt sich das Gleichgewicht zwischen möglichst guter Anpassung und möglichst kleinen Gewichten.
Bei Alpha = 0 gibt es keine Strafe. Bei sehr großem Alpha werden große Gewichte unattraktiv.
Was nimmst du mit?
Regulierung mit Alpha ist kein harter Bann, sondern eine Preislogik. Große Gewichte sind möglich, aber nicht mehr gratis.
Ridge hält alle Koeffizienten klein, löscht aber keinen komplett aus dem Modell.
Beim Kochen willst du nicht alles Salz in eine einzige Prise packen. Du verteilst das Gewürzbudget lieber über mehrere Zutaten. So schmeckt das Gericht runder und hängt nicht an einem Extrem.
Ridge macht genau das mit den Modellgewichten. Jedes Feature darf bleiben, aber keines soll dominant werden.
verwendet die L2-Strafe. Große Koeffizienten werden teuer, aber die Lösung landet selten exakt auf null.
Besonders nützlich ist Ridge, wenn Features ähnlich oder korreliert sind. Dann verteilt das Modell Gewicht oft stabiler.
Fehler + Alpha × Σ βⱼ²Nutze ein bewusst einfaches Regressionsbeispiel und ergänze das Ridge-Modell. Danach schaust du dir an, wie stark der Koeffizient durch die Strafe geschrumpft wird.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.linear_model import Ridge
X = [[0.0], [1.0], [2.0], [3.0]]
y = [0.0, 1.0, 2.0, 3.0]
model = # ??? DEINE LÖSUNG ???
model.fit(X, y)
print(round(model.coef_[0], 3))Setze alpha=1.0 und fit_intercept=False, damit du den Schrumpf-Effekt klar siehst.
from sklearn.linear_model import Ridge
X = [[0.0], [1.0], [2.0], [3.0]]
y = [0.0, 1.0, 2.0, 3.0]
model = Ridge(alpha=1.0, fit_intercept=False)
model.fit(X, y)
print(round(model.coef_[0], 3))Erwartete Ausgabe: `0.933`
from sklearn.linear_model import Ridge
# Wir erzeugen ein Ridge-Modell mit moderater Strafe.
model = Ridge(alpha=1.0)
# Das Modell lernt die Gewichte aus den Trainingsdaten.
model.fit(X_train, y_train)
# Ridge schrumpft alle Koeffizienten,
# aber normalerweise wird keiner exakt null.
print(model.coef_)Was nimmst du mit?
Ridge ist kein Aufräumer, sondern ein Verteiler. Alles bleibt grundsätzlich im Team, aber niemand bekommt die ganze Bühne.
Lasso kann unwichtige Features komplett auf null setzen und damit automatisch aus dem Modell werfen.
Beim Ausmisten eines Kleiderschranks reicht es manchmal nicht, alles nur etwas kleiner zu falten. Manche Teile kommen konsequent weg, weil du sie nie trägst.
Lasso arbeitet ähnlich. Unwichtige Features werden nicht nur gedämpft, sondern bei genug Strafe ganz aus dem Modell entfernt.
nutzt die L1-Strafe: Fehler + Alpha × Σ |βⱼ|.
Weil die L1-Geometrie Ecken auf den Achsen hat, landet die Lösung leichter genau bei null. Deshalb ist Lasso gleichzeitig Regularisierung und Feature-Auswahl.
Ergänze das Lasso-Modell mit einem festen alpha und vergleiche den Koeffizienten mit Ridge. So siehst du direkt, wie eine L1-Strafe stärker auf Sparsamkeit drückt.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.linear_model import Lasso
X = [[0.0], [1.0], [2.0], [3.0]]
y = [0.0, 1.0, 2.0, 3.0]
model = # ??? DEINE LÖSUNG ???
model.fit(X, y)
print(round(model.coef_[0], 3))Nimm alpha=0.5, fit_intercept=False und setze ein höheres max_iter, damit die Lösung sicher konvergiert.
from sklearn.linear_model import Lasso
X = [[0.0], [1.0], [2.0], [3.0]]
y = [0.0, 1.0, 2.0, 3.0]
model = Lasso(alpha=0.5, fit_intercept=False, max_iter=10000)
model.fit(X, y)
print(round(model.coef_[0], 3))Erwartete Ausgabe: `0.857`
from sklearn.linear_model import Lasso
# Lasso nutzt eine L1-Strafe.
model = Lasso(alpha=0.5)
model.fit(X_train, y_train)
# Einige Koeffizienten können exakt null werden.
print(model.coef_)Was nimmst du mit?
Lasso ist die strengere Aufräumkraft. Wenn viele Merkmale nur Ballast sind, kann genau diese Härte hilfreich sein.
Elastic Net mischt Ridge und Lasso und ist oft robuster, wenn Features korreliert sind und zugleich viele irrelevante Merkmale im Spiel sind.
Manche Diäten funktionieren besser als Kombination: etwas weniger von allem und gleichzeitig konsequentes Streichen einzelner Ausnahmen. Genau diese Mischlogik bringt Elastic Net ins Modell.
Es kann Gewichte insgesamt schrumpfen und trotzdem einzelne Features aussortieren, ohne so aggressiv wie reines Lasso zu werden.
mischt L1 und L2. Der Parameter l1_ratio steuert die Mischung.
l1_ratio = 0 entspricht Ridge. l1_ratio = 1 entspricht Lasso. Werte dazwischen kombinieren beides.
Penalty = Alpha × (r × L1 + (1 - r) × L2)Setze ein Elastic-Net-Modell mit gemischter Strafe auf. Ergänze die Modellzeile und beobachte, wie der Koeffizient zwischen Ridge und Lasso landet.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.linear_model import ElasticNet
X = [[0.0], [1.0], [2.0], [3.0]]
y = [0.0, 1.0, 2.0, 3.0]
model = # ??? DEINE LÖSUNG ???
model.fit(X, y)
print(round(model.coef_[0], 3))Wähle alpha=0.2, l1_ratio=0.5, fit_intercept=False und ein höheres max_iter.
from sklearn.linear_model import ElasticNet
X = [[0.0], [1.0], [2.0], [3.0]]
y = [0.0, 1.0, 2.0, 3.0]
model = ElasticNet(alpha=0.2, l1_ratio=0.5, fit_intercept=False, max_iter=10000)
model.fit(X, y)
print(round(model.coef_[0], 3))Erwartete Ausgabe: `0.944`
Was nimmst du mit?
Elastic Net ist kein Kompromiss aus Verlegenheit, sondern eine bewusst steuerbare Mischform für schwierige Datensituationen.
Alpha ist ein Hyperparameter. Gute Werte findest du, indem du mehrere Kandidaten systematisch testest.
Eine Heizung stellst du nicht blind auf 31 Grad, nur weil dir die Zahl gefällt. Du probierst verschiedene Einstellungen und beobachtest, wo es wirklich angenehm wird.
Genauso behandelst du Alpha. Zu klein bedeutet oft Overfitting, zu groß führt schnell zu Underfitting. Dazwischen liegt der brauchbare Bereich.
Alpha ist ein Hyperparameter: Menschen legen ihn vor dem Training fest, das Modell lernt ihn nicht selbst.
Mit Grid Search probierst du viele Werte aus und vergleichst ihre Validierungsfehler, oft zusammen mit Cross-Validation.
Stell dir vor, deine Grid Search hat drei Kandidaten getestet. Ergänze die Zeile, die aus den gemessenen Validierungsfehlern den besten alpha-Wert auswählt.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
alphas = [0.1, 1.0, 10.0]
validation_rmse = [0.52, 0.68, 1.34]
best_index = # ??? DEINE LÖSUNG ???
best_alpha = alphas[best_index]
print(best_alpha)Gesucht ist der Index des kleinsten Fehlers. Mit diesem Index holst du dir danach das passende alpha aus der Liste.
alphas = [0.1, 1.0, 10.0]
validation_rmse = [0.52, 0.68, 1.34]
best_index = validation_rmse.index(min(validation_rmse))
best_alpha = alphas[best_index]
print(best_alpha)Erwartete Ausgabe: `0.1`
import pandas as pd
from sklearn.linear_model import RidgeCV
from sklearn.model_selection import train_test_split
# Kleine Beispieldaten für Verbrauch in Abhängigkeit von zwei Features
df = pd.DataFrame({
"horsepower": [95, 110, 125, 140, 155, 170, 185, 200],
"weight": [2200, 2350, 2480, 2620, 2790, 2950, 3120, 3300],
"mpg": [33, 31, 29, 27, 25, 23, 21, 19]
})
X = df[["horsepower", "weight"]]
y = df["mpg"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
# Wir testen mehrere Alpha-Werte automatisch.
alphas = [0.01, 0.1, 1.0, 10.0, 100.0]
model = RidgeCV(alphas=alphas, cv=3)
model.fit(X_train, y_train)
print(model.alpha_) # Bestes Alpha aus der SucheWas nimmst du mit?
Alpha wird nicht geraten. Ein guter Workflow testet mehrere Kandidaten und entscheidet anhand von Validierungsdaten.
Am Ende zählt der reproduzierbare Ablauf: Daten vorbereiten, skalieren, regularisieren und fair bewerten.
Ein Fitness-Tracker sammelt nicht nur einen Wert. Er verbindet Schritte, Puls, Schlaf und Aktivität zu einer Gesamtbewertung. Entscheidend ist die Reihenfolge und dass nichts vergessen wird.
Im Machine Learning ist eine genau diese saubere Kette: vorbereiten, transformieren, modellieren und am Ende prüfen, wie gut das Ganze auf neuen Daten funktioniert.
Eine Pipeline macht den Ablauf reproduzierbar. Gerade bei Regularisierung ist Skalierung wichtig, weil die Strafe sonst große Skalen bevorzugt oder benachteiligt.
Für Einsteiger hilft dieses Bild: Eine Pipeline ist wie ein Fließband. Die Daten laufen immer durch dieselben Stationen, zum Beispiel Features erweitern, skalieren, regularisiertes Modell trainieren. Die Bewertung bleibt außerhalb der Pipeline mit Testdaten.
import numpy as np
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import Ridge
from sklearn.model_selection import train_test_split
# Einfache Beispieldaten mit leicht gekrümmtem Zusammenhang
X = np.array([[1], [2], [3], [4], [5], [6], [7], [8]])
y = np.array([1.2, 1.9, 3.1, 4.0, 5.3, 6.1, 7.4, 8.2])
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42
)
pipeline = make_pipeline(
PolynomialFeatures(degree=3, include_bias=False),
StandardScaler(),
Ridge(alpha=1.0)
)
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(y_pred.round(2))Was nimmst du mit?
Regularisierung ist keine einzelne Formel, sondern Teil eines sauberen Gesamtprozesses. Erst die Pipeline macht aus einer guten Idee einen verlässlichen Workflow.