# 3. Optimisation La rétropropagation renvoie le gradient du coût par rapport à chaque paramètre. Un optimiseur est la règle qui transforme ces gradients en mises à jour. Ce module couvre les variantes de la descente de gradient et les optimiseurs adaptatifs (momentum, RMSProp, Adam) qui rendent les réseaux profonds entraînables, ainsi que les plannings de taux d'apprentissage qui façonnent l'entraînement. ## 3.1 Descente de gradient Soit $w$ l'ensemble de tous les paramètres (chaque $W^{[l]}$ et $b^{[l]}$) et soit $J(w)$ le coût, la moyenne de la perte par exemple $L$. Notons $g = \nabla_w J(w)$ le gradient du coût par rapport aux paramètres, tel que renvoyé par la rétropropagation. La mise à jour de base déplace $w$ dans le sens de la descente : $$\boxed{ w \leftarrow w - \alpha\, g }$$ avec un taux d'apprentissage $\alpha > 0$. C'est la mise à jour LMS du cours de Machine Learning, écrite pour le vecteur complet des paramètres au lieu d'une seule coordonnée. *Remarque :* le biais est explicite ici. Le gradient $g$ possède un bloc par $W^{[l]}$ et un par $b^{[l]}$, et la mise à jour s'applique à chaque bloc avec le même $\alpha$. ### 3.1.1 Batch, mini-batch, stochastique Les variantes ne diffèrent que par le nombre d'exemples qui entrent dans le gradient $g$ à chaque étape. | variante | exemples par étape | bruit de la mise à jour | par étape | à utiliser quand | | --- | --- | --- | --- | --- | | GD batch | tous les $m$ | aucun | $O(m)$ passes | $m$ petit, gradient exact souhaité | | GD mini-batch | un batch de $B$ | modéré | $O(B)$ | le choix par défaut pour les réseaux profonds | | GD stochastique (SGD) | un exemple | élevé | $O(1)$ | flux de données, $m$ très grand | *Remarque :* un passage complet sur l'ensemble du jeu de données est une époque. Le mini-batch est le choix standard : des batchs de $32$ à $512$ tiennent dans l'accélérateur, exploitent les produits matriciels vectorisés, et le bruit résiduel dans $g$ aide à échapper aux minima locaux peu profonds. En apprentissage profond, « SGD » est employé de façon souple pour désigner la descente de gradient par mini-batch. ## 3.2 Momentum La SGD simple zigzague à travers les vallées étroites parce que le gradient pointe davantage en travers de la vallée que le long de celle-ci. Le momentum accumule une moyenne pondérée exponentiellement des gradients passés dans un vecteur de vitesse $v$, puis avance dans cette direction moyennée : $$\boxed{ v \leftarrow \beta\, v + g, \qquad w \leftarrow w - \alpha\, v }$$ avec un coefficient de momentum $\beta \in [0, 1)$, typiquement $\beta = 0.9$. Les composantes de $g$ qui gardent le même signe se renforcent mutuellement, si bien que $v$ croît et que le pas accélère le long des directions cohérentes. Les composantes qui changent de signe s'annulent dans la moyenne, si bien que les oscillations en travers de la vallée sont amorties.  *Les courbes sont les lignes de niveau de la perte, le point est le minimum. Le gradient est perpendiculaire à la ligne de niveau où il se trouve, dans un ravin il pointe donc surtout en travers de la vallée, et la descente de gradient brute rebondit. Le momentum garde une mémoire des pas précédents, les rebonds s'annulent et la direction de la vallée s'accumule.* ### 3.2.1 Momentum de Nesterov Le gradient accéléré de Nesterov évalue le gradient en un point d'anticipation, après que le pas de momentum a été appliqué à titre provisoire, plutôt qu'au $w$ courant. Cette correction anticipatrice réagit plus tôt lorsque la pente change : $$\boxed{ v \leftarrow \beta\, v + \nabla_w J(w - \alpha \beta\, v), \qquad w \leftarrow w - \alpha\, v }$$ *Remarque :* voir $\beta \approx 0.9$ comme une moyenne sur environ les $\tfrac{1}{1 - \beta} = 10$ derniers gradients. Nesterov converge en général un peu plus vite que le momentum simple pour les mêmes $\alpha$ et $\beta$. ## 3.3 RMSProp Différents paramètres peuvent nécessiter des tailles de pas très différentes, et un unique $\alpha$ global ne peut pas tous les servir. RMSProp maintient une moyenne glissante par coordonnée $s$ des gradients au carré, puis divise le pas par $\sqrt{s}$, de sorte que les coordonnées aux gradients récents importants prennent des pas plus petits et que les coordonnées calmes prennent des pas plus grands : $$\boxed{ s \leftarrow \rho\, s + (1 - \rho)\, g^2, \qquad w \leftarrow w - \alpha\, \frac{g}{\sqrt{s} + \epsilon} }$$ avec une décroissance $\rho \approx 0.9$ et un petit $\epsilon \approx 10^{-8}$ pour la sûreté numérique. Ici $g^2 = g \odot g$ est le carré de Hadamard (élément par élément) et la division est élément par élément, de sorte que chaque coordonnée est normalisée par sa propre échelle de gradient récente. *Remarque :* $s$ estime le moment d'ordre deux non centré de chaque coordonnée de $g$, si bien que $\sqrt{s}$ correspond à peu près à sa magnitude quadratique moyenne récente. RMSProp convient aux objectifs non stationnaires, ce qui est exactement le cas d'un gradient de mini-batch mobile. ## 3.4 Adam Adam (adaptive moment estimation) combine le momentum et RMSProp : il maintient une estimation du moment d'ordre un $m$ (la moyenne du gradient) et une estimation du moment d'ordre deux $v$ (la moyenne du gradient au carré). $$\boxed{ m \leftarrow \beta_1\, m + (1 - \beta_1)\, g, \qquad v \leftarrow \beta_2\, v + (1 - \beta_2)\, g^2 }$$ $m$ et $v$ démarrent tous deux à zéro, si bien qu'au début de l'entraînement ils sont biaisés vers zéro. Diviser par $1 - \beta_1^t$ et $1 - \beta_2^t$ à l'étape $t$ supprime ce biais : $$\boxed{ \hat m = \frac{m}{1 - \beta_1^{\,t}}, \qquad \hat v = \frac{v}{1 - \beta_2^{\,t}} }$$ La mise à jour avance ensuite dans la direction du momentum, redimensionnée par coordonnée par le moment d'ordre deux : $$\boxed{ w \leftarrow w - \alpha\, \frac{\hat m}{\sqrt{\hat v} + \epsilon} }$$ Les valeurs par défaut courantes sont $\beta_1 = 0.9$, $\beta_2 = 0.999$ et $\epsilon = 10^{-8}$. Comme précédemment, le carré, la racine carrée et la division sont élément par élément. *Remarque :* la correction de biais compte surtout dans les premières dizaines d'étapes, quand $t$ est petit et que $\beta_2^t$ est encore proche de $1$. Sans elle, $\hat v$ serait bien trop petit et les premiers pas bien trop grands. AdamW, une variante courante, découple la décroissance des poids (weight decay) de cette mise à jour.  *Adam combine le momentum des gradients moyennés avec la mise à l'échelle par paramètre de RMSProp.* ## 3.5 Plannings de taux d'apprentissage Le taux d'apprentissage $\alpha$ est l'hyperparamètre le plus important à lui seul, et le maintenir fixe est rarement optimal. Un grand $\alpha$ accélère les progrès initiaux mais empêche de se stabiliser dans un minimum, si bien que les plannings diminuent généralement $\alpha$ au fil de l'entraînement. Ici $\alpha_0$ est le taux initial et $t$ indexe l'étape ou l'époque. ### 3.5.1 Décroissance par paliers Multiplier $\alpha$ par un facteur $\gamma \in (0, 1)$ toutes les $s$ époques, de sorte qu'il chute par étapes discrètes : $$\boxed{ \alpha_t = \alpha_0\, \gamma^{\lfloor t / s \rfloor} }$$ ### 3.5.2 Décroissance en cosinus Recuire $\alpha$ en douceur depuis $\alpha_0$ vers un plancher nul le long d'un demi-cosinus sur un total de $T$ étapes : $$\boxed{ \alpha_t = \tfrac{1}{2}\,\alpha_0\left(1 + \cos\frac{\pi t}{T}\right) }$$ ### 3.5.3 Warmup Le warmup fait monter $\alpha$ linéairement depuis une petite valeur au cours des premières centaines à quelques milliers d'étapes, puis passe la main à un planning de décroissance. Il évite les mises à jour importantes et mal conditionnées qu'un démarrage à froid avec un grand $\alpha$ produirait, et il est standard pour les réseaux profonds tels que les transformeurs. | planning | forme | usage principal | | --- | --- | --- | | Décroissance par paliers | chutes en escalier | entraînement classique en vision | | Cosinus | recuit en douceur vers zéro | choix par défaut moderne, souvent avec warmup | | Warmup | montée linéaire, puis décroissance | stabiliser les premières étapes, grands modèles |  *Plannings courants de taux d'apprentissage : décroissance par paliers, décroissance en cosinus, et un warmup suivi de décroissance.* *Remarque :* le warmup et une décroissance sont généralement combinés, le warmup pour la première phase et le cosinus ou la décroissance par paliers ensuite. ## 3.6 Choisir un optimiseur | optimiseur | ce qu'il ajoute | suit | usage typique | | --- | --- | --- | --- | | SGD | rien, règle de base | rien | référence solide, meilleure précision finale avec réglage | | Momentum | vitesse, amortit les oscillations | moment d'ordre un $v$ | modèles de vision, avec un planning | | RMSProp | mise à l'échelle par coordonnée | moment d'ordre deux $s$ | RNN, objectifs non stationnaires | | Adam | momentum plus mise à l'échelle, corrigé du biais | moments d'ordre un et deux | le premier choix par défaut pour la plupart des réseaux | *Remarque :* Adam est le choix par défaut sûr et converge vite avec peu de réglage. Une SGD bien réglée avec momentum et un planning atteint souvent une précision de test finale légèrement meilleure sur les grands modèles de vision, raison pour laquelle les deux restent largement utilisés.  *Sur une surface de perte allongée, le momentum et Adam atteignent le minimum bien plus vite que la descente de gradient simple.* ## 3.7 Les bonnes pratiques Deux des habitudes qui font qu'un entraînement se passe bien, l'initialisation soignée et le dropout, vivent dans la prochaine leçon ([Entraîner les réseaux profonds](/fr/Deep%20Learning/04%20Training%20deep%20networks)). Deux autres ont leur place ici. **Centrer et normaliser les entrées.** Standardiser chaque caractéristique (soustraire sa moyenne, diviser par son écart-type), pour qu'aucune ne domine les premiers produits scalaires et que les gradients de la première couche démarrent bien mis à l'échelle. **Vérifier avant d'entraîner longtemps.** Un classifieur à $K$ classes fraîchement initialisé doit démarrer près de la perte $\ln K$ (environ $2{,}3$ pour $K = 10$). Un minuscule jeu d'entraînement doit être facile à surapprendre : si le réseau n'y arrive pas, le code est cassé. Surveiller les courbes d'entraînement et de validation. Et comme la rétropropagation est source d'erreurs, comparer son gradient analytique à une estimation numérique par différences finies : $$\boxed{ \frac{\partial L}{\partial w} \approx \frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon} }$$ *Chaque optimiseur présenté ici met à l'échelle le gradient brut, si bien que son comportement dépend de la taille de ces gradients au départ. La partie suivante étudie comment les poids initiaux et la profondeur du réseau fixent cette échelle, et comment de mauvais choix font disparaître ou exploser les gradients.* --- Suivant : [Entraîner les réseaux profonds](/fr/Deep%20Learning/04%20Training%20deep%20networks) · [Vue d'ensemble du cours](/fr/Deep%20Learning)