Une régression qui ne donne pas seulement une prévision, mais aussi la marge d'erreur qui va avec, point par point. Là où les données sont nombreuses, l'intervalle est serré ; dès qu'on s'en éloigne, il s'élargit. C'est l'outil de choix pour décider sur peu de données, quand savoir ce que l'on ne sait pas compte autant que la prévision.
Un agent immobilier estime un bien d'après les ventes voisines. Au cœur d'un quartier bien connu, il est précis. Pour une maison atypique, loin de toute référence, il élargit sa fourchette. Le processus gaussien fait exactement cela, avec des chiffres.
Un noyau mesure à quel point deux observations se ressemblent. Deux magasins de surface et de budget proches doivent avoir des CA proches. La portée de chaque variable dit à partir de quelle distance on ne se ressemble plus.
Le modèle ajuste les portées et le niveau de bruit pour expliquer au mieux les CA observés, par maximum de vraisemblance.
Pour un nouveau cas, la prévision est une moyenne pondérée des cas ressemblants. L'écart-type dépend de la proximité des données : faible au milieu des observations, fort en terrain inconnu.
Surface, budget publicitaire local, nombre de concurrents, zone (centre-ville, périphérie, rural) et chiffre d'affaires annuel. La direction du développement étudie deux projets d'ouverture.
Sur le jeu d'exemple, un magasin de 1 500 m² en périphérie est prévu vers 826 k€ (intervalle à 95 % : 686 à 966 k€). Un projet de 4 000 m², plus grand que tout le réseau, reçoit une fourchette plus large (± 205 k€ contre ± 140 k€) : le modèle signale qu'il sort de son terrain connu.
L'erreur absolue moyenne en k€ dit si la prévision est utile. Il faut aussi vérifier que l'intervalle à 95 % contient bien environ 95 % des CA réels de magasins de test : sinon, la fourchette est trompeuse. Ici, 98 %.
Noms donnés pour R (DiceKriging) et Python (scikit-learn). Les paramètres du noyau sont appris par le modèle ; ce qui compte, c'est la forme qu'on lui donne.
Le noyau gaussien (RBF) suppose une fonction très lisse. Le noyau de Matérn, plus souple, est souvent plus réaliste. Pour une saisonnalité, on ajoute un noyau périodique.
Avec une portée par variable (ARD), le modèle apprend lesquelles comptent : une portée très grande signifie que la variable influe peu. Mettre les variables à l'échelle avant, pour que l'optimisation parte sur de bonnes bases.
Sans terme de bruit, le modèle passe exactement par chaque point observé et surapprend. Avec, il sépare la tendance du bruit, et l'intervalle couvre les aléas réels.
# CA des magasins : processus gaussien en R
library(DiceKriging)
magasins <- read.csv("magasins.csv")
X <- data.frame(surface_m2 = magasins$surface_m2, budget_pub_k = magasins$budget_pub_k,
nb_concurrents = magasins$nb_concurrents,
zone_peripherie = as.numeric(magasins$zone == "peripherie"),
zone_rural = as.numeric(magasins$zone == "rural"))
set.seed(42)
idx <- sample(nrow(X), round(0.75 * nrow(X)))
# Noyau gaussien (une portée par variable) + bruit estimé (nugget)
modele <- km(design = X[idx, ], response = magasins$ca_k[idx], covtype = "gauss",
nugget.estim = TRUE, control = list(trace = FALSE))
pred <- predict(modele, newdata = X[-idx, ], type = "UK", checkNames = FALSE)
reel <- magasins$ca_k[-idx]
cat("Erreur absolue moyenne (k€) :", round(mean(abs(reel - pred$mean)), 1), "\n")
cat("Part des CA réels dans l'intervalle à 95 % :", round(mean(reel >= pred$lower95 & reel <= pred$upper95), 2), "\n")
# Deux projets en périphérie : 1 500 m² (cas courant) et 4 000 m² (jamais vu)
projets <- data.frame(surface_m2 = c(1500, 4000), budget_pub_k = 15, nb_concurrents = 3,
zone_peripherie = 1, zone_rural = 0)
p <- predict(modele, newdata = projets, type = "UK", checkNames = FALSE)
print(round(data.frame(surface = projets$surface_m2, prevision = p$mean, bas = p$lower95, haut = p$upper95)))# CA des magasins : processus gaussien en Python
import numpy as np
import pandas as pd
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel, ConstantKernel
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
magasins = pd.read_csv("magasins.csv")
X = pd.get_dummies(magasins[["surface_m2", "budget_pub_k", "nb_concurrents", "zone"]], drop_first=True, dtype=float)
y = magasins["ca_k"].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
echelle = StandardScaler().fit(X_train)
# Noyau : similarité entre magasins (une portée par variable) + bruit de mesure
noyau = ConstantKernel() * RBF(length_scale=np.ones(X.shape[1])) + WhiteKernel()
modele = GaussianProcessRegressor(kernel=noyau, normalize_y=True, random_state=42)
modele.fit(echelle.transform(X_train), y_train)
moy, ecart = modele.predict(echelle.transform(X_test), return_std=True)
print("Erreur absolue moyenne (k€) :", round(np.mean(np.abs(y_test - moy)), 1))
print("Part des CA réels dans l'intervalle à 95 % :", round(np.mean(np.abs(y_test - moy) <= 1.96 * ecart), 2))
# Deux projets en périphérie : 1 500 m² (cas courant) et 4 000 m² (jamais vu)
projets = pd.DataFrame({"surface_m2": [1500, 4000], "budget_pub_k": 15, "nb_concurrents": 3,
"zone_peripherie": 1.0, "zone_rural": 0.0})
m, s = modele.predict(echelle.transform(projets), return_std=True)
for i in range(2):
print(f"{projets.surface_m2[i]} m² : {m[i]:.0f} k€, intervalle à 95 % [{m[i] - 1.96 * s[i]:.0f} ; {m[i] + 1.96 * s[i]:.0f}]")C'est un modèle de régression qui considère la fonction à apprendre comme inconnue et aléatoire. À partir des données observées, il en déduit pour chaque nouveau point une prévision moyenne et un écart-type. La forme des fonctions possibles est fixée par un noyau de similarité.
Aucune sur le fond. Le krigeage est le nom donné en géostatistique, où la méthode est née pour estimer des teneurs de minerai entre deux forages. Le terme processus gaussien vient des statistiques et du machine learning.
L'entraînement exige d'inverser une matrice de taille n par n, où n est le nombre de lignes. Le temps de calcul croît comme le cube de n : 10 fois plus de données, 1 000 fois plus de calcul. Des approximations (points d'induction, GPyTorch) repoussent cette limite.
Donne aussi un intervalle de prévision, mais suppose une relation en ligne droite partout.
Voir la fiche → l'autre fourchettePrévoit directement les bornes basse et haute. Passe mieux à grande échelle, sans cadre probabiliste complet.
Voir la fiche → l'usage phareUtilise un processus gaussien pour choisir le prochain essai là où le gain espéré est le plus fort.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus