Régression par processus gaussien : noyaux

Introduction

Ce laboratoire montre comment utiliser différents noyaux pour la régression par processus gaussien (GPR) dans la bibliothèque Scikit-learn de Python. La GPR est une technique de régression non paramétrique qui peut ajuster des modèles complexes aux données bruitées. Une fonction noyau est utilisée pour déterminer la similarité entre deux points d'entrée quelconques. Le choix de la fonction noyau est important, car il détermine la forme du modèle qui est ajusté aux données. Dans ce laboratoire, nous allons aborder les noyaux les plus couramment utilisés en GPR.

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 votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Nous commençons par importer les bibliothèques nécessaires.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, RationalQuadratic, ExpSineSquared, ConstantKernel, DotProduct, Matern

Création des données d'entraînement

Ensuite, nous créons un ensemble de données d'entraînement que nous utiliserons dans les différentes sections.

rng = np.random.RandomState(4)
X_train = rng.uniform(0, 5, 10).reshape(-1, 1)
y_train = np.sin((X_train[:, 0] - 2.5) ** 2)
n_samples = 5

Fonction d'aide

Avant de présenter chacun des noyaux disponibles pour les processus gaussiens, nous définirons une fonction d'aide permettant de tracer des échantillons tirés du processus gaussien.

def plot_gpr_samples(gpr_model, n_samples, ax):
    """Trace des échantillons tirés du modèle de processus gaussien.

    Si le modèle de processus gaussien n'est pas entraîné, les échantillons tirés sont
    tirés de la distribution a priori. Sinon, les échantillons sont tirés de
    la distribution a posteriori. Sachez qu'un échantillon ici correspond à une
    fonction.

    Paramètres
    ----------
    gpr_model : `GaussianProcessRegressor`
        Un modèle :class:`~sklearn.gaussian_process.GaussianProcessRegressor`.
    n_samples : int
        Le nombre d'échantillons à tirer de la distribution du processus gaussien.
    ax : axe matplotlib
        L'axe matplotlib où tracer les échantillons.
    """
    x = np.linspace(0, 5, 100)
    X = x.reshape(-1, 1)

    y_mean, y_std = gpr_model.predict(X, return_std=True)
    y_samples = gpr_model.sample_y(X, n_samples)

    for idx, single_prior in enumerate(y_samples.T):
        ax.plot(
            x,
            single_prior,
            linestyle="--",
            alpha=0.7,
            label=f"Fonction échantillonnée #{idx + 1}",
        )
    ax.plot(x, y_mean, color="black", label="Moyenne")
    ax.fill_between(
        x,
        y_mean - y_std,
        y_mean + y_std,
        alpha=0.1,
        color="black",
        label=r"$\pm$ 1 écart-type.",
    )
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_ylim([-3, 3])

Noyau de fonction de base radiale

Le noyau de fonction de base radiale (RBF) est défini comme suit :

k(x_i, x_j) = \exp \left( -\frac{\|x_i - x_j\|^2}{2\ell^2} \right)

où \ell est le paramètre d'échelle de longueur.

kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-1, 10.0))
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)

fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))

## trace la distribution a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Echantillons de la distribution a priori")

## trace la distribution a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Echantillons de la distribution a posteriori")

fig.suptitle("Noyau de fonction de base radiale", fontsize=18)
plt.tight_layout()

Noyau quadratique rationnel

Le noyau quadratique rationnel est défini comme suit :

k(x_i, x_j) = \left( 1 + \frac{\|x_i - x_j\|^2}{2\alpha\ell^2} \right)^{-\alpha}

où \ell est le paramètre d'échelle de longueur et \alpha contrôle le poids relatif des caractéristiques à petite et à grande échelle.

kernel = 1.0 * RationalQuadratic(length_scale=1.0, alpha=0.1, alpha_bounds=(1e-5, 1e15))
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)

fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))

## trace la distribution a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Echantillons de la distribution a priori")

## trace la distribution a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Echantillons de la distribution a posteriori")

fig.suptitle("Noyau quadratique rationnel", fontsize=18)
plt.tight_layout()

Noyau Exp-Sine-Squared

Le noyau Exp-Sine-Squared est défini comme suit :

k(x_i, x_j) = \exp \left( -\frac{2\sin^2(\pi\|x_i - x_j\|/p)}{\ell^2} \right)

où \ell est le paramètre d'échelle de longueur et p contrôle la périodicité.

kernel = 1.0 * ExpSineSquared(
    length_scale=1.0,
    periodicity=3.0,
    length_scale_bounds=(0.1, 10.0),
    periodicity_bounds=(1.0, 10.0),
)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)

fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))

## trace la distribution a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Echantillons de la distribution a priori")

## trace la distribution a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Echantillons de la distribution a posteriori")

fig.suptitle("Noyau Exp-Sine-Squared", fontsize=18)
plt.tight_layout()

Noyau de produit scalaire

Le noyau de produit scalaire est défini comme suit :

k(x_i, x_j) = (\sigma_0 + x_i^T x_j)^2

où \sigma_0 est une constante.

kernel = ConstantKernel(0.1, (0.01, 10.0)) * (
    DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0)) ** 2
)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)

fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))

## trace la distribution a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Echantillons de la distribution a priori")

## trace la distribution a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Echantillons de la distribution a posteriori")

fig.suptitle("Noyau de produit scalaire", fontsize=18)
plt.tight_layout()

Noyau de Matérn

Le noyau de Matérn est défini comme suit :

k(x_i, x_j) = \frac{1}{\Gamma(\nu)2^{\nu-1}}\left(\frac{\sqrt{2\nu}}{\ell}\|x_i - x_j\|\right)^\nu K_\nu\left(\frac{\sqrt{2\nu}}{\ell}\|x_i - x_j\|\right)

où \ell est le paramètre d'échelle de longueur et \nu contrôle la régularité de la fonction.

kernel = 1.0 * Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=1.5)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)

fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))

## trace la distribution a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Echantillons de la distribution a priori")

## trace la distribution a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observations")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Echantillons de la distribution a posteriori")

fig.suptitle("Noyau de Matérn", fontsize=18)
plt.tight_layout()

Sommaire

Dans ce laboratoire, nous avons appris à utiliser différents noyaux pour la régression par processus gaussien dans la bibliothèque Scikit-learn de Python. Nous avons abordé les noyaux les plus couramment utilisés en RGP, y compris le noyau de fonction de base radiale, le noyau quadratique rationnel, le noyau Exp-Sine-Squared, le noyau de produit scalaire et le noyau de Matérn. Nous avons également appris à tracer des échantillons tirés du processus gaussien à l'aide d'une fonction d'aide.

Sommaire

Félicitations ! Vous avez terminé le laboratoire Régression par processus gaussien : noyaux. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.