Regresión y clasificación con Procesos Gaussianos

Introducción

En este laboratorio, exploraremos los Procesos Gaussianos (GP), un método de aprendizaje supervisado utilizado para problemas de regresión y clasificación probabilística. Los Procesos Gaussianos son versátiles y pueden interpolar observaciones, proporcionar predicciones probabilísticas y manejar diferentes tipos de kernels. En este laboratorio, nos centraremos en la Regresión con Procesos Gaussianos (GPR) y la Clasificación con Procesos Gaussianos (GPC) utilizando la biblioteca scikit-learn.

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

Regresión con Procesos Gaussianos (GPR)

La clase GaussianProcessRegressor implementa procesos gaussianos para tareas de regresión. Requiere especificar una distribución a priori para el proceso gaussiano, como las funciones de media y covarianza. Los hiperparámetros del kernel se optimizan durante el proceso de ajuste. Veamos un ejemplo de uso de GPR para la regresión.

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

## Crea un modelo GPR con un kernel RBF
kernel = RBF()
model = GaussianProcessRegressor(kernel=kernel)

## Ajusta el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

## Realiza predicciones utilizando el modelo entrenado
y_pred = model.predict(X_test)

Ejemplos de GPR

GPR con estimación del nivel de ruido: Este ejemplo ilustra GPR con un kernel de suma que incluye un WhiteKernel para estimar el nivel de ruido de los datos.

from sklearn.gaussian_process.kernels import WhiteKernel

## Crea un modelo GPR con un kernel RBF y un WhiteKernel
kernel = RBF() + WhiteKernel()
model = GaussianProcessRegressor(kernel=kernel)

## Ajusta el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

## Realiza predicciones utilizando el modelo entrenado
y_pred = model.predict(X_test)

Comparación de GPR y Regresión Ridge con Kernel: Tanto la regresión ridge con kernel (KRR) como GPR aprenden una función objetivo utilizando el "truco del kernel". GPR aprende un modelo generativo y probabilístico y puede proporcionar intervalos de confianza, mientras que KRR solo proporciona predicciones.

from sklearn.kernel_ridge import KernelRidge

## Crea un modelo de Regresión Ridge con Kernel
krr_model = KernelRidge(kernel='rbf')

## Ajusta el modelo KRR a los datos de entrenamiento
krr_model.fit(X_train, y_train)

## Realiza predicciones utilizando el modelo KRR
krr_y_pred = krr_model.predict(X_test)

## Compara los resultados con GPR
gpr_model = GaussianProcessRegressor(kernel=RBF())
gpr_model.fit(X_train, y_train)
gpr_y_pred = gpr_model.predict(X_test)

GPR en datos de CO2 de Mauna Loa: Este ejemplo demuestra la ingeniería de kernel compleja y la optimización de hiperparámetros utilizando el ascenso del gradiente en la log-verosimilitud marginal. Los datos consisten en concentraciones mensuales promedio de CO2 atmosférico recolectadas en el Observatorio de Mauna Loa en Hawái. El objetivo es modelar la concentración de CO2 como una función del tiempo.

from sklearn.gaussian_process.kernels import RBF, ExpSineSquared, RationalQuadratic, WhiteKernel

## Crea un modelo GPR con un kernel compuesto
kernel = 34.4**2 * RBF(length_scale=41.8) + 3.27**2 * RBF(length_scale=180) * ExpSineSquared(length_scale=1.44, periodicity=1) + 0.446**2 * RationalQuadratic(alpha=17.7, length_scale=0.957) + 0.197**2 * RBF(length_scale=0.138) + WhiteKernel(noise_level=0.0336)
model = GaussianProcessRegressor(kernel=kernel)

## Ajusta el modelo a los datos
model.fit(X_train, y_train)

## Realiza predicciones utilizando el modelo entrenado
y_pred = model.predict(X_test)

Clasificación con Procesos Gaussianos (GPC)

La clase GaussianProcessClassifier implementa GPC para la clasificación probabilística. Coloca una distribución a priori de proceso gaussiano en una función latente, que luego se aplana a través de una función de enlace para obtener las probabilidades de clase. GPC admite la clasificación multi-clase mediante el entrenamiento y la predicción basados en one-versus-rest o one-versus-one.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

X = np.linspace(0, 10, 100).reshape(-1, 1)
y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from sklearn.gaussian_process import GaussianProcessClassifier
## Crea un modelo GPC con un kernel RBF
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)

## Ajusta el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

## Realiza predicciones utilizando el modelo entrenado
y_pred = model.predict(X_test)

Ejemplos de GPC

Predicciones probabilísticas con GPC: Este ejemplo ilustra la probabilidad predicha de GPC con diferentes elecciones de hiperparámetros.

## Crea un modelo GPC con un kernel RBF
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)

## Ajusta el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

## Predice las probabilidades de clase de los datos de prueba
y_prob = model.predict_proba(X_test)

Ilustración de GPC en el conjunto de datos XOR: Este ejemplo demuestra el uso de GPC en el conjunto de datos XOR. Comparamos los resultados de utilizar un kernel estacionario, isotrópico (RBF) y un kernel no estacionario (DotProduct).

## Crea modelos GPC con diferentes kernels
isotropic_kernel = RBF(length_scale=1.0)
non_stationary_kernel = DotProduct(sigma_0=1.0)

## Ajusta los modelos al conjunto de datos XOR
isotropic_model = GaussianProcessClassifier(kernel=isotropic_kernel)
non_stationary_model = GaussianProcessClassifier(kernel=non_stationary_kernel)
isotropic_model.fit(X_xor, y_xor)
non_stationary_model.fit(X_xor, y_xor)

## Realiza predicciones utilizando los modelos entrenados
isotropic_y_pred = isotropic_model.predict(X_test)
non_stationary_y_pred = non_stationary_model.predict(X_test)

GPC en el conjunto de datos iris: Este ejemplo ilustra GPC en el conjunto de datos iris utilizando un kernel RBF isotrópico y un kernel RBF anisotrópico. Muestra cómo diferentes elecciones de hiperparámetros pueden afectar la probabilidad predicha.

## Crea modelos GPC con diferentes kernels y ajusta them al conjunto de datos iris
isotropic_kernel = RBF(length_scale=1.0)
anisotropic_kernel = RBF(length_scale=[1.0, 2.0])
isotropic_model = GaussianProcessClassifier(kernel=isotropic_kernel)
anisotropic_model = GaussianProcessClassifier(kernel=anisotropic_kernel)
isotropic_model.fit(X_train, y_train)
anisotropic_model.fit(X_train, y_train)

## Predice las probabilidades de clase
isotropic_y_prob = isotropic_model.predict_proba(X_test)
anisotropic_y_prob = anisotropic_model.predict_proba(X_test)

Resumen

En este laboratorio, exploramos los Procesos Gaussianos (GP) y sus aplicaciones para tareas de regresión y clasificación. Aprendimos cómo utilizar las clases GaussianProcessRegressor y GaussianProcessClassifier de scikit-learn, y cómo especificar diferentes tipos de kernels para los GP. También vimos ejemplos de GPR para tareas de regresión y GPC para tareas de clasificación multi-clase, lo que demuestra la versatilidad y las capacidades de los Procesos Gaussianos.