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.
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.