Predicciones probabilísticas con Clasificación por Procesos Gaussianos

Introducción

En este laboratorio, exploraremos la clasificación por procesos gaussianos (GPC, por sus siglas en inglés) con un kernel RBF y diferentes elecciones de hiperparámetros. Generaremos datos, entrenaremos el modelo GPC con hiperparámetros fijos y optimizados, y graficaremos las posteriores y el paisaje de la verosimilitud marginal logarítmica. También evaluaremos la precisión y la pérdida logarítmica del modelo.

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.

Skills Graph

Importar bibliotecas

Importaremos las bibliotecas necesarias para este laboratorio.

import numpy as np
from matplotlib import pyplot as plt
from sklearn.metrics import accuracy_score, log_loss
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

Generar datos

Generaremos datos utilizando NumPy. Generaremos 100 puntos de datos con una distribución uniforme entre 0 y 5. Estableceremos el umbral en 2.5 y generaremos las etiquetas utilizando una expresión booleana. Utilizaremos los primeros 50 puntos de datos como datos de entrenamiento y el resto como datos de prueba.

train_size = 50
rng = np.random.RandomState(0)
X = rng.uniform(0, 5, 100)[:, np.newaxis]
y = np.array(X[:, 0] > 2.5, dtype=int)

Entrenar el modelo

Entrenaremos el modelo GPC utilizando hiperparámetros fijos y optimizados. Imprimiremos la verosimilitud marginal logarítmica, la precisión y la pérdida logarítmica de los modelos.

## Fixed Hyperparameters
gp_fix = GaussianProcessClassifier(kernel=1.0 * RBF(length_scale=1.0), optimizer=None)
gp_fix.fit(X[:train_size], y[:train_size])

## Optimized Hyperparameters
gp_opt = GaussianProcessClassifier(kernel=1.0 * RBF(length_scale=1.0))
gp_opt.fit(X[:train_size], y[:train_size])

## Results
print("Log Marginal Likelihood (initial): %.3f" % gp_fix.log_marginal_likelihood(gp_fix.kernel_.theta))
print("Log Marginal Likelihood (optimized): %.3f" % gp_opt.log_marginal_likelihood(gp_opt.kernel_.theta))
print("Accuracy: %.3f (initial) %.3f (optimized)" % (accuracy_score(y[:train_size], gp_fix.predict(X[:train_size])), accuracy_score(y[:train_size], gp_opt.predict(X[:train_size]))))
print("Log-loss: %.3f (initial) %.3f (optimized)" % (log_loss(y[:train_size], gp_fix.predict_proba(X[:train_size])[:, 1]), log_loss(y[:train_size], gp_opt.predict_proba(X[:train_size])[:, 1])))

Graficar las posteriores

Graficaremos las posteriores del modelo GPC utilizando hiperparámetros fijos y optimizados. Graficaremos los datos de entrenamiento, los datos de prueba y la probabilidad predicha de la clase 1. También etiquetaremos las gráficas.

## Plot posteriors
plt.figure()
plt.scatter(X[:train_size, 0], y[:train_size], c="k", label="Train data", edgecolors=(0, 0, 0))
plt.scatter(X[train_size:, 0], y[train_size:], c="g", label="Test data", edgecolors=(0, 0, 0))
X_ = np.linspace(0, 5, 100)
plt.plot(X_, gp_fix.predict_proba(X_[:, np.newaxis])[:, 1], "r", label="Initial kernel: %s" % gp_fix.kernel_)
plt.plot(X_, gp_opt.predict_proba(X_[:, np.newaxis])[:, 1], "b", label="Optimized kernel: %s" % gp_opt.kernel_)
plt.xlabel("Feature")
plt.ylabel("Class 1 probability")
plt.xlim(0, 5)
plt.ylim(-0.25, 1.5)
plt.legend(loc="best")

Graficar el paisaje de la verosimilitud marginal logarítmica

Graficaremos el paisaje de la verosimilitud marginal logarítmica del modelo GPC utilizando diferentes elecciones de hiperparámetros. Destacaremos los hiperparámetros utilizados en la gráfica anterior. También etiquetaremos las gráficas.

## Plot LML landscape
plt.figure()
theta0 = np.logspace(0, 8, 30)
theta1 = np.logspace(-1, 1, 29)
Theta0, Theta1 = np.meshgrid(theta0, theta1)
LML = [[gp_opt.log_marginal_likelihood(np.log([Theta0[i, j], Theta1[i, j]])) for i in range(Theta0.shape[0])] for j in range(Theta0.shape[1])]
LML = np.array(LML).T
plt.plot(np.exp(gp_fix.kernel_.theta)[0], np.exp(gp_fix.kernel_.theta)[1], "ko", zorder=10)
plt.plot(np.exp(gp_opt.kernel_.theta)[0], np.exp(gp_opt.kernel_.theta)[1], "ko", zorder=10)
plt.pcolor(Theta0, Theta1, LML)
plt.xscale("log")
plt.yscale("log")
plt.colorbar()
plt.xlabel("Magnitude")
plt.ylabel("Length-scale")
plt.title("Log-marginal-likelihood")

Resumen

En este laboratorio, exploramos la Clasificación por Procesos Gaussianos (GPC) con un kernel RBF y diferentes elecciones de hiperparámetros. Generamos datos, entrenamos el modelo GPC con hiperparámetros fijos y optimizados, y graficamos las posteriores y el paisaje de la verosimilitud marginal logarítmica. También evaluamos la precisión y la pérdida logarítmica del modelo.