Regularization

La régularisation est toute modification de la manière dont un modèle est entraîné qui vise à réduire son erreur sur de nouvelles données, même si son erreur sur les données d’entraînement augmente. Elle lutte contre le surapprentissage, où un modèle ayant une capacité suffisante mémorise le bruit et les particularités des exemples qu’il a vus. La régularisation limite la complexité effective d’un modèle en pénalisant les grands poids, en injectant du bruit, en ajoutant des données variées ou en arrêtant l’entraînement prématurément. En termes de biais-variance, elle accepte un léger biais supplémentaire en échange d’une réduction plus importante de la variance.

Pénalités L1 et L2#

La forme classique ajoute une pénalité sur les poids à la fonction de perte : perte totale = perte sur les données + λ × pénalité. La régularisation L2 pénalise la somme des carrés des poids, Σw², ce qui ramène chaque poids vers zéro proportionnellement à sa valeur ; dans les modèles linéaires, on parle de régression ridge. La régularisation L1 pénalise la somme des valeurs absolues des poids ; sa force constante ramène exactement à zéro de nombreux poids. La régression linéaire pénalisée par L1, appelée Lasso, sert donc aussi à sélectionner les caractéristiques. Le filet élastique combine les deux. L’intensité de la pénalité λ, appelée alpha dans scikit-learn, est un hyperparamètre : si elle est trop faible, le modèle reste en surapprentissage ; si elle est trop élevée, il sous-apprend. L’ajustement d’un polynôme de degré 9 à 12 points bruités d’une sinusoïde illustre ces deux modes d’échec :

import numpy as np
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures

rng = np.random.default_rng(0)

# 12 noisy training points from a sine wave, plus clean test points
x_train = rng.uniform(0, 1, (12, 1))
y_train = np.sin(2 * np.pi * x_train[:, 0]) + rng.normal(0, 0.2, 12)
x_test = np.linspace(0, 1, 200)[:, None]
y_test = np.sin(2 * np.pi * x_test[:, 0])

# The same degree-9 polynomial, fit with a growing L2 penalty on its coefficients
for alpha in (0.0, 1e-4, 1e-2, 1.0):
    model = make_pipeline(PolynomialFeatures(9), Ridge(alpha=alpha)).fit(x_train, y_train)
    train_mse = np.mean((model.predict(x_train) - y_train) ** 2)
    test_mse = np.mean((model.predict(x_test) - y_test) ** 2)
    weight_norm = np.linalg.norm(model[-1].coef_)
    print(f"alpha {alpha:g}: train MSE {train_mse:.4f}, test MSE {test_mse:.4f}, |w| {weight_norm:.1f}")

Sans pénalité, le polynôme épouse le bruit : la norme de ses coefficients atteint environ 425 000, son erreur d’entraînement est de 0,0148 et son erreur de test est de 0,1859. Une pénalité de 0,0001 ramène la norme des coefficients à 20,8 et réduit l’erreur de test d’un facteur onze, à 0,0170, tandis que l’erreur d’entraînement augmente à 0,0334. Avec un alpha de 1, la pénalité domine et le modèle sous-apprend, avec une erreur de test de 0,3998.

Décroissance des poids et dropout dans les réseaux neuronaux#

Dans les réseaux neuronaux, la régularisation L2 prend généralement la forme d’une décroissance des poids : chaque mise à jour réduit aussi chaque poids d’une petite fraction de sa valeur. Pour la descente de gradient stochastique classique, les deux sont équivalentes. Pour les optimiseurs adaptatifs comme Adam, un terme L2 ajouté au gradient est divisé par la mise à l’échelle propre à chaque paramètre d’Adam ; les poids associés à de grands gradients sont donc à peine régularisés. La décroissance des poids découplée applique directement cette réduction, et l’optimiseur AdamW qui en résulte est le choix standard pour les transformeurs.

Une couche de dropout met à zéro la sortie de chaque unité avec une probabilité p à chaque étape d’entraînement et multiplie les sorties restantes par 1/(1 − p). Le réseau ne peut donc pas dépendre d’une seule unité et entraîne en pratique de nombreux sous-réseaux réduits qui partagent leurs poids. Lors de l’inférence, toutes les unités restent actives. Dans les expériences originales, une probabilité de dropout de 0,5 pour les unités cachées était proche de l’optimum sur un large éventail de réseaux et de tâches.

L’entraînement Ultralytics YOLO expose les deux paramètres : weight_decay, défini par défaut à 0,0005, s’applique uniquement aux poids des couches convolutionnelles et linéaires, et ignore les biais ainsi que les paramètres des couches de normalisation ; dropout, défini par défaut à 0,0, agit juste avant la dernière couche linéaire des modèles de classification YOLO26.

from ultralytics import YOLO

# Charger un modèle de classification YOLO26n préentraîné
model = YOLO("yolo26n-cls.pt")

# Entraîner avec du dropout dans la tête de classification et une décroissance des poids plus forte
results = model.train(data="mnist160", epochs=10, dropout=0.2, weight_decay=0.001)

Autres techniques de régularisation#

• Augmentation des données : Les retournements, recadrages, changements d’échelle et de couleur, ainsi que le mosaïquage, diversifient les images d’entraînement. Le modèle voit ainsi chaque objet dans bien plus de conditions que celles présentes dans le jeu de données brut.
• Lissage des étiquettes : Remplace les cibles de classification one-hot par des cibles légèrement adoucies, afin que le modèle cesse de pousser ses logits vers une confiance extrême.
• Régularisation implicite : Le bruit des gradients dû à l’entraînement en petits lots et le bruit d’un lot à l’autre produit par la normalisation par lots régularisent tous deux le modèle sans terme explicite.

L’arrêt anticipé régularise le modèle en limitant la durée d’entraînement. Il évalue le modèle sur les données de validation après chaque époque et s’arrête dès que le score n’a pas progressé pendant un nombre défini d’époques, appelé patience, tout en conservant les meilleurs poids obtenus jusque-là :

Régularisation et termes associés#

• Normalisation : Redimensionne les entrées ou les activations pour accélérer et stabiliser l’entraînement. La normalisation par lots ne régularise le modèle qu’à titre d’effet secondaire.
• Réglage des hyperparamètres : Recherche de bonnes valeurs pour les paramètres de régularisation, comme λ, la probabilité de dropout et la patience, ainsi que pour tous les autres hyperparamètres.
• Ensembles de modèles : Réduisent la variance en moyennant les prédictions de plusieurs modèles entraînés indépendamment. Le dropout approxime un tel ensemble au sein d’un seul réseau : l’entraînement échantillonne parmi un nombre exponentiel de sous-réseaux réduits, et l’exécution du réseau complet avec toutes les unités actives au moment du test approxime la moyenne de leurs prédictions.