Introduction
La régression par processus gaussien est une technique de modélisation statistique utilisée pour prédire le résultat d'une variable cible en fonction de variables d'entrée. La technique modélise la distribution de la variable cible comme un processus gaussien, qui est une collection de variables aléatoires, un nombre fini d'entre elles ayant une distribution gaussienne conjointe. La technique est particulièrement utile dans les cas où la relation entre les variables d'entrée et la variable cible est non linéaire.
Dans ce laboratoire, nous allons apprendre à utiliser la régression par processus gaussien avec estimation du niveau de bruit en Python, en utilisant la bibliothèque scikit-learn.
Conseils sur la VM
Une fois le démarrage de la VM 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ésoudrons rapidement le problème pour vous.
Génération de données
Dans cette étape, nous allons générer quelques données avec une seule caractéristique en utilisant une fonction sinus.
import numpy as np
def target_generator(X, add_noise=False):
target = 0.5 + np.sin(3 * X)
if add_noise:
rng = np.random.RandomState(1)
target += rng.normal(0, 0.3, size=target.shape)
return target.squeeze()
X = np.linspace(0, 5, num=30).reshape(-1, 1)
y = target_generator(X, add_noise=False)
Visualisation des données
Dans cette étape, nous allons visualiser les données générées.
import matplotlib.pyplot as plt
plt.plot(X, y, label="Expected signal")
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")
Ajout de bruit
Dans cette étape, nous allons ajouter du bruit aux données générées pour créer un ensemble de données d'entraînement plus réaliste.
rng = np.random.RandomState(0)
X_train = rng.uniform(0, 5, size=20).reshape(-1, 1)
y_train = target_generator(X_train, add_noise=True)
Visualisation des données
Dans cette étape, nous allons visualiser l'ensemble de données d'entraînement bruité ainsi que le signal attendu.
plt.plot(X, y, label="Expected signal")
plt.scatter(
x=X_train[:, 0],
y=y_train,
color="black",
alpha=0.4,
label="Observations",
)
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")
Régression par processus gaussien
Dans cette étape, nous allons créer un régresseur par processus gaussien en utilisant un noyau additif en ajoutant les noyaux RBF et WhiteKernel. Le noyau WhiteKernel est un noyau qui sera capable d'estimer la quantité de bruit présent dans les données tandis que le RBF servira à ajuster la non-linéarité entre les données et la cible.
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel
kernel = 1.0 * RBF(length_scale=1e-1, length_scale_bounds=(1e-2, 1e3)) + WhiteKernel(
noise_level=1e-2, noise_level_bounds=(1e-10, 1e1)
)
gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0)
gpr.fit(X_train, y_train)
y_mean, y_std = gpr.predict(X, return_std=True)
Visualisation des données
Dans cette étape, nous allons visualiser les prédictions effectuées par le régresseur par processus gaussien.
plt.plot(X, y, label="Expected signal")
plt.scatter(x=X_train[:, 0], y=y_train, color="black", alpha=0.4, label="Observations")
plt.errorbar(X, y_mean, y_std)
plt.legend()
plt.xlabel("X")
plt.ylabel("y")
_ = plt.title(
(
f"Initial: {kernel}\nOptimum: {gpr.kernel_}\nLog-Marginal-Likelihood: "
f"{gpr.log_marginal_likelihood(gpr.kernel_.theta)}"
),
fontsize=8,
)
Log-Vraisemblance Marginale
Dans cette étape, nous allons examiner la Log-Vraisemblance Marginale (LML) du GaussianProcessRegressor pour différents paramètres hypermétriques pour avoir une idée des minima locaux.
from matplotlib.colors import LogNorm
length_scale = np.logspace(-2, 4, num=50)
noise_level = np.logspace(-2, 1, num=50)
length_scale_grid, noise_level_grid = np.meshgrid(length_scale, noise_level)
log_marginal_likelihood = [
gpr.log_marginal_likelihood(theta=np.log([0.36, scale, noise]))
for scale, noise in zip(length_scale_grid.ravel(), noise_level_grid.ravel())
]
log_marginal_likelihood = np.reshape(
log_marginal_likelihood, newshape=noise_level_grid.shape
)
vmin, vmax = (-log_marginal_likelihood).min(), 50
level = np.around(np.logspace(np.log10(vmin), np.log10(vmax), num=50), decimals=1)
plt.contour(
length_scale_grid,
noise_level_grid,
-log_marginal_likelihood,
levels=level,
norm=LogNorm(vmin=vmin, vmax=vmax),
)
plt.colorbar()
plt.xscale("log")
plt.yscale("log")
plt.xlabel("Length-scale")
plt.ylabel("Noise-level")
plt.title("Log-marginal-likelihood")
plt.show()
Conclusion
Dans ce laboratoire, nous avons appris à utiliser la régression par processus gaussien avec estimation du niveau de bruit en Python, en utilisant la bibliothèque scikit-learn. Nous avons généré des données avec une seule caractéristique en utilisant une fonction sinus, ajouté du bruit aux données générées pour créer un ensemble de données d'entraînement plus réaliste, et visualisé les données générées. Nous avons créé un régresseur par processus gaussien en utilisant un noyau additif en ajoutant les noyaux RBF et WhiteKernel, et visualisé les prédictions effectuées par le régresseur par processus gaussien. Nous avons également examiné la Log-Vraisemblance Marginale (LML) du GaussianProcessRegressor pour différents paramètres hypermétriques pour avoir une idée des minima locaux.
Sommaire
Félicitations ! Vous avez terminé le laboratoire sur la régression par processus gaussien. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.