Une régression linéaire qui pénalise les coefficients trop grands. Quand les variables sont nombreuses et se ressemblent, la régression classique s'emballe et donne des poids instables. Ridge les freine tous un peu, sans en supprimer aucun, et prévoit mieux sur des données nouvelles.
Un budget de poids à répartir. Quand deux variables racontent la même histoire, la régression classique donne +100 à l'une et -95 à l'autre. Ridge leur donne +3 chacune.
La pénalité porte sur la taille des coefficients. Sans mise à l'échelle, une variable en euros et une variable en milliers d'euros ne seraient pas traitées à égalité.
Le modèle minimise l'erreur au carré plus alpha fois la somme des coefficients au carré. Plus alpha est grand, plus les coefficients sont ramenés vers zéro.
On teste une grille de valeurs et on garde celle qui prévoit le mieux sur les blocs de données mis de côté.
Pour prévoir les ventes du mois prochain, on donne au modèle les ventes de chacun des 36 mois précédents. Ces variables sont très corrélées entre elles, et il ne reste que 48 mois pour apprendre.
Sur le jeu d'exemple, la régression classique donne des poids qui changent de signe d'un mois à l'autre, dont un poids négatif au mois précédent. Ridge les lisse : le même mois des années précédentes (12, 24 et 36 mois avant) pèse le plus.
On teste sur les deux dernières années, jamais vues à l'apprentissage. Ici, l'erreur moyenne passe de 56,6 unités avec la régression classique à 42,7 avec Ridge, pour des ventes d'environ 1 600 unités par mois.
Noms donnés pour R (glmnet) et Python (scikit-learn). Attention : alpha n'a pas le même sens dans les deux.
La force du frein. En R, c'est lambda ; en Python, alpha. Toujours choisi par validation croisée (cv.glmnet, RidgeCV), jamais au jugé.
Dans glmnet, alpha désigne le mélange : 0 donne Ridge, 1 donne Lasso. Oublier alpha = 0 donne un Lasso par défaut.
glmnet met les variables à l'échelle tout seul. En Python, il faut un StandardScaler dans un Pipeline, sinon la pénalité frappe inégalement les variables.
# Prévision des ventes mensuelles : Ridge en R
library(glmnet)
ventes <- read.csv("ventes_mensuelles.csv")
y <- ventes$ventes
# 36 variables : les ventes des 36 mois précédents, très corrélées entre elles
X <- sapply(1:36, function(k) c(rep(NA, k), head(y, -k)))
colnames(X) <- paste0("mois_moins_", 1:36)
garder <- complete.cases(X)
X <- X[garder, ]
y <- y[garder]
test <- (nrow(X) - 23):nrow(X) # les 24 derniers mois en test
mco <- lm.fit(cbind(1, X[-test, ]), y[-test])
pred_mco <- cbind(1, X[test, ]) %*% mco$coefficients
set.seed(42)
cv <- cv.glmnet(X[-test, ], y[-test], alpha = 0, nfolds = 5) # alpha = 0 : Ridge
pred_ridge <- predict(cv, newx = X[test, ], s = "lambda.min")
cat("Lignes d'apprentissage :", nrow(X) - 24, "pour", ncol(X), "variables\n")
cat("Erreur moyenne MCO :", round(mean(abs(y[test] - pred_mco)), 1), "\n")
cat("Erreur moyenne Ridge :", round(mean(abs(y[test] - pred_ridge)), 1), "\n")
# Prévision des ventes mensuelles : Ridge en Python
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression, RidgeCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error
ventes = pd.read_csv("ventes_mensuelles.csv")
# 36 variables : les ventes des 36 mois précédents, très corrélées entre elles
X = pd.concat({f"mois_moins_{k}": ventes["ventes"].shift(k) for k in range(1, 37)}, axis=1)
donnees = pd.concat([X, ventes["ventes"]], axis=1).dropna()
train, test = donnees.iloc[:-24], donnees.iloc[-24:] # les 24 derniers mois en test
mco = LinearRegression().fit(train[X.columns], train["ventes"])
ridge = make_pipeline(StandardScaler(), RidgeCV(alphas=np.logspace(-2, 4, 60), cv=5))
ridge.fit(train[X.columns], train["ventes"])
print("Lignes d'apprentissage :", len(train), "pour", X.shape[1], "variables")
print("Alpha retenu :", round(ridge[-1].alpha_, 1))
print("Erreur moyenne MCO :", round(mean_absolute_error(test["ventes"], mco.predict(test[X.columns])), 1))
print("Erreur moyenne Ridge :", round(mean_absolute_error(test["ventes"], ridge.predict(test[X.columns])), 1))
Les deux freinent les coefficients. Ridge les rétrécit tous sans jamais les annuler ; le Lasso en met certains exactement à zéro, et sélectionne donc des variables. Ridge est souvent meilleur quand toutes les variables comptent un peu, le Lasso quand quelques-unes seulement comptent.
Oui. La pénalité dépend de la taille des coefficients, donc de l'unité des variables. glmnet le fait par défaut ; avec scikit-learn, placez un StandardScaler avant le modèle dans un Pipeline.
Ridge accepte un petit biais en échange d'une forte baisse de la variance : ses coefficients bougent beaucoup moins d'un échantillon à l'autre. Sur des données nouvelles, ce compromis donne souvent une erreur plus faible.
L'autre pénalité : elle met à zéro les variables inutiles et fait la sélection.
Voir la fiche → le mélange des deuxCombine Ridge et Lasso : sélectionne, tout en gardant ensemble les variables corrélées.
Voir la fiche → l'autre réponse aux corrélationsRésume d'abord les variables en quelques composantes, puis régresse sur elles.
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