Une régression qui traite normalement les petits écarts, mais limite l'influence des grands. Une erreur de saisie qui multiplie un chiffre par dix ne tire plus toute la droite vers elle. On obtient les coefficients qu'on aurait eus sur des données propres, sans devoir chasser chaque anomalie à la main.
Un comité qui écoute tout le monde, mais qui plafonne le temps de parole. Celui qui crie plus fort que les autres n'obtient pas plus d'influence pour autant.
On calcule les écarts entre valeurs réelles et prévues, et une échelle de référence de ces écarts.
Sous un seuil (1,35 fois l'échelle), l'écart compte au carré, comme en régression classique. Au-delà, il ne compte plus qu'en valeur absolue : son influence est plafonnée.
Les points aux grands écarts reçoivent un poids plus faible, et on réajuste. Quelques itérations suffisent pour que la droite se stabilise.
Le CA de 400 magasins avec surface, pub, concurrents et zone. Pour la démonstration, 20 CA ont été saisis avec un zéro de trop. C'est le cas typique d'une remontée manuelle depuis les régions.
Sur le jeu d'exemple, l'effet d'un concurrent passe de -15 k€ sur les données propres à -82 k€ avec la régression classique polluée. La régression de Huber, sur les mêmes données polluées, donne -16 k€.
On compare les coefficients obtenus avec et sans les lignes suspectes. Les poids finaux de la régression robuste servent aussi de détecteur : les lignes fortement dévaluées sont celles à vérifier en priorité.
Noms donnés pour R (MASS::rlm) et Python (scikit-learn).
Le seuil de bascule, en multiples de l'échelle des écarts. 1,345 en R et 1,35 en Python : une valeur standard, efficace à 95 % si les données sont propres. Plus petit, plus robuste, moins précis.
rlm propose aussi l'estimation MM, qui résiste à une plus forte proportion d'aberrations. Utile quand beaucoup de lignes sont douteuses.
HuberRegressor ajoute une légère pénalité Ridge (alpha = 0,0001). Mettre les variables à l'échelle avant l'ajustement aide la convergence.
# CA magasins avec erreurs de saisie : régression robuste (Huber) en R
library(MASS)
magasins <- read.csv("magasins.csv")
magasins$zone <- factor(magasins$zone) # référence : centre_ville
# Démonstration : 20 CA saisis avec un zéro de trop (x 10)
set.seed(42)
erreurs <- sample(nrow(magasins), 20)
magasins$ca_saisi <- magasins$ca_k
magasins$ca_saisi[erreurs] <- magasins$ca_saisi[erreurs] * 10
propre <- lm(ca_k ~ surface_m2 + budget_pub_k + nb_concurrents + zone, data = magasins)
mco <- lm(ca_saisi ~ surface_m2 + budget_pub_k + nb_concurrents + zone, data = magasins)
huber <- rlm(ca_saisi ~ surface_m2 + budget_pub_k + nb_concurrents + zone, data = magasins,
psi = psi.huber, k = 1.345, maxit = 100)
print(round(cbind(sans_erreur = coef(propre), mco_avec_erreurs = coef(mco),
huber_avec_erreurs = coef(huber))[-1, ], 2))
# Poids finaux : les lignes suspectes sont fortement dévaluées
cat("Poids moyen des 20 erreurs :", round(mean(huber$w[erreurs]), 3), "\n")
cat("Poids moyen des autres :", round(mean(huber$w[-erreurs]), 3), "\n")
# CA magasins avec erreurs de saisie : régression robuste (Huber) en Python
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression, HuberRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
magasins = pd.read_csv("magasins.csv")
X = pd.get_dummies(magasins[["surface_m2", "budget_pub_k", "nb_concurrents", "zone"]], drop_first=True, dtype=float)
# Démonstration : 20 CA saisis avec un zéro de trop (x 10)
rng = np.random.default_rng(42)
ca_saisi = magasins["ca_k"].copy()
erreurs = rng.choice(len(ca_saisi), 20, replace=False)
ca_saisi.iloc[erreurs] *= 10
propre = LinearRegression().fit(X, magasins["ca_k"]) # référence sans erreur
mco = LinearRegression().fit(X, ca_saisi)
huber = make_pipeline(StandardScaler(), HuberRegressor(epsilon=1.35, max_iter=1000)).fit(X, ca_saisi)
print(pd.DataFrame({"sans erreur": propre.coef_, "MCO avec erreurs": mco.coef_,
"Huber avec erreurs": huber[-1].coef_ / huber[0].scale_}, index=X.columns).round(2))
Supprimer demande de fixer un seuil à la main, et on risque d'écarter des cas réels. La régression robuste garde toutes les lignes mais réduit automatiquement le poids des plus grands écarts. On peut ensuite examiner les lignes dévaluées.
Elle compte les petits écarts au carré, comme les moindres carrés, et les grands écarts en valeur absolue. Au-delà du seuil, l'influence d'un point cesse de croître avec son écart. C'est ce qui empêche une valeur aberrante de tirer le modèle.
Non. Elle protège contre les valeurs extrêmes de la cible. Un point extrême sur une variable explicative, dit point levier, peut encore influencer fortement le résultat. Pour ces cas, on utilise des estimateurs MM ou LTS.
Même équation, mais une seule ligne aberrante peut déplacer tous les coefficients.
Voir la fiche → l'autre résistanceLa régression médiane résiste aussi aux extrêmes de la cible et donne des fourchettes.
Voir la fiche → détecter avant de modéliserLes règles de base pour repérer les valeurs extrêmes avant tout modèle.
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