Tutorial zur robusten linearen Schätzung

Einführung

In diesem Lab werden wir lernen, wie man die scikit-learn-Bibliothek von Python verwendet, um eine robuste lineare Schätzeranpassung durchzuführen. Wir werden eine Sinusfunktion mit einem Polynom dritten Grades für Werte in der Nähe von Null anpassen und die robuste Anpassung in verschiedenen Situationen demonstrieren. Wir werden die mittlere absolute Abweichung verwenden, um neue, nicht verfälschte Daten zu bewerten und die Qualität der Vorhersage zu beurteilen.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der linken oberen Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

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

Wenn Sie während des Lernens 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 und Generieren von Daten

Wir müssen zunächst die erforderlichen Bibliotheken importieren und Daten für unsere Anpassung generieren. Wir werden eine Sinusfunktion mit etwas Rauschen generieren und die Daten durch die Einführung von Fehlern in sowohl X als auch y verfälschen.

from matplotlib import pyplot as plt
import numpy as np

from sklearn.linear_model import (
    LinearRegression,
    TheilSenRegressor,
    RANSACRegressor,
    HuberRegressor,
)
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline

np.random.seed(42)

X = np.random.normal(size=400)
y = np.sin(X)
## Stellen Sie sicher, dass X 2D ist
X = X[:, np.newaxis]

X_test = np.random.normal(size=200)
y_test = np.sin(X_test)
X_test = X_test[:, np.newaxis]

y_errors = y.copy()
y_errors[::3] = 3

X_errors = X.copy()
X_errors[::3] = 3

y_errors_large = y.copy()
y_errors_large[::3] = 10

X_errors_large = X.copy()
X_errors_large[::3] = 10

Ein Sinusfunktion mit einem Polynom dritten Grades anpassen

Wir werden eine Sinusfunktion mit einem Polynom dritten Grades für Werte in der Nähe von Null anpassen.

x_plot = np.linspace(X.min(), X.max())

Demonstrieren der robusten Anpassung in verschiedenen Situationen

Wir werden nun die robuste Anpassung in verschiedenen Situationen mit vier verschiedenen Schätzern demonstrieren: OLS, Theil-Sen, RANSAC und HuberRegressor.

estimators = [
    ("OLS", LinearRegression()),
    ("Theil-Sen", TheilSenRegressor(random_state=42)),
    ("RANSAC", RANSACRegressor(random_state=42)),
    ("HuberRegressor", HuberRegressor()),
]
colors = {
    "OLS": "turquoise",
    "Theil-Sen": "gold",
    "RANSAC": "lightgreen",
    "HuberRegressor": "black",
}
linestyle = {"OLS": "-", "Theil-Sen": "-.", "RANSAC": "--", "HuberRegressor": "--"}
lw = 3

Die Ergebnisse plotten

Wir werden nun die Ergebnisse für jede der verschiedenen Situationen plotten.

for title, this_X, this_y in [
    ("Modeling Errors Only", X, y),
    ("Corrupt X, Small Deviants", X_errors, y),
    ("Corrupt y, Small Deviants", X, y_errors),
    ("Corrupt X, Large Deviants", X_errors_large, y),
    ("Corrupt y, Large Deviants", X, y_errors_large),
]:
    plt.figure(figsize=(5, 4))
    plt.plot(this_X[:, 0], this_y, "b+")

    for name, estimator in estimators:
        model = make_pipeline(PolynomialFeatures(3), estimator)
        model.fit(this_X, this_y)
        mse = mean_squared_error(model.predict(X_test), y_test)
        y_plot = model.predict(x_plot[:, np.newaxis])
        plt.plot(
            x_plot,
            y_plot,
            color=colors[name],
            linestyle=linestyle[name],
            linewidth=lw,
            label="%s: error = %.3f" % (name, mse),
        )

    legend_title = "Error of Mean\nAbsolute Deviation\nto Non-corrupt Data"
    legend = plt.legend(
        loc="upper right", frameon=False, title=legend_title, prop=dict(size="x-small")
    )
    plt.xlim(-4, 10.2)
    plt.ylim(-2, 10.2)
    plt.title(title)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die scikit-learn-Bibliothek in Python verwendet, um eine robuste lineare Schätzung durchzuführen. Wir haben eine Sinusfunktion mit einem Polynom dritten Grades für Werte in der Nähe von Null angepasst und die robuste Anpassung in verschiedenen Situationen demonstriert. Wir haben die mittlere absolute Abweichung zu nicht verfälschten neuen Daten verwendet, um die Qualität der Vorhersage zu beurteilen.

Robuste lineare Schätzung