Régularisation en apprentissage automatique : L1, L2 et Elastic Net expliqués

Vous avez entraîné un modèle qui frôle la perfection sur l’entraînement, mais s’effondre sur de nouvelles données ? Cela nous est arrivé à tous.

C’est, en résumé, du surapprentissage. Votre modèle n’a pas appris le vrai schéma : il a mémorisé les données d’entraînement. En production, face à des données nouvelles et inédites, il émettrait des prédictions peu fiables. Plus les données réelles s’éloignent des échantillons d’entraînement, plus le problème s’aggrave.

La régularisation corrige cela en ajoutant une pénalité à la fonction de perte. Cette pénalité décourage les modèles trop complexes. Autrement dit, elle empêche votre modèle d’épouser chaque point de données et l’oblige à généraliser.

Dans cet article, je vous explique l’intuition derrière la régularisation, les méthodes les plus courantes — L1, L2 et Elastic Net — et comment choisir la bonne approche selon votre cas d’usage.

Si vous voulez comprendre pourquoi et comment les modèles d’apprentissage automatique échouent en production, lisez notre billet sur le compromis biais-variance.

Qu’est-ce que la régularisation en apprentissage automatique

La régularisation consiste à ajouter un terme de pénalité à la fonction de perte du modèle pour limiter sa complexité.

Sans ce terme de pénalité, un modèle est suffisamment flexible pour coller de très près aux données d’entraînement — y compris au bruit et aux valeurs aberrantes. La régularisation fait payer cette flexibilité. Plus le modèle cherche à être complexe, plus la pénalité augmente.

La fonction de perte de votre modèle mesure d’ordinaire l’écart entre les valeurs prédites et réelles. La régularisation ajoute un terme supplémentaire à cette équation, qui croît avec la taille des coefficients du modèle. Le modèle doit alors équilibrer deux objectifs concurrents : bien ajuster les données d’entraînement et garder des coefficients faibles.

Cet équilibre contrôle la flexibilité du modèle.

Un modèle très flexible peut se contorsionner pour épouser les données d’entraînement. La régularisation le ramène vers une forme plus simple — plus susceptible de tenir la route face à des données jamais vues.

Pourquoi la régularisation est nécessaire

Chaque modèle que vous entraînez se situe quelque part entre deux extrêmes inutilisables : trop simple ou trop complexe.

Un modèle trop simple ne « comprend » pas les vrais motifs de vos données. Il rate le signal. C’est le sous-apprentissage : de mauvaises performances à la fois sur l’entraînement et sur de nouvelles données.

Un modèle trop complexe fait l’inverse. Il colle à chaque détail des données d’entraînement, y compris au bruit. C’est le surapprentissage : des résultats excellents sur l’entraînement, mais un échec sur de nouvelles données car le modèle a mémorisé les mauvaises choses.

Prenons la régression polynomiale. Un polynôme de degré 3 sur des données en légère courbe capture probablement le bon motif. Mais un polynôme de degré 15 sur les mêmes données conduit au surapprentissage : la courbe passe par chaque point, mais fait des prédictions aléatoires entre les points.

Le graphique ci-dessous illustre ce phénomène.

Modèle bien dosé vs modèle trop complexe

C’est le compromis biais-variance.

Les modèles simples présentent un biais élevé — ils font des hypothèses fortes qui manquent les vrais motifs. Les modèles complexes présentent une variance élevée — ils sont trop sensibles aux échantillons d’entraînement observés, et de petits changements produisent des modèles très différents.

La régularisation aide à trouver un juste milieu. Elle n’élimine pas la complexité, mais elle la pénalise. Votre modèle a ainsi plus de chances de capter le signal réel.

Comment fonctionne la régularisation

Tout modèle apprend en minimisant une fonction de perte — une mesure de l’erreur de ses prédictions. Sans régularisation, son seul objectif est de réduire cette erreur, quitte à gonfler ses coefficients pour coller aux données d’entraînement sans généraliser.

La régularisation modifie l’objectif. Au lieu de minimiser uniquement l’erreur, le modèle minimise désormais ceci :

Comment fonctionne la régularisation

Le terme de pénalité dépend des coefficients du modèle. De grands coefficients augmentent la pénalité. Pour garder un coût total faible, le modèle est contraint de maintenir des coefficients réduits — ce qui conduit à des solutions plus simples et plus généralisables.

Le λ (lambda) contrôle l’importance de la pénalité. Plus λ est élevé, plus la pression pour rester simple est forte. Un λ faible laisse davantage le modèle se concentrer sur l’ajustement des données. Vous verrez comment le régler dans la section Choisir l’intensité de la régularisation ci-dessous.

Les types de régularisation en apprentissage automatique

Il existe plusieurs façons de pénaliser la complexité. Chacune exerce une pression différente sur les coefficients, ce qui les rend adaptées à des situations variées.

Régularisation L2 (régression Ridge)

La L2 pénalise le carré de chaque coefficient. Plus un coefficient est grand, plus il contribue à la pénalité — et plus le modèle cherche à le réduire.

Régularisation L2

Le mot-clé ici est rétrécir. La L2 pousse tous les coefficients vers zéro, sans les annuler totalement. Chaque variable reste dans le modèle, mais avec un poids plus faible. Ridge est donc un bon choix par défaut si vous pensez que la plupart de vos variables sont utiles et si vous voulez un modèle stable et bien conditionné.

Régularisation L1 (régression Lasso)

La L1 pénalise la valeur absolue de chaque coefficient, au lieu du carré.

Régularisation L1

Cette petite différence a une grande conséquence. La L1 peut ramener des coefficients exactement à zéro, ce qui revient à supprimer des variables du modèle. C’est une sélection automatique de variables. Autrement dit, la régularisation Lasso peut simplifier votre modèle en éliminant des caractéristiques.

L1 vs L2

La différence essentielle tient à la parcimonie. La L1 produit des modèles parcimonieux — seul un sous-ensemble de variables subsiste. La L2 produit des modèles denses — toutes les variables restent, avec des poids plus faibles.

Cela influe aussi sur l’interprétabilité. Un modèle Lasso avec 5 variables actives est plus simple à expliquer qu’un Ridge avec 50 variables contribuant chacune un peu. Mais Ridge est généralement plus stable quand les variables sont corrélées, car il répartit le poids au lieu d’en sélectionner une au hasard.

Voici un aperçu rapide des différences :

Régularisation L1 vs L2

Pour comparer ces méthodes en Python, consultez notre tutoriel sur Lasso et Ridge en Python.

Régularisation Elastic Net

Elastic Net combine L1 et L2 en un seul terme de pénalité.

Régularisation Elastic Net

L’objectif est de tirer parti des deux : la sélection de variables de L1 et la stabilité de L2. Utile lorsque vos variables sont corrélées et que vous souhaitez tout de même en éliminer certaines. Lasso a tendance à en choisir une seule parmi un groupe corrélé et ignorer les autres. Elastic Net gardera plus volontiers quelques variables tout en supprimant les non pertinentes.

Régularisation selon les modèles

La régularisation apparaît dans de nombreux modèles d’apprentissage automatique, sous des formes différentes. Voici les principales.

La régression linéaire est souvent le premier terrain de découverte : en ajoutant une régularisation L2, on obtient Ridge ; avec L1, on obtient Lasso. Les mathématiques restent les mêmes : un terme de pénalité ajouté à la perte des moindres carrés.

La régression logistique fonctionne de la même manière. La fonction de perte change — entropie croisée au lieu d’erreur quadratique — mais la pénalité est identique. La plupart des bibliothèques appliquent par défaut la L2 à la régression logistique, d’où le paramètre C dans scikit-learn. C’est l’inverse de λ : un C plus petit signifie une régularisation plus forte.

Les réseaux de neurones utilisent plusieurs approches :

• Weight decay : régularisation L2 appliquée aux poids du réseau — même principe, à plus grande échelle
• Dropout : pendant l’entraînement, une fraction de neurones est désactivée aléatoirement à chaque passe, ce qui évite au réseau de s’appuyer excessivement sur un seul chemin.

Ces deux méthodes réduisent le surapprentissage, mais par des voies différentes.

Les modèles à base d’arbres n’utilisent pas de pénalités sur la perte. Ils contrôlent la complexité via l’élagage : limiter la profondeur maximale ou supprimer des branches dont l’apport prédictif est insuffisant. Des hyperparamètres comme max_depth et min_samples_split dans scikit-learn jouent un rôle de régularisation, même s’ils ne sont pas nommés ainsi.

Régularisation et compromis biais-variance

La régularisation, c’est l’art du compromis.

En ajoutant une pénalité, vous restreignez ce que le modèle peut faire. Il ne peut plus épouser aussi étroitement les données d’entraînement. Cette contrainte introduit du biais — le modèle fait volontairement des hypothèses un peu fausses, parce que vous lui imposez la simplicité.

Mais la même contrainte réduit la variance. Un modèle qui ne peut pas coller à chaque point est moins sensible aux échantillons spécifiques sur lesquels il a été entraîné. En le réentraînant sur un jeu légèrement différent, vous obtiendrez un résultat similaire. Cette stabilité est précisément ce que vous recherchez pour éviter les échecs en production.

Sans régularisation, vous avez un modèle très flexible avec un faible biais (peu d’hypothèses, excellent ajustement sur l’entraînement) et une variance élevée (de petites variations d’entraînement produisent des modèles très différents, donc peu fiables sur de nouvelles données).

La régularisation déplace l’équilibre. Un peu plus de biais en échange d’une forte baisse de variance conduit généralement à de meilleures performances sur des données inédites. Ce compromis est presque toujours payant.

Choisir l’intensité de la régularisation

En tant que praticien de l’apprentissage automatique, vous devrez régler l’intensité de la régularisation après avoir choisi le type.

Cette intensité est pilotée par un hyperparamètre — souvent noté lambda (λ) en mathématiques, ou alpha dans scikit-learn. C’est le multiplicateur devant le terme de pénalité. En le modifiant, vous ajustez la pression exercée pour simplifier le modèle.

Si vous vous trompez dans un sens ou dans l’autre, vous aurez des problèmes en production :

• Trop faible : la pénalité est trop faible pour peser. Le modèle surapprend, comme sans régularisation.
• Trop forte : la pénalité domine. Le modèle est tellement contraint qu’il ne parvient plus à capter les vrais motifs des données. C’est le sous-apprentissage.

La bonne valeur se situe entre les deux, sans réponse universelle. Elle dépend de vos données, de votre modèle et du niveau de bruit.

La méthode standard pour la trouver est la validation croisée. Vous découpez vos données d’entraînement en plis, entraînez le modèle sur des combinaisons de plis et mesurez la performance de validation pour une plage de valeurs d’alpha. La valeur qui maximise la performance moyenne de validation est celle à retenir.

Dans scikit-learn, RidgeCV et LassoCV automatise nt ce processus — ils lancent une validation croisée sur une grille d’alpha et sélectionnent la meilleure valeur.

from sklearn.linear_model import RidgeCV

model = RidgeCV(alphas=[0.01, 0.1, 1.0, 10.0], cv=5)
model.fit(X_train, y_train)

print(model.alpha_)

La valeur d’alpha affichée correspond au meilleur réglage trouvé par validation croisée. Démarrez avec une plage large, puis resserrez autour de la zone optimale.

Conclusion

La régularisation empêche un modèle d’être « trop malin pour son propre bien ».

Elle pénalise la complexité, obligeant le modèle à trouver des solutions qui généralisent plutôt que de mémoriser l’entraînement. La L2 conserve toutes les variables en réduisant leur influence. La L1 supprime les variables non pertinentes. Elastic Net combine les deux. Et, qu’il s’agisse de modèles linéaires, de régression logistique, de réseaux de neurones ou d’ensembles, la même idée se décline sous des formes différentes — et n’est pas toujours nommée « régularisation ».

L’essentiel est de choisir la bonne technique et le bon niveau de pénalisation. Ce que vous devez faire, c’est expérimenter. Testez différentes approches et plusieurs réglages. Ne vous contentez pas d’un choix par défaut.

Vos données vous diront ce qui fonctionne.

Pour voir davantage de techniques de régularisation en pratique, inscrivez-vous à notre parcours Machine Learning Scientist in Python. Il propose 85 heures de contenu pour vous rendre opérationnel.