Comparando regresores bayesianos lineales

Introducción

Esta práctica utiliza un conjunto de datos sintético para comparar dos regresores bayesianos diferentes: Determinación de Relevancia Automática y Regresión de Cresta Bayesiana. La primera parte de la práctica compara los coeficientes de los modelos con respecto a los coeficientes reales utilizando un modelo de Mínimos Cuadrados Ordinarios (OLS) como línea base. En la última sección, la práctica traza las predicciones y las incertidumbres para las regresiones ARD y de Cresta Bayesiana utilizando una expansión de características polinómicas para ajustar una relación no lineal entre X e y.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Generar un conjunto de datos sintético

Generamos un conjunto de datos sintético en el que X e y están relacionados linealmente. Diez de las características de X se utilizarán para generar y. Las otras características no son útiles para predecir y. Además, generamos un conjunto de datos donde n_samples == n_features. Esta configuración es desafiante para un modelo OLS y puede conducir a pesos arbitrariamente grandes. Tener una prioridad sobre los pesos y una penalización alivia el problema. Finalmente, se agrega ruido gaussiano.

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

Ajustar los regresores

Ajustamos ambos modelos bayesianos y el OLS para luego comparar los coeficientes de los modelos.

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

Graficar los coeficientes reales y estimados

Comparamos los coeficientes de cada modelo con los pesos del modelo generativo real.

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": "valores de los coeficientes"},
    cmap="seismic_r",
)
plt.ylabel("modelo lineal")
plt.xlabel("coeficientes")
plt.tight_layout(rect=(0, 0, 1, 0.95))
_ = plt.title("Coeficientes de los modelos")

Graficar la log-verosimilitud marginal

Graficamos la log-verosimilitud marginal de ambos modelos.

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-verosimilitud")
plt.xlabel("Iteraciones")
plt.xlim(1, 30)
plt.legend()
_ = plt.title("Log-verosimilitud de los modelos")

Generar un conjunto de datos sintético

Creamos una variable objetivo que es una función no lineal de la característica de entrada. Se agrega ruido que sigue una distribución uniforme estándar.

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

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

## ordenar los datos para facilitar la representación posterior
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({"característica de entrada": X, "variable objetivo": y})
X = X.reshape((-1, 1))

## extrapolación
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))

Ajustar los regresores

Probamos un polinomio de grado 10 para potencialmente sobreajustar, aunque los modelos lineales bayesianos regularizan el tamaño de los coeficientes del polinomio. Dado que fit_intercept=True por defecto para ARDRegression y BayesianRidge, entonces PolynomialFeatures no debe introducir una característica de sesgo adicional. Al establecer return_std=True, los regresores bayesianos devuelven la desviación estándar de la distribución posterior para los parámetros del modelo.

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)

Graficando regresiones polinómicas con errores estándar de las puntuaciones

Las barras de error representan una desviación estándar de la distribución gaussiana predicha de los puntos de consulta. Observe que la regresión ARD captura la verdadera situación de mejor manera al usar los parámetros predeterminados en ambos modelos, pero reducir aún más el hiperparámetro lambda_init de Bayesian Ridge puede reducir su sesgo. Finalmente, debido a las limitaciones intrínsecas de una regresión polinómica, ambos modelos fallan al extrapolar.

ax = sns.scatterplot(
    data=full_data, x="característica de entrada", y="variable objetivo", color="black", alpha=0.75
)
ax.plot(X_plot, y_plot, color="black", label="Verdadera situación")
ax.plot(X_plot, y_brr, color="red", label="BayesianRidge con características polinómicas")
ax.plot(X_plot, y_ard, color="navy", label="ARD con características polinómicas")
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("Ajuste polinómico de una característica no lineal")

Resumen

Esta práctica compara dos regresores bayesianos diferentes utilizando un conjunto de datos sintético. La primera parte de la práctica compara los coeficientes de los modelos con respecto a los coeficientes reales utilizando un modelo de mínimos cuadrados ordinarios (OLS) como línea base. En la última sección, la práctica grafica las predicciones y las incertidumbres para las regresiones ARD y Bayesian Ridge utilizando una expansión de características polinómicas para ajustar una relación no lineal entre X e y.