Vergleich von linearen bayes'schen Regressoren

Einführung

In diesem Lab wird ein synthetisches Dataset verwendet, um zwei verschiedene Bayes'sche Regressoren zu vergleichen: Automatic Relevance Determination und Bayesian Ridge Regression. Der erste Teil des Labs vergleicht die Koeffizienten der Modelle mit den wahren Koeffizienten unter Verwendung eines Ordinary Least Squares (OLS)-Modells als Referenz. Im letzten Abschnitt des Labs werden Vorhersagen und Unsicherheiten für die ARD- und die Bayesian Ridge-Regression geplottet, wobei eine polynomiale Feature Expansion verwendet wird, um eine nicht-lineare Beziehung zwischen X und y anzupassen.

Tipps für die VM

Nachdem der Start der VM abgeschlossen ist, klicken Sie in der oberen linken 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 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.

Synthetisches Dataset generieren

Wir generieren ein synthetisches Dataset, in dem X und y linear verknüpft sind. Zehn der Features von X werden verwendet, um y zu generieren. Die anderen Features sind bei der Vorhersage von y nicht nützlich. Darüber hinaus generieren wir ein Dataset, bei dem n_samples == n_features. Ein solcher Einstellung ist für ein OLS-Modell herausfordernd und kann möglicherweise zu beliebig großen Gewichten führen. Ein Vorwissen über die Gewichte und eine Strafe mildern das Problem. Schließlich wird gaussian Rauschen hinzugefügt.

from sklearn.datasets import make_regression

X, y, true_weights = make_regression(
    n_samples=100,
    n_features=100,
    n_informative=10,
    noise=8,
    coef=True,
    random_state=42,
)

Die Regressoren anpassen

Wir passen sowohl die Bayes'schen Modelle als auch das OLS an, um später die Koeffizienten der Modelle zu vergleichen.

import pandas as pd
from sklearn.linear_model import ARDRegression, LinearRegression, BayesianRidge

olr = LinearRegression().fit(X, y)
brr = BayesianRidge(compute_score=True, n_iter=30).fit(X, y)
ard = ARDRegression(compute_score=True, n_iter=30).fit(X, y)
df = pd.DataFrame(
    {
        "Gewichte des wahren generativen Prozesses": true_weights,
        "ARDRegression": ard.coef_,
        "BayesianRidge": brr.coef_,
        "LinearRegression": olr.coef_,
    }
)

Die wahren und geschätzten Koeffizienten plotten

Wir vergleichen die Koeffizienten jedes Modells mit den Gewichten des wahren generativen Modells.

import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.colors import SymLogNorm

plt.figure(figsize=(10, 6))
ax = sns.heatmap(
    df.T,
    norm=SymLogNorm(linthresh=10e-4, vmin=-80, vmax=80),
    cbar_kws={"label": "Koeffizientenwerte"},
    cmap="seismic_r",
)
plt.ylabel("lineares Modell")
plt.xlabel("Koeffizienten")
plt.tight_layout(rect=(0, 0, 1, 0.95))
_ = plt.title("Koeffizienten der Modelle")

Die marginale Log-Wahrscheinlichkeit plotten

Wir plotten die marginale Log-Wahrscheinlichkeit beider Modelle.

import numpy as np

ard_scores = -np.array(ard.scores_)
brr_scores = -np.array(brr.scores_)
plt.plot(ard_scores, color="navy", label="ARD")
plt.plot(brr_scores, color="red", label="BayesianRidge")
plt.ylabel("Log-Wahrscheinlichkeit")
plt.xlabel("Iterationen")
plt.xlim(1, 30)
plt.legend()
_ = plt.title("Log-Wahrscheinlichkeit der Modelle")

Synthetisches Dataset generieren

Wir erstellen ein Ziel, das eine nicht-lineare Funktion der Eingabe-Feature ist. Rauschen, das einer standardnormalverteilten Gleichverteilung folgt, wird hinzugefügt.

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler

rng = np.random.RandomState(0)
n_samples = 110

## sortieren der Daten, um das späteren Plotten zu erleichtern
X = np.sort(-10 * rng.rand(n_samples) + 10)
noise = rng.normal(0, 1, n_samples) * 1.35
y = np.sqrt(X) * np.sin(X) + noise
full_data = pd.DataFrame({"input_feature": X, "target": y})
X = X.reshape((-1, 1))

## Extrapolation
X_plot = np.linspace(10, 10.4, 10)
y_plot = np.sqrt(X_plot) * np.sin(X_plot)
X_plot = np.concatenate((X, X_plot.reshape((-1, 1))))
y_plot = np.concatenate((y - noise, y_plot))

Die Regressoren anpassen

Wir versuchen ein Polynom vom Grad 10, um möglicherweise zu überanpassen, obwohl die bayes'schen linearen Modelle die Größe der Polynomkoeffizienten regulieren. Da fit_intercept=True standardmäßig für ARDRegression und BayesianRidge gesetzt ist, sollte PolynomialFeatures keine zusätzliche Bias-Feature einführen. Indem return_std=True gesetzt wird, geben die bayes'schen Regressoren die Standardabweichung der posterioren Verteilung für die Modellparameter zurück.

ard_poly = make_pipeline(
    PolynomialFeatures(degree=10, include_bias=False),
    StandardScaler(),
    ARDRegression(),
).fit(X, y)
brr_poly = make_pipeline(
    PolynomialFeatures(degree=10, include_bias=False),
    StandardScaler(),
    BayesianRidge(),
).fit(X, y)

y_ard, y_ard_std = ard_poly.predict(X_plot, return_std=True)
y_brr, y_brr_std = brr_poly.predict(X_plot, return_std=True)

Plotten von Polynomregressionen mit Standardfehlern der Scores

Die Fehlerbalken repräsentieren eine Standardabweichung der vorhergesagten gaussianischen Verteilung der Abfragepunkte. Beachten Sie, dass die ARD-Regression die tatsächliche Situation am besten erfasst, wenn die Standardparameter in beiden Modellen verwendet werden, aber die weitere Reduzierung des Hyperparameters lambda_init der Bayesian Ridge ihre Bias reduzieren kann. Schließlich scheitern beide Modelle bei der Extrapolation aufgrund der intrinsischen Limitationen einer Polynomregression.

ax = sns.scatterplot(
    data=full_data, x="input_feature", y="target", color="black", alpha=0.75
)
ax.plot(X_plot, y_plot, color="black", label="Ground Truth")
ax.plot(X_plot, y_brr, color="red", label="BayesianRidge with polynomial features")
ax.plot(X_plot, y_ard, color="navy", label="ARD with polynomial features")
ax.fill_between(
    X_plot.ravel(),
    y_ard - y_ard_std,
    y_ard + y_ard_std,
    color="navy",
    alpha=0.3,
)
ax.fill_between(
    X_plot.ravel(),
    y_brr - y_brr_std,
    y_brr + y_brr_std,
    color="red",
    alpha=0.3,
)
ax.legend()
_ = ax.set_title("Polynomial fit of a non-linear feature")

Zusammenfassung

Dieses Lab vergleicht zwei verschiedene bayes'sche Regressoren mit Hilfe eines synthetischen Datasets. Der erste Teil des Labs vergleicht die Koeffizienten der Modelle mit den wahren Koeffizienten unter Verwendung eines Ordinary Least Squares (OLS)-Modells als Referenz. Im letzten Abschnitt des Labs werden Vorhersagen und Unsicherheiten für die ARD- und die Bayesian Ridge-Regression mit Hilfe einer polynomiellen Feature-Erweiterung dargestellt, um eine nicht-lineare Beziehung zwischen X und y anzupassen.