Prédictions probabilistes avec la classification par processus gaussien

Introduction

Dans ce laboratoire, nous explorerons la classification par processus gaussien (GPC) avec un noyau RBF et différents choix d'hyperparamètres. Nous générerons des données, entraînerons le modèle GPC avec des hyperparamètres fixes et optimisés, et traçons les postérieurs et le paysage de la log-vraisemblance marginale. Nous évaluerons également la précision et la log-perte du modèle.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Nous allons importer les bibliothèques nécessaires pour ce laboratoire.

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

Générer des données

Nous allons générer des données à l'aide de NumPy. Nous allons générer 100 points de données avec une distribution uniforme entre 0 et 5. Nous allons définir le seuil à 2,5 et générer les étiquettes à l'aide d'une expression booléenne. Nous utiliserons les 50 premiers points de données comme données d'entraînement et les autres comme données de test.

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)

Entraîner le modèle

Nous allons entraîner le modèle GPC en utilisant des hyperparamètres fixes et optimisés. Nous allons afficher la log-vraisemblance marginale, la précision et la log-perte des modèles.

## 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])))

Tracer les postérieurs

Nous allons tracer les postérieurs du modèle GPC en utilisant des hyperparamètres fixes et optimisés. Nous allons tracer les données d'entraînement, les données de test et la probabilité prédite de la classe 1. Nous allons également étiqueter les graphiques.

## 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")

Tracer le paysage de la log-vraisemblance marginale

Nous allons tracer le paysage de la log-vraisemblance marginale du modèle GPC en utilisant différents choix d'hyperparamètres. Nous allons souligner les hyperparamètres utilisés dans le graphique précédent. Nous allons également étiqueter les graphiques.

## 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")

Sommaire

Dans ce laboratoire, nous avons exploré la classification par processus gaussien (GPC) avec un noyau RBF et différents choix d'hyperparamètres. Nous avons généré des données, entraîné le modèle GPC avec des hyperparamètres fixes et optimisés, et tracé les postérieurs et le paysage de la log-vraisemblance marginale. Nous avons également évalué la précision et la log-perte du modèle.