Accueil › Glossaire › Régularisation

Régularisation

La régularisation est un ensemble de techniques qui contraignent l’apprentissage d’un modèle de machine learning pour réduire l’overfitting et améliorer sa capacité à généraliser à des données nouvelles.

Le principe est simple : un modèle non contraint va naturellement chercher à minimiser son erreur sur le training set, quitte à mémoriser le bruit. La régularisation ajoute une contrainte qui pénalise la complexité excessive du modèle, forçant l’algorithme à trouver des solutions plus simples et plus robustes. Le résultat : une légère augmentation de l’erreur d’entraînement en échange d’une amélioration significative de la performance sur des données inédites. C’est un compromis volontaire et bénéfique.

Pourquoi régulariser

Sans régularisation, un modèle avec suffisamment de paramètres peut atteindre une erreur de zéro sur le training set. Mais cette performance parfaite en entraînement ne se traduit presque jamais en performance parfaite en production. Le modèle a simplement mémorisé les données, y compris le bruit et les anomalies.

La régularisation résout ce problème en agissant comme le rasoir d’Occam : entre deux modèles qui expliquent les données de façon similaire, elle favorise le plus simple. En termes techniques, elle réduit la variance du modèle (sa sensibilité aux données d’entraînement) au prix d’une légère augmentation du biais (ses hypothèses simplificatrices). Le résultat net est une meilleure performance sur le test set et en production.

Régularisation L2 (Ridge / Weight Decay)

La régularisation L2 est la technique la plus utilisée en deep learning. Elle ajoute à la fonction de loss un terme proportionnel à la somme des carrés des poids du modèle.

Formule : Loss_régularisée = Loss_originale + λ × Σ(wᵢ²)

Le paramètre λ (lambda) contrôle la force de la pénalité. Plus λ est élevé, plus les poids sont poussés vers zéro, plus le modèle est contraint (plus simple). Un λ trop élevé cause l’underfitting ; un λ trop faible n’a pas d’effet.

Effet sur les poids. L2 réduit uniformément la magnitude de tous les poids sans les mettre exactement à zéro. Chaque poids est « rétréci » proportionnellement à sa taille. Les poids grands sont pénalisés beaucoup plus (le carré d’un grand nombre est très grand), ce qui empêche le modèle de s’appuyer trop fortement sur une seule feature.

En pratique. Dans les optimizers de deep learning (Adam, SGD), la régularisation L2 est implémentée via le paramètre weight_decay. Valeurs typiques : 1e-4 à 1e-2.

# PyTorch : L2 via weight_decay dans l'optimizer
optimizer = torch.optim.Adam(
    model.parameters(),
    lr=1e-3,
    weight_decay=1e-4  # L2 régularisation
)

Régularisation L1 (Lasso)

La régularisation L1 ajoute à la loss un terme proportionnel à la somme des valeurs absolues des poids.

Formule : Loss_régularisée = Loss_originale + λ × Σ|wᵢ|

Effet sur les poids. Contrairement à L2, L1 pousse certains poids exactement à zéro. C’est la différence clé : L1 effectue une sélection automatique de features en éliminant les features non pertinentes (leur poids tombe à zéro). Le modèle résultant est « sparse » (clairsemé) : seules les features les plus importantes conservent un poids non nul.

Quand l’utiliser. L1 est particulièrement utile quand vous suspectez que beaucoup de features sont non pertinentes et que vous voulez identifier les plus importantes. C’est aussi un choix naturel quand l’interprétabilité est cruciale : un modèle avec 10 features actives sur 1 000 est beaucoup plus facile à comprendre et à auditer.

# scikit-learn : Lasso (L1) pour la régression
from sklearn.linear_model import Lasso
model = Lasso(alpha=0.1)  # alpha = λ
model.fit(X_train, y_train)

# Features sélectionnées (poids non nuls)
selected = [f for f, w in zip(feature_names, model.coef_) if w != 0]
print(f"{len(selected)} features retenues sur {len(feature_names)}")

Elastic Net : le meilleur des deux mondes

L’Elastic Net combine les pénalités L1 et L2 dans une seule formule, contrôlée par un ratio l1_ratio (entre 0 et 1) qui détermine la proportion de chaque pénalité.

Formule : Loss_régularisée = Loss_originale + λ × [(1-α) × Σ|wᵢ| + α × Σ(wᵢ²)]

L’Elastic Net offre la sélection de features de L1 (certains poids à zéro) avec la stabilité de L2 (réduction uniforme des poids restants). C’est le choix recommandé quand vous avez des features corrélées entre elles : L1 seul tend à sélectionner arbitrairement une feature parmi des features corrélées, tandis qu’Elastic Net les conserve toutes avec des poids réduits.

Comparaison L1 vs L2

Dropout

Le dropout est une technique de régularisation spécifique aux réseaux de neurones. À chaque étape d’entraînement, une fraction aléatoire des neurones est « désactivée » (mise à zéro). Le réseau doit apprendre à fonctionner correctement même quand certains de ses neurones sont absents, ce qui l’oblige à distribuer l’information de façon redondante plutôt que de s’appuyer sur des neurones individuels.

Taux de dropout typiques : 20 à 50%. Un taux de 0,5 signifie que la moitié des neurones sont désactivés à chaque pas d’entraînement. Pendant l’inférence (prédiction), tous les neurones sont actifs mais leurs sorties sont multipliées par (1 – taux_dropout) pour compenser. Consultez notre page dédiée dropout pour un traitement approfondi.

Early stopping

L’early stopping surveille la performance sur le validation set pendant l’entraînement. Dès que cette performance cesse de s’améliorer pendant N epochs consécutives (la « patience »), l’entraînement s’arrête et le modèle est restauré au point de meilleure validation.

C’est la forme de régularisation la plus universelle et la plus simple à implémenter. Elle ne nécessite aucun hyperparamètre supplémentaire dans la loss function, seulement un paramètre de patience. Elle est applicable à tout type de modèle entraîné par itérations (réseaux de neurones, gradient boosting).

Autres techniques de régularisation

Data augmentation

La data augmentation agit comme un régulariseur en augmentant la diversité du training set. Le modèle ne voit jamais exactement le même exemple deux fois (les transformations aléatoires varient à chaque epoch), ce qui rend la mémorisation beaucoup plus difficile. C’est l’un des régulariseurs les plus efficaces en computer vision.

Batch normalization

La batch normalization normalise les activations de chaque couche, ce qui a un léger effet régularisant en plus de ses bénéfices sur la convergence. Le bruit introduit par le calcul de la moyenne et de la variance sur le mini-batch agit comme une forme de régularisation stochastique. Cependant, cet effet est secondaire et ne remplace pas les techniques dédiées.

Pruning (élagage)

Le pruning consiste à supprimer les connexions, neurones ou couches les moins importants d’un réseau entraîné. Le résultat est un modèle plus petit, plus rapide et potentiellement mieux généralisé. C’est aussi une technique de compression de modèle pour le déploiement sur des appareils embarqués.

Label smoothing

Au lieu d’utiliser des labels « durs » (1 pour la bonne classe, 0 pour les autres), le label smoothing utilise des valeurs légèrement adoucies (0,9 pour la bonne classe, 0,1/(N-1) pour les autres). Cela empêche le modèle d’être trop confiant dans ses prédictions et améliore la calibration. C’est une technique standard dans l’entraînement des Transformers.

Injection de bruit

Ajouter du bruit gaussien aux poids pendant l’entraînement force le modèle à trouver des solutions robustes aux perturbations. C’est conceptuellement proche du dropout mais appliqué de façon continue plutôt que binaire.

Comment choisir et calibrer

Commencez sans régularisation. Vérifiez d’abord que votre modèle peut apprendre (même s’il overfitte). Si le modèle n’arrive pas à obtenir de bonnes performances sur le training set, le problème est l’underfitting, pas l’overfitting, et la régularisation ne fera qu’empirer les choses.

Ajoutez progressivement. Commencez par l’early stopping (gratuit et universel). Si l’overfitting persiste, ajoutez du weight decay (L2) avec une valeur faible (1e-4). Si toujours insuffisant, ajoutez du dropout (20-30%) et/ou de la data augmentation.

Calibrez λ sur le validation set. La force de régularisation (λ, taux de dropout, patience) est un hyperparamètre à optimiser. Testez plusieurs valeurs et retenez celle qui donne la meilleure performance de validation. Des outils comme Optuna ou W&B Sweeps automatisent cette recherche.

Combinez les techniques. Les régularisateurs sont complémentaires. Early stopping + weight decay + dropout + data augmentation est une combinaison standard en deep learning. Chaque technique agit sur un aspect différent du problème.

Implémentation par framework

Notez que XGBoost et LightGBM ont leurs propres formes de régularisation qui vont au-delà de L1/L2 : limiter la profondeur des arbres (max_depth), le nombre minimum d’exemples par feuille (min_child_weight), et le sous-échantillonnage de lignes et de colonnes (subsample, colsample_bytree) agissent tous comme des régulariseurs en contraignant la complexité de chaque arbre.

La régularisation dans l’entraînement des LLM

Les grands modèles de langage utilisent des techniques de régularisation spécifiques à leur échelle.

Weight decay (AdamW). L’optimizer AdamW avec weight decay découplé est le standard pour l’entraînement des Transformers. Des valeurs de weight decay de 0,01 à 0,1 sont courantes pour le pré-entraînement des LLM.

Dropout. Utilisé dans les couches du Transformer (attention dropout, résidual dropout), typiquement avec des taux de 0,1. Certains modèles récents (comme GPT-3 et ses successeurs) utilisent très peu ou pas de dropout pendant le pré-entraînement, compensant par la taille massive du dataset.

Déduplication du corpus. Supprimer les doublons dans le corpus de pré-entraînement empêche le modèle de mémoriser des textes spécifiques, ce qui est une forme de régularisation au niveau des données.

LoRA pour le fine-tuning. En limitant les modifications à un petit nombre de paramètres de faible rang, LoRA agit comme un régulariseur implicite pendant le fine-tuning, empêchant le modèle de trop s’éloigner de ses poids pré-entraînés et réduisant le risque de catastrophic forgetting.

Erreurs fréquentes

Régulariser un modèle qui underfitte. Si votre modèle n’atteint pas de bonnes performances sur le training set, la régularisation ne fera qu’empirer les choses. Assurez-vous d’abord que le modèle a la capacité d’apprendre (même s’il overfitte), puis régularisez.

Appliquer une régularisation massive d’un coup. Un weight decay de 0,1, un dropout de 0,8 et un early stopping avec patience 2 simultanément vont écraser votre modèle. Ajoutez les techniques une par une, en mesurant l’impact de chacune sur la validation.

Confondre L2 et weight decay avec Adam. Les deux ne sont pas équivalents avec l’optimizer Adam. Utilisez AdamW (weight decay découplé) pour un effet correct. L’erreur est courante car beaucoup de tutoriels confondent les deux.

Oublier de désactiver le dropout à l’inférence. Le dropout doit être actif uniquement pendant l’entraînement. En PyTorch, appelez model.eval() avant l’inférence pour désactiver automatiquement les couches de dropout et de batch normalization. Oublier cette étape produit des prédictions bruitées et incohérentes.

Ne pas régulariser différemment selon les couches. Les premières couches d’un réseau profond capturent des features génériques (contours, textures) et n’ont généralement pas besoin de beaucoup de régularisation. Les couches finales, plus spécialisées, sont plus susceptibles d’overfitter. En fine-tuning, on applique souvent des learning rates et des régularisations différenciées par couche (discriminative learning rates).