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.