Aller au contenu
Data science

Entraîner un réseau : optimiseurs, régularisation, courbes d'apprentissage

⏱ 1 h 30

Prérequis : La rétropropagation · Sous-apprentissage et surapprentissage

À la fin de ce chapitre, vous saurez :
  • expliquer les notions d'époque, de mini-paquet et de taux d'apprentissage ;
  • comparer SGD, momentum, RMSProp et Adam ;
  • mettre en œuvre le dropout, la pénalité L2, la normalisation par lots et l'arrêt précoce ;
  • diagnostiquer un entraînement à partir de ses courbes d'apprentissage.

Calculer le gradient sur toutes les données à chaque pas coûterait trop cher sur des millions d’exemples. On l’estime sur un mini-paquet (mini-batch) de quelques dizaines à quelques centaines d’exemples tirés au hasard : c’est la descente de gradient stochastique (SGD).

  • une itération : un mini-paquet, une propagation avant et arrière, une mise à jour ;
  • une époque : un passage complet sur les données d’entraînement (n/taille du paquetn / \text{taille du paquet} itérations).

Le gradient d’un mini-paquet est bruité : il pointe à peu près dans la bonne direction, en zigzaguant. Ce bruit n’est pas seulement un défaut : il aide à sortir des zones plates et des mauvais minima, et semble favoriser des solutions qui généralisent bien. Des paquets plus grands donnent des gradients plus précis et exploitent mieux les GPU, mais demandent souvent d’ajuster le taux d’apprentissage.

La descente de gradient simple avance proportionnellement à la pente. Dans une vallée allongée (une direction très pentue, l’autre presque plate, situation courante), le taux d’apprentissage est limité par la direction pentue (au-delà, on rebondit d’un bord à l’autre, puis on diverge) ; il est alors bien trop petit pour la direction plate, où l’on rampe. Les optimiseurs modernes corrigent ce défaut :

  • Momentum : on accumule une vitesse, somme amortie des gradients récents. Dans la direction constante (le fond de la vallée), la bille prend de l’élan et accélère ; en contrepartie, elle peut dépasser et osciller dans la direction pentue.
  • RMSProp : on divise chaque pas par la taille récente du gradient dans chaque direction. Les directions pentues sont freinées, les directions plates accélérées.
  • Adam (2014) : momentum et RMSProp à la fois. C’est l’optimiseur par défaut de la plupart des projets ; avec un taux de 10−310^{-3}, il marche souvent du premier coup.

Faites varier le taux d’apprentissage : trop petit, tout le monde rampe ; trop grand, SGD et le momentum divergent. C’est l’hyperparamètre le plus important d’un réseau ; s’il ne fallait en régler qu’un, ce serait lui.

🎓 Pour aller plus loin : les formules des optimiseurs

Notons gtg_t le gradient à l’itération tt, η\eta le taux d’apprentissage. Toutes les opérations sont faites coordonnée par coordonnée.

  • SGD : w←w−η gtw \leftarrow w - \eta\, g_t.
  • Momentum : vt=βvt−1+gtv_t = \beta v_{t-1} + g_t, puis w←w−η vtw \leftarrow w - \eta\, v_t, avec β≈0,9\beta \approx 0{,}9. Dans une direction où le gradient est constant, la vitesse atteint g/(1−β)g / (1 - \beta) : un pas 10 fois plus grand.
  • RMSProp : st=ρ st−1+(1−ρ) gt2s_t = \rho\, s_{t-1} + (1 - \rho)\, g_t^2, puis w←w−η gt/(st+ϵ)w \leftarrow w - \eta\, g_t / (\sqrt{s_t} + \epsilon).
  • Adam : mt=β1mt−1+(1−β1)gtm_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t et st=β2st−1+(1−β2)gt2s_t = \beta_2 s_{t-1} + (1 - \beta_2) g_t^2 (avec β1=0,9\beta_1 = 0{,}9, β2=0,999\beta_2 = 0{,}999), corrigés du biais de départ : m^t=mt/(1−β1t)\hat m_t = m_t / (1 - \beta_1^t), s^t=st/(1−β2t)\hat s_t = s_t / (1 - \beta_2^t). Puis w←w−η m^t/(s^t+ϵ)w \leftarrow w - \eta\, \hat m_t / (\sqrt{\hat s_t} + \epsilon).

Le pas d’Adam a une taille d’environ η\eta quelle que soit l’échelle du gradient : c’est ce qui le rend si facile à régler.

Planifier le taux. On fait souvent varier η\eta au cours de l’entraînement : une montée progressive (warm-up) pendant les premières itérations, puis une décroissance (par paliers, exponentielle ou en cosinus). En fin d’entraînement, un petit taux permet de descendre au fond de la vallée au lieu de rebondir sur ses bords.

AdamW. Dans Adam, ajouter la pénalité L2 au gradient n’équivaut plus à réduire les poids, car le pas est renormalisé. AdamW applique la réduction des poids (weight decay) séparément ; c’est la version utilisée pour entraîner les transformers.

Un réseau a souvent plus de paramètres que d’exemples : il peut tout mémoriser. Toutes les armes contre le surapprentissage vues en régression s’appliquent, plus quelques-unes propres aux réseaux.

Entraînez d’abord sans rien : vers quelques centaines d’itérations, la perte de validation remonte pendant que celle d’entraînement continue de baisser, et la frontière se tord autour des 30 points. Puis réinitialisez avec chaque remède.

  • Pénalité L2 (weight decay) : on ajoute λ2∑w2\frac{\lambda}{2} \sum w^2 à la perte ; les poids restent petits, la fonction reste lisse. C’est la régression Ridge appliquée à un réseau.
  • Dropout : à chaque itération, on éteint au hasard une partie des neurones (20 à 50 %). Le réseau ne peut plus compter sur un neurone particulier ni sur des combinaisons fragiles ; c’est un peu comme entraîner une foule de sous-réseaux qui votent ensuite (on retrouve l’idée des méthodes d’ensemble). Le dropout n’agit que pendant l’entraînement ; à la prédiction, tous les neurones sont actifs.
  • Arrêt précoce : on surveille la perte de validation et on garde les poids de son minimum. Simple, efficace, presque gratuit : on l’utilise quasiment toujours.
  • Plus de données, ou des données augmentées (images retournées, recadrées…), le remède le plus puissant (partie 6).

La normalisation par lots (batch normalization, 2015) recentre et réduit les valeurs de chaque neurone sur le mini-paquet (moyenne 0, écart-type 1), puis leur applique une échelle et un décalage appris. Elle stabilise et accélère fortement l’entraînement des réseaux profonds (on peut prendre un taux plus grand), et régularise un peu, grâce au bruit des statistiques de chaque paquet. À la prédiction, on utilise des moyennes calculées pendant l’entraînement. Les transformers utilisent une variante, la normalisation par couche, qui ne dépend pas de la taille du paquet.

On trace la perte (et une métrique) sur l’entraînement et sur la validation, à chaque époque. Ces courbes sont le tableau de bord de l’entraînement :

Ce qu’on voit Diagnostic Que faire
la perte explose ou devient nan taux d’apprentissage trop grand (ou gradient qui explose) diviser le taux par 10, écrêter le gradient, vérifier les données
la perte baisse très lentement, presque en ligne droite taux trop petit multiplier le taux par 3 à 10
les deux pertes stagnent haut, proches l’une de l’autre sous-apprentissage réseau plus grand, entraîner plus longtemps, meilleures variables
l’entraînement baisse, la validation remonte surapprentissage arrêt précoce, dropout, L2, plus de données, réseau plus petit
courbes très bruitées paquets trop petits ou taux trop grand paquets plus grands, taux plus petit
validation meilleure que l’entraînement normal avec le dropout (actif à l’entraînement seulement) rien ; vérifier qu’il n’y a pas de fuite

Une recette éprouvée. Commencez petit : vérifiez que le réseau sait surapprendre un tout petit lot (10 exemples, perte proche de 0). S’il n’y arrive pas, il y a un bug. Puis passez à toutes les données avec Adam (10−310^{-3}) et l’arrêt précoce, et seulement ensuite ajoutez la régularisation et réglez le reste.

🔬Courbes d'apprentissage en direct

Deux couches de 16 neurones sur les lunes, 200 époques : suivez les courbes de perte d’entraînement et de validation. Changez le taux d’apprentissage (0,0001, puis 0,5) et comparez.

→
import keras
from keras import layers, regularizers
modele = keras.Sequential([
keras.Input(shape=(X_train.shape[1],)),
layers.Dense(64, kernel_regularizer=regularizers.l2(1e-4)), # pénalité L2
layers.BatchNormalization(), # normalisation par lots
layers.Activation("relu"),
layers.Dropout(0.3), # 30 % de neurones éteints à chaque itération
layers.Dense(64, activation="relu"),
layers.Dropout(0.3),
layers.Dense(1, activation="sigmoid"),
])
modele.compile(optimizer=keras.optimizers.Adam(learning_rate=1e-3), loss="binary_crossentropy", metrics=["AUC"])
historique = modele.fit(
X_train, y_train, validation_split=0.2, epochs=500, batch_size=64,
callbacks=[keras.callbacks.EarlyStopping(monitor="val_loss", patience=20, restore_best_weights=True),
keras.callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5, patience=8)])
import matplotlib.pyplot as plt
plt.plot(historique.history["loss"], label="entraînement"); plt.plot(historique.history["val_loss"], label="validation"); plt.legend()

✅ Vérifiez vos acquis

1. Avec 10 000 exemples et des paquets de 100, combien d'itérations compte une époque ?
2. Dans une vallée allongée, pourquoi SGD progresse-t-il lentement ?
3. La perte d'entraînement devient « nan » après quelques itérations. Première chose à essayer ?
4. Que fait le dropout pendant la prédiction ?
5. La perte d'entraînement baisse, la perte de validation remonte depuis 30 époques. Diagnostic ?
6. Avant d'entraîner sur toutes les données, quel test simple détecte un bug ?