Régression Quantile : Guide complet — Principes, Exemples et Implémentation Python

Résumé — La régression quantile est une technique d’apprentissage supervisé qui permet d’estimer les quantiles conditionnels d’une variable cible, au-delà de la simple moyenne. Contrairement à la régression linéaire ordinaire, elle fournit une vision plus complète de la distribution conditionnelle de la cible. Elle est particulièrement utile pour construire des intervalles de prédiction, analyser l’hétéroscédasticité et modéliser le risque.

Principe mathématique

La régression quantile a été introduite par Roger Koenker et Gilbert Bassett en 1978. Son idée fondamentale consiste à remplacer la minimisation de l’erreur quadratique moyenne par la minimisation d’une fonction de perte asymétrique, appelée pinball loss ou check loss.

Le quantile conditionnel

En régression linéaire classique, on modélise :

$$
\mathbb{E}[Y \mid X=x]
$$

c’est-à-dire la moyenne conditionnelle de $Y$ sachant $X=x$.

En régression quantile, on cherche plutôt à modéliser :

$$
Q_\tau(Y \mid X=x)
$$

où $Q_\tau$ désigne le quantile d’ordre $\tau$, avec $\tau \in (0,1)$.

Par exemple :

• $\tau = 0{,}5$ correspond à la médiane conditionnelle ;
• $\tau = 0{,}25$ correspond au premier quartile ;
• $\tau = 0{,}75$ correspond au troisième quartile.

La fonction de perte pinball

Pour un quantile d’ordre $\tau$, la fonction de perte est définie par :

$$
\rho_\tau(u) = u \, (\tau – \mathbf{1}_{u < 0})
$$

où :

• $u = y_i – \hat{y}_i$ est le résidu ;
• $y_i$ est la valeur observée ;
• $\hat{y}_i$ est la prédiction ;
• $\mathbf{1}_{u < 0}$ est la fonction indicatrice.

Cette fonction s’écrit aussi sous forme par morceaux :

$$
\rho_\tau(u) =
\begin{cases}
\tau u & \text{si } u \ge 0 \
(\tau – 1)u & \text{si } u < 0
\end{cases}
$$

L’asymétrie de cette perte est le point central du modèle :

• pour $\tau = 0{,}5$, la perte devient symétrique et correspond à la minimisation de la déviation absolue ;
• pour $\tau = 0{,}75$, les sous-estimations sont davantage pénalisées que les surestimations ;
• pour $\tau = 0{,}25$, c’est l’inverse.

Formulation du problème

Dans sa forme linéaire, la régression quantile cherche un vecteur de paramètres $\beta_\tau$ tel que :

$$
\hat{\beta}\tau = \arg\min\beta \sum_{i=1}^{n} \rho_\tau(y_i – x_i^\top \beta)
$$

Autrement dit, on ajuste une droite, ou plus généralement un hyperplan, non pas pour minimiser l’erreur quadratique moyenne, mais pour cibler un niveau particulier de la distribution de la variable cible.

Lien avec la médiane et la moyenne

Ce point est fondamental :

• la régression linéaire ordinaire estime la moyenne conditionnelle ;
• la régression quantile à $\tau = 0{,}5$ estime la médiane conditionnelle.

La médiane étant plus robuste aux valeurs extrêmes, la régression quantile est souvent plus stable lorsque les données contiennent des outliers ou une variance non constante.

Intuition

Imaginez que vous cherchiez à prédire le prix d’un appartement à partir de sa surface.

Une régression linéaire classique vous donnera le prix moyen attendu pour 50 m², 80 m² ou 120 m². Mais cette information est incomplète : deux appartements de même surface peuvent avoir des prix très différents selon le quartier, l’étage, l’état du bien ou la vue.

La régression quantile permet d’aller plus loin :

• le quantile 0,25 donne une estimation des biens plutôt bon marché ;
• le quantile 0,50 donne le prix médian ;
• le quantile 0,75 donne une estimation des biens plus chers.

On obtient ainsi une bande de prédiction plutôt qu’un simple point. Cela permet de répondre à des questions plus riches :

• « Quel est le prix typique ? »
• « Dans quelle plage se situent 50 % des observations ? »
• « Quelle est la borne haute plausible ? »

C’est particulièrement utile lorsque la dispersion augmente avec la variable explicative. Par exemple, les appartements plus grands ont souvent des prix beaucoup plus dispersés que les studios. La régression quantile capture naturellement ce phénomène d’hétéroscédasticité.

Implémentation Python

Il existe deux approches courantes avec scikit-learn :

1. QuantileRegressor : pour une régression quantile linéaire ;
2. HistGradientBoostingRegressor(loss="quantile") : pour une régression quantile non linéaire.

Installation des dépendances

pip install scikit-learn numpy matplotlib

Exemple 1 — Régression quantile linéaire avec QuantileRegressor

Génération de données hétéroscédastiques

import numpy as np
import matplotlib.pyplot as plt

from sklearn.linear_model import QuantileRegressor, LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_pinball_loss, mean_absolute_error

# Reproductibilité
rng = np.random.RandomState(42)

# Données synthétiques
n_samples = 400
X = rng.uniform(0, 10, size=n_samples).reshape(-1, 1)

# Bruit hétéroscédastique : plus X grand, plus la variance augmente
noise = rng.normal(loc=0, scale=0.8 + 0.35 * X.ravel(), size=n_samples)
y = 3 + 2.0 * X.ravel() + noise

# Séparation train / test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

Entraînement de plusieurs quantiles

quantiles = [0.1, 0.25, 0.5, 0.75, 0.9]
models = {}

for q in quantiles:
    model = QuantileRegressor(
        quantile=q,
        alpha=0.0,       # pas de régularisation au départ
        solver="highs"
    )
    model.fit(X_train, y_train)
    models[q] = model

# Régression linéaire classique pour comparaison
ols = LinearRegression()
ols.fit(X_train, y_train)

Visualisation des bandes de prédiction

x_grid = np.linspace(X.min(), X.max(), 300).reshape(-1, 1)

pred_quantiles = {q: models[q].predict(x_grid) for q in quantiles}
pred_ols = ols.predict(x_grid)

plt.figure(figsize=(10, 6))
plt.scatter(X_train, y_train, alpha=0.35, s=18, label="Données d'entraînement")

# Bande large 10%-90%
plt.fill_between(
    x_grid.ravel(),
    pred_quantiles[0.1],
    pred_quantiles[0.9],
    alpha=0.15,
    label="Intervalle 10%-90%"
)

# Bande centrale 25%-75%
plt.fill_between(
    x_grid.ravel(),
    pred_quantiles[0.25],
    pred_quantiles[0.75],
    alpha=0.25,
    label="Intervalle 25%-75%"
)

# Courbes de quantiles
for q in quantiles:
    plt.plot(x_grid, pred_quantiles[q], linestyle="--", linewidth=2, label=f"Quantile {q:.2f}")

# Moyenne OLS
plt.plot(x_grid, pred_ols, linewidth=2.5, label="Régression linéaire (moyenne)")

plt.xlabel("X")
plt.ylabel("y")
plt.title("Régression quantile linéaire")
plt.legend()
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Évaluation sur l’ensemble de test

# Évaluation du quantile médian
y_pred_median = models[0.5].predict(X_test)

print("MAE sur le quantile 0.5 (médiane) :",
      round(mean_absolute_error(y_test, y_pred_median), 4))

# Évaluation adaptée à chaque quantile avec la pinball loss
for q in [0.1, 0.5, 0.9]:
    y_pred = models[q].predict(X_test)
    loss = mean_pinball_loss(y_test, y_pred, alpha=q)
    print(f"Pinball loss pour le quantile {q:.1f} : {loss:.4f}")

Interprétation

Dans ce graphique :

• la droite OLS modélise la moyenne ;
• les droites de quantiles modélisent différentes parties de la distribution ;
• l’écart entre les quantiles bas et hauts augmente avec $X$, ce qui révèle une variance croissante.

Exemple 2 — Régression quantile non linéaire avec HistGradientBoostingRegressor

Lorsque la relation entre $X$ et $y$ est non linéaire, une régression quantile linéaire devient insuffisante. On peut alors utiliser un modèle plus flexible.

import numpy as np
import matplotlib.pyplot as plt

from sklearn.ensemble import HistGradientBoostingRegressor

rng = np.random.RandomState(42)

# Données non linéaires
X = np.linspace(0, 10, 500).reshape(-1, 1)
y_true = np.sin(X).ravel() * 3 + X.ravel()

# Bruit asymétrique et variable
noise = rng.normal(0, 0.8 + 0.2 * X.ravel(), size=X.shape[0])
y = y_true + noise

quantiles = [0.1, 0.5, 0.9]
preds = {}

for q in quantiles:
    model = HistGradientBoostingRegressor(
        loss="quantile",
        quantile=q,
        max_iter=300,
        max_depth=4,
        learning_rate=0.05,
        random_state=42
    )
    model.fit(X, y)
    preds[q] = model.predict(X)

plt.figure(figsize=(10, 6))
plt.scatter(X, y, s=10, alpha=0.25, label="Observations")
plt.plot(X, preds[0.5], linewidth=2.5, label="Quantile 0.5")
plt.fill_between(
    X.ravel(),
    preds[0.1],
    preds[0.9],
    alpha=0.2,
    label="Intervalle 10%-90%"
)

plt.xlabel("X")
plt.ylabel("y")
plt.title("Régression quantile non linéaire avec gradient boosting")
plt.legend()
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Quand choisir cette approche ?

Le gradient boosting quantile est souvent préférable lorsque :

• la relation entre les variables est non linéaire ;
• les interactions entre variables sont importantes ;
• on cherche avant tout de bonnes performances prédictives plutôt qu’une interprétation purement linéaire.

Hyperparamètres

Pour QuantileRegressor

Pour HistGradientBoostingRegressor

Recommandations pratiques

• Commencez avec les quantiles 0,1 / 0,5 / 0,9 pour obtenir une vue simple de la distribution.
• Utilisez alpha=0 d’abord avec QuantileRegressor, puis ajoutez de la régularisation si le modèle devient instable.
• Vérifiez visuellement si les bandes de quantiles se croisent. Ce phénomène, appelé quantile crossing, peut survenir lorsque les modèles sont entraînés séparément.
• Pour des données complexes, testez la version boosting avant d’ajouter manuellement des termes polynomiaux à une régression linéaire.

Avantages et limites

Avantages

• Robustesse aux valeurs extrêmes : en particulier pour le quantile médian.
• Pas d’hypothèse de normalité sur les résidus.
• Capture l’hétéroscédasticité : la dispersion peut varier selon les entrées.
• Intervalles de prédiction naturels : en combinant plusieurs quantiles.
• Vision plus riche que la moyenne : utile en risque, prévision et incertitude.

Limites

• Un modèle par quantile : il faut entraîner plusieurs modèles pour obtenir une bande complète.
• Coût de calcul plus élevé que l’OLS.
• Quantile crossing possible : les quantiles prédits peuvent devenir incohérents.
• Interprétation plus subtile : les coefficients changent selon le quantile.
• Quantiles extrêmes plus instables : les estimations près de 0 ou 1 demandent davantage de données.

Cas d’usage concrets

1. Prévision de ventes avec intervalles de prédiction

Dans le retail, une prévision moyenne ne suffit pas. Les équipes supply chain ont besoin d’un scénario bas, central et haut pour dimensionner les stocks. La régression quantile fournit directement ces bornes.

2. Finance et Value at Risk (VaR)

La Value at Risk est un quantile d’une distribution de pertes. La régression quantile permet d’estimer ce quantile en fonction de variables explicatives de marché, ce qui la rend utile pour le pilotage du risque.

3. Immobilier

Au lieu de prédire un seul prix immobilier, on peut prédire une fourchette plausible selon la surface, la localisation ou l’état du bien. Cela est souvent plus pertinent pour les acheteurs, vendeurs et agences.

4. Prévision météorologique probabiliste

Les services météo ne donnent pas seulement une valeur attendue, mais aussi une incertitude. La régression quantile est un outil naturel pour produire des prévisions probabilistes sur la température, les précipitations ou le vent.

Comparaison avec la régression linéaire classique

Conclusion

La régression quantile est une extension extrêmement utile de la régression classique. Là où la régression linéaire fournit une moyenne, la régression quantile fournit une distribution conditionnelle partielle, beaucoup plus informative dans les contextes réels.

Elle est particulièrement pertinente lorsque :

• l’incertitude est importante ;
• la variance de la cible n’est pas constante ;
• les décisions dépendent de scénarios pessimistes, médians ou optimistes.

Autrement dit, dès que l’on veut prédire une plage plausible plutôt qu’une simple valeur moyenne, la régression quantile devient un outil de premier plan.

Voir aussi

• Calculer la Longueur de l’Union de Segments en Python : Guide Complet et Code Optimisé
• Découvrez les Secrets du Pandigital Prime avec Python : Guide Complet et Astuces de Programmation