Introduction
Dans ce laboratoire, nous allons explorer les processus gaussiens (GP), une méthode d'apprentissage supervisé utilisée pour les problèmes de régression et de classification probabiliste. Les processus gaussiens sont polyvalents et peuvent interpoler des observations, fournir des prédictions probabilistes et gérer différents types de noyaux. Dans ce laboratoire, nous nous concentrerons sur la régression par processus gaussien (GPR) et la classification par processus gaussien (GPC) à l'aide de la bibliothèque scikit-learn.
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 Notebook pour accéder à Jupyter Notebook pour la pratique.
Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
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églerons rapidement le problème pour vous.
Régression par processus gaussien (GPR)
La classe GaussianProcessRegressor implémente des processus gaussiens pour les tâches de régression. Il est nécessaire de spécifier une loi a priori pour le processus gaussien, telle que les fonctions de moyenne et de covariance. Les hyperparamètres du noyau sont optimisés pendant le processus d'ajustement. Voyons un exemple d'utilisation de la GPR pour la régression.
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF
## Créez un modèle GPR avec un noyau RBF
kernel = RBF()
model = GaussianProcessRegressor(kernel=kernel)
## Ajustez le modèle aux données d'entraînement
model.fit(X_train, y_train)
## Faites des prédictions à l'aide du modèle entraîné
y_pred = model.predict(X_test)
Exemples de GPR
GPR avec estimation du niveau de bruit : Cet exemple illustre la GPR avec un noyau somme incluant un WhiteKernel pour estimer le niveau de bruit des données.
from sklearn.gaussian_process.kernels import WhiteKernel
## Créez un modèle GPR avec un noyau RBF et un WhiteKernel
kernel = RBF() + WhiteKernel()
model = GaussianProcessRegressor(kernel=kernel)
## Ajustez le modèle aux données d'entraînement
model.fit(X_train, y_train)
## Faites des prédictions à l'aide du modèle entraîné
y_pred = model.predict(X_test)
Comparaison de la GPR et de la régression ridge noyau : La régression ridge noyau (KRR) et la GPR apprennent une fonction cible en utilisant le "truc du noyau". La GPR apprend un modèle probabiliste génératif et peut fournir des intervalles de confiance, tandis que la KRR ne fournit que des prédictions.
from sklearn.kernel_ridge import KernelRidge
## Créez un modèle de régression ridge noyau
krr_model = KernelRidge(kernel='rbf')
## Ajustez le modèle KRR aux données d'entraînement
krr_model.fit(X_train, y_train)
## Faites des prédictions à l'aide du modèle KRR
krr_y_pred = krr_model.predict(X_test)
## Comparez les résultats avec la GPR
gpr_model = GaussianProcessRegressor(kernel=RBF())
gpr_model.fit(X_train, y_train)
gpr_y_pred = gpr_model.predict(X_test)
GPR sur les données de CO2 de Mauna Loa : Cet exemple démontre la conception complexe de noyau et l'optimisation d'hyperparamètres en utilisant la montée en gradient sur la log-vraisemblance marginale. Les données consistent en concentrations mensuelles moyennes de CO2 atmosphérique collectées à l'Observatoire de Mauna Loa à Hawaii. L'objectif est de modéliser la concentration de CO2 en fonction du temps.
from sklearn.gaussian_process.kernels import RBF, ExpSineSquared, RationalQuadratic, WhiteKernel
## Créez un modèle GPR avec un noyau composé
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)
## Ajustez le modèle aux données
model.fit(X_train, y_train)
## Faites des prédictions à l'aide du modèle entraîné
y_pred = model.predict(X_test)
Classification par processus gaussien (GPC)
La classe GaussianProcessClassifier implémente la GPC pour la classification probabiliste. Elle place une loi a priori de processus gaussien sur une fonction latente, qui est ensuite aplatie à travers une fonction de liaison pour obtenir les probabilités de classe. La GPC prend en charge la classification multi-classe en effectuant soit un contre-tous ou un contre-un basé sur l'entraînement et la prédiction.
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
## Créez un modèle GPC avec un noyau RBF
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)
## Ajustez le modèle aux données d'entraînement
model.fit(X_train, y_train)
## Faites des prédictions à l'aide du modèle entraîné
y_pred = model.predict(X_test)
Exemples de GPC
Prédictions probabilistes avec la GPC : Cet exemple illustre la probabilité prédite de la GPC avec différents choix d'hyperparamètres.
## Créez un modèle GPC avec un noyau RBF
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)
## Ajustez le modèle aux données d'entraînement
model.fit(X_train, y_train)
## Prédisez les probabilités de classe des données de test
y_prob = model.predict_proba(X_test)
Illustration de la GPC sur l'ensemble de données XOR : Cet exemple démontre l'utilisation de la GPC sur l'ensemble de données XOR. Nous comparons les résultats de l'utilisation d'un noyau stationnaire, isotrope (RBF) et d'un noyau non stationnaire (DotProduct).
## Créez des modèles GPC avec différents noyaux
isotropic_kernel = RBF(length_scale=1.0)
non_stationary_kernel = DotProduct(sigma_0=1.0)
## Ajustez les modèles à l'ensemble de données 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)
## Faites des prédictions à l'aide des modèles entraînés
isotropic_y_pred = isotropic_model.predict(X_test)
non_stationary_y_pred = non_stationary_model.predict(X_test)
GPC sur l'ensemble de données iris : Cet exemple illustre la GPC sur l'ensemble de données iris en utilisant un noyau RBF isotrope et un noyau RBF anisotrope. Il montre comment différents choix d'hyperparamètres peuvent affecter la probabilité prédite.
## Créez des modèles GPC avec différents noyaux et ajustez-les à l'ensemble de données 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)
## Prédisez les probabilités de classe
isotropic_y_prob = isotropic_model.predict_proba(X_test)
anisotropic_y_prob = anisotropic_model.predict_proba(X_test)
Sommaire
Dans ce laboratoire, nous avons exploré les processus gaussiens (GP) et leurs applications pour les tâches de régression et de classification. Nous avons appris à utiliser les classes GaussianProcessRegressor et GaussianProcessClassifier de scikit-learn, et à spécifier différents types de noyaux pour les GP. Nous avons également vu des exemples de GPR pour les tâches de régression et de GPC pour les tâches de classification multi-classe, démontrant la polyvalence et les capacités des processus gaussiens.