Introducción
Esta práctica demuestra cómo utilizar diferentes kernels para la regresión con procesos gaussianos (GPR, por sus siglas en inglés) en la biblioteca Scikit-learn de Python. La GPR es una técnica de regresión no paramétrica que puede ajustar modelos complejos a datos con ruido. Una función kernel se utiliza para determinar la similitud entre cualquier par de puntos de entrada. La elección de la función kernel es importante, ya que determina la forma del modelo que se ajusta a los datos. En esta práctica, cubriremos los kernels más comúnmente utilizados en GPR.
Consejos sobre la VM
Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Notebook 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.
Importar bibliotecas
Comenzamos importando las bibliotecas necesarias.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, RationalQuadratic, ExpSineSquared, ConstantKernel, DotProduct, Matern
Crear datos de entrenamiento
A continuación, creamos un conjunto de datos de entrenamiento que utilizaremos en las diferentes secciones.
rng = np.random.RandomState(4)
X_train = rng.uniform(0, 5, 10).reshape(-1, 1)
y_train = np.sin((X_train[:, 0] - 2.5) ** 2)
n_samples = 5
Función auxiliar
Antes de presentar cada kernel individual disponible para los procesos gaussianos, definiremos una función auxiliar que nos permitirá trazar muestras extraídas del proceso gaussiano.
def plot_gpr_samples(gpr_model, n_samples, ax):
"""Plot samples drawn from the Gaussian process model.
If the Gaussian process model is not trained then the drawn samples are
drawn from the prior distribution. Otherwise, the samples are drawn from
the posterior distribution. Be aware that a sample here corresponds to a
function.
Parameters
----------
gpr_model : `GaussianProcessRegressor`
A :class:`~sklearn.gaussian_process.GaussianProcessRegressor` model.
n_samples : int
The number of samples to draw from the Gaussian process distribution.
ax : matplotlib axis
The matplotlib axis where to plot the samples.
"""
x = np.linspace(0, 5, 100)
X = x.reshape(-1, 1)
y_mean, y_std = gpr_model.predict(X, return_std=True)
y_samples = gpr_model.sample_y(X, n_samples)
for idx, single_prior in enumerate(y_samples.T):
ax.plot(
x,
single_prior,
linestyle="--",
alpha=0.7,
label=f"Sampled function #{idx + 1}",
)
ax.plot(x, y_mean, color="black", label="Mean")
ax.fill_between(
x,
y_mean - y_std,
y_mean + y_std,
alpha=0.1,
color="black",
label=r"$\pm$ 1 std. dev.",
)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_ylim([-3, 3])
Kernel de función de base radial
El kernel de función de base radial (RBF, por sus siglas en inglés) está definido como:
$$ k(x_i, x_j) = \exp \left( -\frac{|x_i - x_j|^2}{2\ell^2} \right) $$
donde $\ell$ es el parámetro de escala de longitud.
kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-1, 10.0))
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plot prior
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Samples from prior distribution")
## plot posterior
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Samples from posterior distribution")
fig.suptitle("Radial Basis Function kernel", fontsize=18)
plt.tight_layout()
Kernel de racional cuadrático
El kernel de racional cuadrático está definido como:
$$ k(x_i, x_j) = \left( 1 + \frac{|x_i - x_j|^2}{2\alpha\ell^2} \right)^{-\alpha} $$
donde $\ell$ es el parámetro de escala de longitud y $\alpha$ controla el peso relativo de las características a pequeña y gran escala.
kernel = 1.0 * RationalQuadratic(length_scale=1.0, alpha=0.1, alpha_bounds=(1e-5, 1e15))
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plot prior
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Samples from prior distribution")
## plot posterior
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Samples from posterior distribution")
fig.suptitle("Rational Quadratic kernel", fontsize=18)
plt.tight_layout()
Kernel Exp-Sine-Squared
El kernel Exp-Sine-Squared está definido como:
$$ k(x_i, x_j) = \exp \left( -\frac{2\sin^2(\pi|x_i - x_j|/p)}{\ell^2} \right) $$
donde $\ell$ es el parámetro de escala de longitud y $p$ controla la periodicidad.
kernel = 1.0 * ExpSineSquared(
length_scale=1.0,
periodicity=3.0,
length_scale_bounds=(0.1, 10.0),
periodicity_bounds=(1.0, 10.0),
)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plot prior
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Samples from prior distribution")
## plot posterior
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Samples from posterior distribution")
fig.suptitle("Exp-Sine-Squared kernel", fontsize=18)
plt.tight_layout()
Kernel de producto punto
El kernel de producto punto está definido como:
$$ k(x_i, x_j) = (\sigma_0 + x_i^T x_j)^2 $$
donde $\sigma_0$ es una constante.
kernel = ConstantKernel(0.1, (0.01, 10.0)) * (
DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0)) ** 2
)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plot prior
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Samples from prior distribution")
## plot posterior
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Samples from posterior distribution")
fig.suptitle("Dot-Product kernel", fontsize=18)
plt.tight_layout()
Kernel de Matérn
El kernel de Matérn está definido como:
$$ k(x_i, x_j) = \frac{1}{\Gamma(\nu)2^{\nu-1}}\left(\frac{\sqrt{2\nu}}{\ell}|x_i - x_j|\right)^\nu K_\nu\left(\frac{\sqrt{2\nu}}{\ell}|x_i - x_j|\right) $$
donde $\ell$ es el parámetro de escala de longitud y $\nu$ controla la suavidad de la función.
kernel = 1.0 * Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=1.5)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plot prior
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Samples from prior distribution")
## plot posterior
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Samples from posterior distribution")
fig.suptitle("Matérn kernel", fontsize=18)
plt.tight_layout()
Resumen
En este laboratorio, aprendimos cómo usar diferentes kernels para la regresión de procesos gaussianos en la biblioteca Scikit-learn de Python. Cubrimos los kernels más comúnmente utilizados en la RGP, incluyendo el kernel de función de base radial, el kernel de racional cuadrático, el kernel Exp-Sine-Squared, el kernel de producto punto y el kernel de Matérn. También aprendimos cómo trazar muestras extraídas del proceso gaussiano usando una función auxiliar.
Resumen
¡Felicitaciones! Has completado el laboratorio de Regresión de Procesos Gaussianos: Kernels. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.