Ridge Regression für lineare Modelle

Einführung

In diesem Lab werden wir lernen, wie wir Ridge Regression für die lineare Regression mit L2-Regularisierung verwenden, um Overfitting zu vermeiden. Wir werden scikit-learn, eine beliebte Machine-Learning-Bibliothek für Python, verwenden.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken für dieses Lab.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_regression
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error

Generieren von zufälligen Daten

Wir werden zufällige Daten mit der make_regression-Funktion aus scikit-learn generieren. Wir werden n_samples auf 10, n_features auf 10 und random_state auf 1 setzen. Diese Funktion wird unsere Eingabefeatures X, unsere Zielfunktion y und die wahren Koeffizientenwerte w zurückgeben.

X, y, w = make_regression(
    n_samples=10, n_features=10, coef=True, random_state=1, bias=3.5
)

Initialisieren des Ridge-Regressionsmodells

Wir werden das Ridge-Regressionsmodell mit seinen Standard-Hyperparametern initialisieren.

clf = Ridge()

Trainieren des Modells mit unterschiedlichen Regularisierungswerten

Wir werden das Modell mit unterschiedlichen Regularisierungswerten in einer Schleife trainieren. Wir werden die Regularisierungswert durch Ändern des Wertes von alpha in der set_params-Funktion festlegen. Wir werden die Koeffizienten und Fehler für jeden Wert von alpha speichern.

coefs = []
errors = []

alphas = np.logspace(-6, 6, 200)

for a in alphas:
    clf.set_params(alpha=a)
    clf.fit(X, y)
    coefs.append(clf.coef_)
    errors.append(mean_squared_error(clf.coef_, w))

Zeichnen der Ergebnisse

Wir werden die Koeffizienten und Fehler als Funktion der Regularisierungswert mit Matplotlib zeichnen.

plt.figure(figsize=(20, 6))

plt.subplot(121)
ax = plt.gca()
ax.plot(alphas, coefs)
ax.set_xscale("log")
plt.xlabel("alpha")
plt.ylabel("weights")
plt.title("Ridge coefficients as a function of the regularization")
plt.axis("tight")

plt.subplot(122)
ax = plt.gca()
ax.plot(alphas, errors)
ax.set_xscale("log")
plt.xlabel("alpha")
plt.ylabel("error")
plt.title("Coefficient error as a function of the regularization")
plt.axis("tight")

plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Ridge Regression mit L2-Regularisierung verwendet, um Overfitting zu vermeiden. Wir haben zufällige Daten generiert, ein Ridge-Regressionsmodell mit unterschiedlichen Regularisierungswerten trainiert und die Koeffizienten und Fehler als Funktion der Regularisierungswert geplottet.