Processus Gaussien : Guide complet — Régression Bayésienne Non-Paramétrique

Résumé — Les Processus Gaussiens (GP) sont une approche bayésienne non-paramétrique de la régression qui modélise directement une distribution sur les fonctions. Contrairement aux modèles paramétriques (comme la régression linéaire) qui apprennent un ensemble fixe de paramètres, un GP apprend une distribution complete de fonctions possibles compatibles avec les données observées. Le résultat: des prédictions avec des barres d’incertitude quantifiables, ce qui est crucial pour les applications sensibles comme le contrôle industriel, la médecine ou la prise de décision sous incertitude.

Principe mathématique

1. Définition du processus gaussien

Un processus gaussien est une distribution sur les fonctions f(x) complètement spécifiée par sa fonction de moyenne m(x) et sa fonction de covariance (noyau) k(x,x’) :

f(x) ~ GP(m(x), k(x,x'))

Pour tout ensemble fini de points X = {x₁, …, xₙ}, les valeurs f(X) suivent une distribution gaussienne multivariée:

f(X) ~ N(m(X), K(X,X))

Où K est la matrice de Gram (ou matrice de covariance) avec K_{ij} = k(x_i, x_j).

2. Prédiction bayésienne

Étant donné des observations y = f(X) + ε où ε ~ N(0, sigma_n² · I), la distribution prédictive à de nouveaux points X* est:

f* | X, y, X* ~ N(μ*, Σ*)

μ* = k(X*, X) · [K(X, X) + sigma_n² · I]^{-1} · y

Σ* = k(X*, X*) - k(X*, X) · [K(X, X) + sigma_n² · I]^{-1} · k(X, X*)

Le point clé: Σ donne l’incertitude épistémique* — combien le modèle est incertain à cause du manque de données dans cette région de l’espace d’entrée.

3. Fonctions de covariance (noyaux)

RBF (Radial Basis Function / Squared Exponential) :

k(x, x') = sigma² · exp(-||x - x'||² / (2 · l²))

C’est le noyau le plus utilisé. l (longueur de corrélation) contrôle la douceur: petit l = variations rapides, grand l = variations lisses.

Matérn :

k_Matern(x, x') = sigma² · 2^(1-nu) / Gamma(nu) · (sqrt(2·nu) · r / l)^nu · K_nu(sqrt(2·nu) · r / l)

Où r = ||x – x’||, K_nu est la fonction de Bessel modifiée, et nu contrôle la régularité. nu = 3/2 ou 5/2 sont des choix courants (plus lisses que RBF pour nu > 0.5).

Périodique :

k_periodic(x, x') = sigma² · exp(-2 · sin²(pi · ||x - x'|| / p) / l²)

Pour les données avec patterns périodiques (saisonnalité, cycles).

4. Optimisation des hyperparamètres

Les hyperparamètres du noyau (l, sigma, etc.) sont optimisés en maximisant la vraisemblance marginale logarithmique :

log p(y | X, theta) = -1/2 · y^T · K_y^{-1} · y - 1/2 · log|K_y| - n/2 · log(2·pi)

Où K_y = K(X, X) + sigma_n² · I. Le premier terme pénalise un mauvais ajustement, le second contrôle la complexité du modèle (régularisation automatique dite Occam’s razor).

Intuition

Imaginez un dessinateur à qui on montre quelques points sur un graphique et on lui demande de tracer la courbe qui les relie.

Le dessinateur ne trace pas une seule courbe — il imagine un faisceau de milliers de courbes qui passent toutes près des points observés. Là où les points sont nombreux et rapprochés, toutes les courbes se ressemblent (grande confiance). Là où il n’y a aucun point, les courbes divergent en tout sens (grande incertitude).

Un Processus Gaussien, c’est exactement ça: il ne prédit pas une seule valeur, il prédit une distribution de valeurs possibles avec leur probabilité. C’est le seul modèle de machine learning qui vous dit honnêtement « je ne sais pas » — et c’est sa plus grande force.

Implémentation Python

1. GP Regression avec scikit-learn

import numpy as np
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel
from sklearn.gaussian_process.kernels import Matern
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

# Données synthétiques 1D bruitées
np.random.seed(42)
X = np.array([[0.0], [0.3], [0.6], [0.8], [1.0]])
y = np.sin(3 * X.ravel() + 0.5) + 0.1 * np.random.randn(5)

# Noyau: Constant * RBF + White (bruit)
kernel = ConstantKernel(1.0) * RBF(length_scale=0.5) + WhiteKernel(noise_level=0.1)

# Création et entraînement du GP
gp = GaussianProcessRegressor(
    kernel=kernel,
    alpha=0.0,  # bruit déjà dans le kernel
    n_restarts_optimizer=10,  # éviter les minima locaux
    normalize_y=True
)
gp.fit(X, y)

print(f"Noyau optimisé: {gp.kernel_}")
print(f"Log-marginal-likelihood: {gp.log_marginal_likelihood(gp.kernel_.theta):.3f}")

# Prédictions avec intervalle de confiance
X_plot = np.linspace(-0.3, 1.5, 300).reshape(-1, 1)
y_pred, sigma = gp.predict(X_plot, return_std=True)

# Visualisation
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Prédiction + incertitude
ax1.fill_between(X_plot.ravel(),
                 y_pred - 1.96 * sigma,
                 y_pred + 1.96 * sigma,
                 alpha=0.2, label='95% intervalle de confiance')
ax1.plot(X_plot, y_pred, 'b-', label='Prédiction GP')
ax1.plot(X, y, 'ro', markersize=8, label='Observations')
ax1.fill_between(X_plot.ravel(),
                 np.sin(3*X_plot.ravel() + 0.5) - 0.2,
                 np.sin(3*X_plot.ravel() + 0.5) + 0.2,
                 alpha=0.1, color='green', label='Vraie fonction +/- bruit')
ax1.set_title('Processus Gaussien: Prédiction + Incertitude')
ax1.legend()
ax1.set_xlabel('x')
ax1.set_ylabel('y')

# L'échantillons du processus a posteriori
y_samples = gp.sample_y(X_plot, n_samples=8)
ax2.plot(X_plot, y_samples, alpha=0.6)
ax2.plot(X, y, 'ro', markersize=8, label='Observations')
ax2.set_title('8 échantillons du processus a posteriori')
ax2.legend()

plt.tight_layout()
plt.savefig('gaussian_process.png', dpi=150)
print('Visualisation sauvegardée!')

# Comparaison avec différents noyaux
kernels_to_test = [
    RBF(length_scale=1.0),
    Matern(length_scale=1.0, nu=1.5),
    Matern(length_scale=1.0, nu=2.5),
    ConstantKernel(1.0) * RBF(length_scale=1.0),
]

for i, k in enumerate(kernels_to_test):
    gp_test = GaussianProcessRegressor(kernel=k, n_restarts_optimizer=15)
    gp_test.fit(X, y)
    print(f'Kernel {i+1}: {gp_test.kernel_} | LML: {gp_test.log_marginal_likelihood():.3f}')

Hyperparamètres

Avantages

1. Incertitude quantifiée : Le GP fournit des intervalles de confiance exacts, pas des approximations. Indispensable pour la prise de décision critique.
2. Pas de surapprentissage : La maximisation de la vraisemblance marginale agit comme une régularisation automatique. Le GP choisit le niveau de complexité adapté aux données.
3. Peu de données nécessaires : Contrairement aux réseaux profonds, les GP fonctionnent bien avec 10-50 points seulement. Idéal pour les expériences coûteuses.
4. Pas d’entraînement itératif : La “fit” est une optimisation analytique des hyperparamètres du noyau. Pas de learning rate, pas d’épochs, pas de risque de non-convergence.

Limites

1. Complexité cubique O(n³) : L’inversion de la matrice K (de taille n×n) coûte O(n³). Au-delà de ~10 000 points, c’est impraticable sans approximations (Sparse GPs, inducing points).
2. Choix du noyau : Le résultat dépend fortement du noyau choisi. Un mauvais noyau donne de mauvaises prédictions. L’expertise du pratiquant est nécessaire.
3. Hypothèse gaussienne : Le GP suppose que les données suivent une distribution gaussienne. Pour des données fortement asymétriques ou multi-modales, c’est inadéquat.
4. Non-stationnarité : Les noyaux standards supposent que la covariance dépend uniquement de la distance entre points. Si la régularité de la fonction varie selon la région, il faut des noyaux non-stationnaires (plus complexes).

4 cas d’usage concrets

1. Optimisation bayésienne d’hyperparamètres

Le GP est le modèle de surrogate par excellence dans l’optimisation bayésienne (cf. article 133). Il modélise la fonction coût inconnue f(learning_rate, batch_size, …) et guide la recherche vers les régions prometteuses.

2. Calibration de capteurs industriels

Quand un capteur coûte cher à calibrer (chaque mesure prend des heures), le GP interpole entre les points de calibration mesurés et fournit une incertitude pour chaque prédiction. L’ingénieur sait alors quand recalibrer.

3. Prédiction de consommation énergétique

Avec des données saisonnières (cycles jour/nuit, semaine), un GP avec noyau périodique + RBF capture les patterns de consommation et quantifie l’incertitude, permettant un dimensionnement adapté des réserves d’énergie.

4. Modélisation pharmacocinétique

Dans l’industrie pharmaceutique, le GP modélise la concentration d’un médicament dans le sang en fonction du temps et de la dose, avec des intervalles de confiance rigoureux pour les essais cliniques.

Conclusion

Les Processus Gaussiens représentent l’un des outils les plus élégants du machine learning: une approche rigoureusement bayésienne qui fournit des prédictions avec des garanties d’incertitude. Alors que le deep learning domine les applications à grande échelle, les GP restent imbattables pour les problèmes de petite taille où l’incertitude compte autant que la prédiction elle-même.

Les approximations modernes (Sparse GPs avec points inducteurs, Deep Kernel Learning qui combine GPs et réseaux profonds) étendent l’applicabilité des GPs à des échelles toujours plus grandes, préservant leur avantage fondamental: quantifier l’incertitude.

Voir aussi

• Calcul de la Somme des Produits en Python : Guide Complet et Astuces Pratiques
• Explorer les Nombres de $k$-Markov avec Python : Guide Complet pour Algorithmes et Programmation