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.