Accueil › Glossaire › Régression

Régression en Machine Learning

La régression est une tâche d’apprentissage supervisé qui consiste à prédire une valeur numérique continue à partir de variables d’entrée, en modélisant la relation entre les features et une variable cible quantitative.

C’est l’une des deux grandes familles de prédiction en machine learning, l’autre étant la classification (prédiction de catégories discrètes). En régression, la sortie est un nombre réel : un prix, une température, un chiffre d’affaires, une durée, une concentration chimique. Cette distinction fondamentale conditionne le choix de la fonction de perte, des métriques d’évaluation et de l’architecture du modèle.

Le principe fondamental de la régression

L’idée de la régression est de trouver une fonction f(X) qui, à partir d’un ensemble de features X, produit une prédiction ŷ aussi proche que possible de la valeur réelle y. La différence entre ŷ et y est le résidu (ou erreur). L’entraînement du modèle consiste à minimiser une mesure agrégée de ces résidus sur l’ensemble des données d’entraînement.

La forme la plus simple est la régression linéaire : ŷ = w₁x₁ + w₂x₂ + ... + wₙxₙ + b, où les wᵢ sont les poids (coefficients) et b le biais (intercept). L’entraînement ajuste ces paramètres pour minimiser l’erreur quadratique moyenne (MSE).

Mais la régression ne se limite pas aux relations linéaires. Les algorithmes modernes (arbres de décision, gradient boosting, réseaux de neurones) capturent des relations complexes et non linéaires entre les features et la cible.

Les types de régression

Régression linéaire simple et multiple

La régression linéaire simple modélise la relation entre une seule feature et la cible par une droite. La régression linéaire multiple étend ce concept à plusieurs features, modélisant un hyperplan dans un espace multidimensionnel.

Les coefficients sont typiquement estimés par la méthode des moindres carrés ordinaires (OLS), qui minimise la somme des carrés des résidus. En Python :

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Données d'exemple
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

# Entraînement
model = LinearRegression()
model.fit(X_train, y_train)

# Prédiction et évaluation
y_pred = model.predict(X_test)
print(f"R² : {r2_score(y_test, y_pred):.4f}")
print(f"RMSE : {np.sqrt(mean_squared_error(y_test, y_pred)):.4f}")

# Coefficients et intercept
print(f"Coefficients : {model.coef_}")
print(f"Intercept : {model.intercept_:.4f}")

La régression linéaire est rapide, interprétable et constitue toujours la baseline de référence. Ses limites : elle suppose une relation linéaire entre features et cible, est sensible aux outliers, et peut souffrir de multicolinéarité (corrélation forte entre features).

Régression polynomiale

Quand la relation entre features et cible est courbe, la régression polynomiale ajoute des termes de puissance supérieure (x², x³, etc.) aux features. Techniquement, c’est toujours un modèle linéaire par rapport aux paramètres, mais non linéaire par rapport aux features d’entrée.

from sklearn.preprocessing import PolynomialFeatures

# Créer des features polynomiales de degré 3
poly = PolynomialFeatures(degree=3, include_bias=False)
X_poly = poly.fit_transform(X_train)

# Entraîner une régression linéaire sur les features transformées
model = LinearRegression()
model.fit(X_poly, y_train)

Régression régularisée : Ridge, Lasso, ElasticNet

La régularisation ajoute un terme de pénalité à la fonction de coût pour empêcher les coefficients de devenir trop grands, ce qui réduit l’overfitting.

Ridge (L2) : ajoute la somme des carrés des coefficients à la fonction de coût. Les coefficients sont réduits vers zéro mais ne deviennent jamais exactement zéro. Idéal quand toutes les features contribuent et que la multicolinéarité est un problème.

Lasso (L1) : ajoute la somme des valeurs absolues des coefficients. Certains coefficients sont réduits exactement à zéro, ce qui effectue automatiquement une sélection de features. Idéal quand vous suspectez que seules quelques features sont réellement pertinentes.

ElasticNet : combine les pénalités L1 et L2. Offre le meilleur des deux mondes : sélection de features (comme Lasso) et gestion de la multicolinéarité (comme Ridge). Contrôlé par deux hyperparamètres : alpha (force globale de régularisation) et l1_ratio (proportion de L1).

from sklearn.linear_model import Ridge, Lasso, ElasticNet

# Ridge
ridge = Ridge(alpha=1.0).fit(X_train, y_train)

# Lasso
lasso = Lasso(alpha=0.1).fit(X_train, y_train)
print(f"Features supprimées par Lasso : "
      f"{sum(lasso.coef_ == 0)} / {len(lasso.coef_)}")

# ElasticNet
elastic = ElasticNet(alpha=0.1, l1_ratio=0.5).fit(X_train, y_train)

Régression par arbres et gradient boosting

Les arbres de décision, Random Forest et le gradient boosting (XGBoost, LightGBM) sont les algorithmes dominants pour la régression sur données tabulaires. Ils capturent naturellement les relations non linéaires, les interactions entre features, et ne nécessitent pas de normalisation des données.

from sklearn.ensemble import RandomForestRegressor
from xgboost import XGBRegressor

# Random Forest
rf = RandomForestRegressor(n_estimators=200, random_state=42)
rf.fit(X_train, y_train)
print(f"R² RF : {rf.score(X_test, y_test):.4f}")

# XGBoost
xgb = XGBRegressor(n_estimators=200, learning_rate=0.1)
xgb.fit(X_train, y_train)
print(f"R² XGB : {xgb.score(X_test, y_test):.4f}")

Régression par deep learning

Les réseaux de neurones peuvent effectuer de la régression en utilisant une couche de sortie avec un seul neurone (sans activation ou avec activation linéaire). La perte utilisée est typiquement le MSE ou le MAE. Les cas d’usage principaux : prédiction à partir d’images (estimation de profondeur), de texte, de séries temporelles, ou sur des datasets massifs (millions d’échantillons).

Métriques d’évaluation en régression

Contrairement à la classification où l’on mesure des taux de bonne classification, la régression mesure la distance entre prédictions et valeurs réelles.

Le R² en détail

Le coefficient de détermination R² mesure la proportion de la variance de y qui est expliquée par le modèle. Un R² de 0,85 signifie que le modèle capture 85 % de la variabilité de la cible. La baseline (R² = 0) correspond à un modèle qui prédit toujours la moyenne de y.

Points importants sur le R² :

Il peut être négatif si le modèle est pire que la moyenne (ce qui arrive rarement mais signale un problème grave).

Il augmente mécaniquement quand on ajoute des features, même non pertinentes. Le R² ajusté corrige ce biais en pénalisant le nombre de features.

Un R² élevé sur l’entraînement mais bas sur le test signale un overfitting.

Un R² de 0,70 peut être excellent (prédiction du prix immobilier) ou médiocre (prédiction de trajectoire de missile), selon le domaine.

Quelle métrique choisir ?

Utilisez le RMSE quand les grandes erreurs sont particulièrement coûteuses (le carré pénalise les erreurs extrêmes). Utilisez le MAE quand toutes les erreurs comptent de la même façon, ou quand les données contiennent des outliers. Utilisez le MAPE pour communiquer avec des parties prenantes non techniques (« notre modèle se trompe en moyenne de 8 % »). Utilisez le R² pour comparer des modèles entre eux sur le même jeu de données.

Pipeline de régression en pratique

Étape 1 : Analyse exploratoire

Avant tout modèle, examinez la distribution de la variable cible. Si elle est très asymétrique (skewed), une transformation log peut améliorer les performances. Vérifiez les corrélations entre features (risque de multicolinéarité) et entre features et cible (signaux utiles).

Étape 2 : Préparation des données

Les modèles linéaires nécessitent une normalisation/standardisation des features. Les arbres de décision et le gradient boosting n’en ont pas besoin. Encodez les variables catégorielles (one-hot, target encoding). Gérez les valeurs manquantes (imputation par la médiane est un bon défaut).

Étape 3 : Sélection de modèle et tuning

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor
from xgboost import XGBRegressor

models = {
    'Linear': LinearRegression(),
    'Ridge': Ridge(alpha=1.0),
    'Lasso': Lasso(alpha=0.1),
    'Random Forest': RandomForestRegressor(n_estimators=100),
    'XGBoost': XGBRegressor(n_estimators=100, learning_rate=0.1)
}

for name, model in models.items():
    scores = cross_val_score(model, X_train, y_train,
                            cv=5, scoring='neg_root_mean_squared_error')
    print(f"{name}: RMSE = {-scores.mean():.4f} ± {scores.std():.4f}")

Étape 4 : Diagnostic des résidus

Après l’entraînement, analysez les résidus (erreurs) du modèle. Ils doivent être :

Centrés autour de zéro : un biais systématique indique que le modèle sous-estime ou surestime de manière constante.

Distribués aléatoirement : des patterns dans les résidus (forme en U, tendance) indiquent une relation non capturée.

Homoscédastiques : la variance des résidus doit être constante. Si elle augmente avec la valeur prédite, une transformation de la cible (log, racine carrée) peut aider.

Applications courantes de la régression

Prédiction de prix

L’estimation immobilière est le cas d’école de la régression : prédire le prix d’un bien à partir de sa surface, son emplacement, son âge, etc. Les mêmes principes s’appliquent à la prédiction de prix de produits, de tarifs d’assurance ou de coûts de projet.

Prévision de séries temporelles

La prévision de séries temporelles (ventes, trafic, demande, cours boursiers) est une forme spécialisée de régression où les features incluent des valeurs passées de la cible (lags), des indicateurs temporels (jour de la semaine, mois, jours fériés) et des variables exogènes.

Scoring et notation

Le scoring de crédit, la notation de risque, les scores de satisfaction client : dès que la sortie est un score numérique continu, c’est de la régression.

Applications scientifiques

Prédiction de propriétés de molécules (drug discovery), estimation de paramètres physiques, modélisation climatique, prédiction de rendements agricoles : la régression est omniprésente dans les sciences quantitatives.

Régression vs classification : la frontière

La distinction paraît simple mais se brouille dans plusieurs cas :

Régression logistique : malgré son nom, c’est un algorithme de classification. Il utilise une régression linéaire suivie d’une sigmoïde pour produire une probabilité, puis un seuil pour décider de la classe. Le nom « régression » fait référence à la méthode d’estimation, pas à la nature de la tâche.

Régression ordinale : quand la cible a un ordre naturel mais discret (notes de 1 à 5, niveaux de sévérité), on peut traiter le problème en régression (prédire un score continu puis arrondir) ou en classification ordinale. Les deux approches ont des avantages selon le contexte.

Quantile regression : au lieu de prédire la moyenne conditionnelle (régression classique), la quantile regression prédit un quantile spécifique (médiane, 90ᵉ percentile). Utile pour estimer des intervalles de confiance ou modéliser les queues de distribution.

Défis courants en régression

Overfitting

Un modèle trop complexe mémorise le bruit des données d’entraînement. Signes : R² élevé sur l’entraînement, faible sur le test. Solutions : régularisation (Ridge, Lasso), réduction de la complexité, plus de données, validation croisée.

Outliers

Les valeurs aberrantes ont un impact disproportionné sur les modèles basés sur le MSE (qui élève les erreurs au carré). Solutions : utiliser le MAE ou la perte de Huber au lieu du MSE, détecter et traiter les outliers en amont, ou utiliser des méthodes robustes (régression quantile, RANSAC).

Multicolinéarité

Quand des features sont fortement corrélées entre elles, les coefficients de la régression linéaire deviennent instables (grands en valeur absolue, signes incohérents). Solutions : Ridge regularization, sélection de features, PCA pour réduire les dimensions.

Relations non linéaires

La régression linéaire échoue si la relation réelle est non linéaire. Solutions : features polynomiales, arbres de décision, gradient boosting, réseaux de neurones. Le gradient boosting est particulièrement efficace car il apprend les non-linéarités automatiquement sans intervention manuelle.

Hétéroscédasticité

Quand la variance des erreurs varie avec la valeur prédite (par exemple, l’erreur augmente avec le prix du bien immobilier). Solutions : transformation log de la cible, modèles de variance (GLS), ou utiliser des métriques relatives comme le MAPE.

Verdict

La régression est la tâche de prédiction la plus intuitive en ML : estimer un nombre à partir de données. Le choix de l’algorithme suit une logique simple. Commencez par la régression linéaire (interprétable, rapide, baseline solide). Si les résidus montrent des patterns non linéaires, passez au gradient boosting (XGBoost, LightGBM), qui domine sur les données tabulaires. Réservez le deep learning aux données non structurées.

Le choix de la métrique est tout aussi important : RMSE si les grosses erreurs comptent, MAE si toutes les erreurs se valent, R² pour comparer des modèles. Et dans tous les cas, analysez vos résidus : ils racontent l’histoire des erreurs que votre modèle ne sait pas encore corriger.