Comparer les régresseurs bayésiens linéaires

Introduction

Ce laboratoire utilise un ensemble de données synthétiques pour comparer deux régresseurs bayésiens différents : la détermination de la pertinence automatique et la régression de Ridge bayésienne. La première partie du laboratoire compare les coefficients des modèles par rapport aux coefficients réels en utilisant un modèle de moindres carrés ordinaires (OLS) comme référence. Dans la dernière section, le laboratoire trace les prédictions et les incertitudes pour les régressions ARD et de Ridge bayésienne en utilisant une expansion de fonction polynomiale pour ajuster une relation non linéaire entre X et y.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Générer un ensemble de données synthétiques

Nous générons un ensemble de données synthétiques où X et y sont liés linéairement. Dix des caractéristiques de X seront utilisées pour générer y. Les autres caractéristiques ne sont pas utiles pour prédire y. De plus, nous générons un ensemble de données où n_samples == n_features. Un tel paramétrage est difficile pour un modèle OLS et peut potentiellement entraîner des poids arbitrairement grands. Avoir une a priori sur les poids et une pénalité atténue le problème. Enfin, du bruit gaussien est ajouté.

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,
)

Ajuster les régresseurs

Nous ajustons les deux modèles bayésiens et l'OLS pour comparer plus tard les coefficients des modèles.

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(
    {
        "Weights of true generative process": true_weights,
        "ARDRegression": ard.coef_,
        "BayesianRidge": brr.coef_,
        "LinearRegression": olr.coef_,
    }
)

Tracer les coefficients réels et estimés

Nous comparons les coefficients de chaque modèle avec les poids du modèle générateur réel.

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": "valeurs des coefficients"},
    cmap="seismic_r",
)
plt.ylabel("modèle linéaire")
plt.xlabel("coefficients")
plt.tight_layout(rect=(0, 0, 1, 0.95))
_ = plt.title("Coefficients des modèles")

Tracer la log-vraisemblance marginale

Nous traçons la log-vraisemblance marginale des deux modèles.

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-vraisemblance")
plt.xlabel("Itérations")
plt.xlim(1, 30)
plt.legend()
_ = plt.title("Log-vraisemblance des modèles")

Générer un ensemble de données synthétiques

Nous créons une variable cible qui est une fonction non linéaire des caractéristiques d'entrée. Du bruit suivant une distribution uniforme standard est ajouté.

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

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

## trier les données pour faciliter la tracé plus tard
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))

Ajuster les régresseurs

Nous essayons un polynôme de degré 10 pour risquer de surajuster, bien que les modèles linéaires bayésiens régularisent la taille des coefficients du polynôme. Comme fit_intercept=True par défaut pour ARDRegression et BayesianRidge, alors PolynomialFeatures ne devrait pas introduire une fonction de biais supplémentaire. En définissant return_std=True, les régresseurs bayésiens renvoient l'écart-type de la distribution postérieure pour les paramètres du modèle.

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)

Tracer des régressions polynômes avec les erreurs-types des scores

Les barres d'erreur représentent un écart-type de la distribution gaussienne prédite des points de requête. Remarquez que la régression ARD capture la vérité terrain le mieux en utilisant les paramètres par défaut dans les deux modèles, mais réduire davantage le paramètre hyper lambda_init de la Ridge bayésienne peut réduire son biais. Enfin, en raison des limitations intrinsèques d'une régression polynomiale, les deux modèles échouent lors de l'extrapolation.

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")

Sommaire

Ce laboratoire compare deux régresseurs bayésiens différents en utilisant un ensemble de données synthétiques. La première partie du laboratoire compare les coefficients des modèles par rapport aux coefficients réels en utilisant un modèle de moindres carrés ordinaires (OLS) comme référence. Dans la dernière section, le laboratoire trace les prédictions et les incertitudes pour les régressions ARD et Ridge bayésienne en utilisant une expansion de fonction polynomiale pour ajuster une relation non linéaire entre X et y.