Modelado predictivo no lineal usando Procesos Gaussianos

Introducción

La regresión de procesos gaussianos es una técnica de modelado estadístico que se utiliza para predecir el resultado de una variable objetivo en función de variables de entrada. La técnica modela la distribución de la variable objetivo como un proceso gaussiano, que es una colección de variables aleatorias, cualquier número finito de las cuales tiene una distribución gaussiana conjunta. La técnica es particularmente útil en casos donde la relación entre las variables de entrada y la variable objetivo es no lineal.

En este laboratorio, aprenderemos a usar la regresión de procesos gaussianos con estimación del nivel de ruido en Python, usando la biblioteca scikit-learn.

Consejos sobre la VM

Después de que se haya iniciado 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.

Generación de datos

En este paso, generaremos algunos datos con una sola característica usando una función seno.

import numpy as np

def target_generator(X, add_noise=False):
    target = 0.5 + np.sin(3 * X)
    if add_noise:
        rng = np.random.RandomState(1)
        target += rng.normal(0, 0.3, size=target.shape)
    return target.squeeze()

X = np.linspace(0, 5, num=30).reshape(-1, 1)
y = target_generator(X, add_noise=False)

Visualización de datos

En este paso, visualizaremos los datos generados.

import matplotlib.pyplot as plt

plt.plot(X, y, label="Señal esperada")
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")

Agregar ruido

En este paso, agregaremos algo de ruido a los datos generados para crear un conjunto de datos de entrenamiento más realista.

rng = np.random.RandomState(0)
X_train = rng.uniform(0, 5, size=20).reshape(-1, 1)
y_train = target_generator(X_train, add_noise=True)

Visualización de datos

En este paso, visualizaremos el conjunto de datos de entrenamiento con ruido junto con la señal esperada.

plt.plot(X, y, label="Señal esperada")
plt.scatter(
    x=X_train[:, 0],
    y=y_train,
    color="black",
    alpha=0.4,
    label="Observaciones",
)
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")

Regresión con Procesos Gaussianos

En este paso, crearemos un regresor de procesos gaussianos usando un kernel aditivo que agrega los kernels RBF y WhiteKernel. El kernel WhiteKernel es un kernel que será capaz de estimar la cantidad de ruido presente en los datos mientras que el RBF servirá para ajustar la no-linealidad entre los datos y la variable objetivo.

from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel

kernel = 1.0 * RBF(length_scale=1e-1, length_scale_bounds=(1e-2, 1e3)) + WhiteKernel(
    noise_level=1e-2, noise_level_bounds=(1e-10, 1e1)
)
gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0)
gpr.fit(X_train, y_train)
y_mean, y_std = gpr.predict(X, return_std=True)

Visualización de datos

En este paso, visualizaremos las predicciones hechas por el regresor de procesos gaussianos.

plt.plot(X, y, label="Señal esperada")
plt.scatter(x=X_train[:, 0], y=y_train, color="black", alpha=0.4, label="Observaciones")
plt.errorbar(X, y_mean, y_std)
plt.legend()
plt.xlabel("X")
plt.ylabel("y")
_ = plt.title(
    (
        f"Initial: {kernel}\nOptimum: {gpr.kernel_}\nLog-Marginal-Likelihood: "
        f"{gpr.log_marginal_likelihood(gpr.kernel_.theta)}"
    ),
    fontsize=8,
)

Log-Verdad-Marginal

En este paso, inspeccionaremos la Log-Verdad-Marginal (LML) de GaussianProcessRegressor para diferentes hiperparámetros para obtener una idea de los mínimos locales.

from matplotlib.colors import LogNorm

length_scale = np.logspace(-2, 4, num=50)
noise_level = np.logspace(-2, 1, num=50)
length_scale_grid, noise_level_grid = np.meshgrid(length_scale, noise_level)

log_marginal_likelihood = [
    gpr.log_marginal_likelihood(theta=np.log([0.36, scale, noise]))
    for scale, noise in zip(length_scale_grid.ravel(), noise_level_grid.ravel())
]
log_marginal_likelihood = np.reshape(
    log_marginal_likelihood, newshape=noise_level_grid.shape
)

vmin, vmax = (-log_marginal_likelihood).min(), 50
level = np.around(np.logspace(np.log10(vmin), np.log10(vmax), num=50), decimals=1)
plt.contour(
    length_scale_grid,
    noise_level_grid,
    -log_marginal_likelihood,
    levels=level,
    norm=LogNorm(vmin=vmin, vmax=vmax),
)
plt.colorbar()
plt.xscale("log")
plt.yscale("log")
plt.xlabel("Longitud de escala")
plt.ylabel("Nivel de ruido")
plt.title("Log-verdad-marginal")
plt.show()

Conclusión

En este laboratorio, aprendimos cómo usar la regresión con procesos gaussianos con estimación del nivel de ruido en Python, usando la biblioteca scikit-learn. Generamos algunos datos con una sola característica usando una función seno, agregamos algo de ruido a los datos generados para crear un conjunto de datos de entrenamiento más realista y visualizamos los datos generados. Creamos un regresor de procesos gaussianos usando un kernel aditivo que agrega los kernels RBF y WhiteKernel, y visualizamos las predicciones hechas por el regresor de procesos gaussianos. También inspeccionamos la Log-Verdad-Marginal (LML) de GaussianProcessRegressor para diferentes hiperparámetros para obtener una idea de los mínimos locales.

Resumen

¡Felicitaciones! Has completado el laboratorio de Regresión con Procesos Gaussianos. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.