Vergleiche Huber und Ridge

Einführung

In diesem Lab werden wir die Leistung zweier Regressionsmodelle, HuberRegressor und Ridge, auf einem Datensatz mit starken Ausreißern vergleichen. Wir werden einen Toy-Datensatz generieren, ihm starke Ausreißer hinzufügen und dann beide Modelle an den Datensatz anpassen. Wir werden die Ergebnisse visualisieren und die Leistung der Modelle vergleichen.

VM-Tipps

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 von 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, und wir werden das Problem für Sie prompt beheben.

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken, einschließlich von numpy und matplotlib für die Datenmanipulation und -visualisierung sowie von HuberRegressor und Ridge aus scikit-learn für die Regressionsmodellierung.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import HuberRegressor, Ridge

Erzeugen eines Toy-Datensatzes

Wir werden nun einen Toy-Datensatz mit der Funktion make_regression aus scikit-learn erzeugen. Wir werden einen Datensatz mit 20 Proben, einem Merkmal und einem Zufallszahlengenerator mit dem Seed 0 erzeugen. Wir werden auch etwas Rauschen zum Datensatz hinzufügen.

rng = np.random.RandomState(0)
X, y = make_regression(
    n_samples=20, n_features=1, random_state=0, noise=4.0, bias=100.0
)

Fügen von starken Ausreißern zum Datensatz hinzu

Wir werden vier starke Ausreißer zum Datensatz hinzufügen. Wir werden zufällige Werte für diese Ausreißer mit Hilfe der Normalverteilung generieren. Anschließend werden wir diese Ausreißer zum Datensatz hinzufügen.

X_outliers = rng.normal(0, 0.5, size=(4, 1))
y_outliers = rng.normal(0, 2.0, size=4)
X_outliers[:2, :] += X.max() + X.mean() / 4.0
X_outliers[2:, :] += X.min() - X.mean() / 4.0
y_outliers[:2] += y.min() - y.mean() / 4.0
y_outliers[2:] += y.max() + y.mean() / 4.0
X = np.vstack((X, X_outliers))
y = np.concatenate((y, y_outliers))

Visualisierung des Datensatzes

Wir werden nun den Datensatz mit matplotlib visualisieren. Wir werden die Werte von X gegen die Werte von y aufzeichnen.

plt.plot(X, y, "b.")
plt.title("Dataset with Strong Outliers")
plt.xlabel("X")
plt.ylabel("y")
plt.show()

Passt den Huber-Regressor an

Wir werden nun den HuberRegressor an den Datensatz anpassen. Wir werden das Modell über einen Bereich von Epsilon-Werten anpassen, um zu zeigen, wie sich die Entscheidungsfunktion an die der Ridge-Regression annähert, wenn der Wert von Epsilon zunimmt.

## Definiere den Bereich der Epsilon-Werte
epsilon_values = [1, 1.5, 1.75, 1.9]

## Definiere die x-Werte zum Plotten
x = np.linspace(X.min(), X.max(), 7)

## Definiere die Farben zum Plotten
colors = ["r-", "b-", "y-", "m-"]

## Passt den Huber-Regressor über eine Reihe von Epsilon-Werten an.
for k, epsilon in enumerate(epsilon_values):
    huber = HuberRegressor(alpha=0.0, epsilon=epsilon)
    huber.fit(X, y)
    coef_ = huber.coef_ * x + huber.intercept_
    plt.plot(x, coef_, colors[k], label="huber loss, %s" % epsilon)

## Füge eine Legende zum Plot hinzu
plt.legend(loc=0)

## Zeige den Plot an
plt.title("HuberRegressor mit unterschiedlichen Epsilon-Werten")
plt.xlabel("X")
plt.ylabel("y")
plt.show()

Passt den Ridge-Regressor an

Wir werden nun den Ridge-Regressor an den Datensatz anpassen und dessen Leistung mit der des HuberRegressors vergleichen.

## Passt einen Ridge-Regressor an, um ihn mit dem Huber-Regressor zu vergleichen.
ridge = Ridge(alpha=0.0, random_state=0)
ridge.fit(X, y)
coef_ridge = ridge.coef_
coef_ = ridge.coef_ * x + ridge.intercept_
plt.plot(x, coef_, "g-", label="ridge regression")

## Füge eine Legende zum Plot hinzu
plt.legend(loc=0)

## Zeige den Plot an
plt.title("Vergleich von HuberRegressor und Ridge")
plt.xlabel("X")
plt.ylabel("y")
plt.show()

Zusammenfassung

In diesem Lab haben wir die Leistung zweier Regressionsmodelle, HuberRegressor und Ridge, auf einem Datensatz mit starken Ausreißern verglichen. Wir haben einen Toy-Datensatz generiert, ihm starke Ausreißer hinzugefügt und dann beide Modelle an den Datensatz angepasst. Wir haben die Ergebnisse visualisiert und die Leistung der Modelle verglichen. Wir haben beobachtet, dass der HuberRegressor weniger von den Ausreißern beeinflusst wurde als der Ridge-Regressor und dass sich die Entscheidungsfunktion des HuberRegressors mit zunehmendem Wert von Epsilon der des Ridge-Regressors annäherte.