Retour au blog
Articles

La descente de gradient en images

En 1847, pour calculer des orbites célestes, Cauchy écrit qu'il faut « avancer d'un pas le long du gradient négatif ». Quand on entraîne aujourd'hui un grand modèle de langage, optimizer.step() fait toujours la même chose ; seule la façon de faire ce pas a donné naissance à toute une famille, de SGD à Adam, AdamW, Lion et Muon. Les frais d'envoi de douze colis dessinent une vallée oblique, et plus de trente animations calculées en direct montrent quelle lacune de la méthode précédente chaque méthode vient combler.

Ouvrez un script d'entraînement PyTorch ; dans la boucle, on trouve presque toujours ces deux lignes :

python
loss.backward()
optimizer.step()

backward() calcule dans quelle direction modifier chaque paramètre, et step() effectue réellement la modification. Cet article parle des quelques lignes qui se trouvent dans step().

La direction est déjà calculée ; il suffit de la suivre, non ? Dit comme ça, il n'y a pas grand-chose à raconter. Pourtant, la seule question de « comment faire ce pas » a donné naissance à toute une famille, de SGD, Momentum, AdaGrad, Adam et AdamW jusqu'à Lion et Muon. Presque chaque nouvelle méthode est apparue parce que la précédente avançait mal sur un certain type de paysage.

Nous partirons de la base, avec une droite et douze colis. D'abord dessiner le « gradient », puis le faire passer par une vallée longue et étroite, du bruit aléatoire, une falaise et un point selle, pour voir quelle lacune de la méthode précédente chaque méthode vient combler.

Avant de partir, un coup d'œil sur l'itinéraire complet. Chaque ligne correspond à une méthode, suivie de la lacune qu'elle vient combler :

Chaque méthode, et la lacune qu'elle combleEn partant de BGD, chaque ligne indique ce que la méthode corrige.

Les bases

  1. BGDLe point de départ : chaque pas lit toutes les données.
  2. SGD · MBGDLire toutes les données à chaque pas est trop lent → tirer un exemple ou un petit lot.
  3. SGDMZigzags et bruit → accumuler une vitesse.
  4. NAGLe momentum dépasse la cible → prendre le gradient au point d'anticipation.

Un pas par paramètre

  1. AdaGradUn seul taux pour tous les paramètres → mettre chacun à l'échelle selon ses gradients accumulés.
  2. RMSProp · AdaDeltaLe taux d'AdaGrad ne fait que baisser → une moyenne mobile qui sait oublier.
  3. Adam · NadamRéunir momentum et pas par paramètre, et corriger le départ à zéro.

Corriger Adam

  1. AMSGradAdam peut converger au mauvais endroit → ne jamais laisser v diminuer.
  2. AdamWAdam divise aussi la régularisation L2 → découpler la décroissance des poids.
  3. Warmup · Cosine · SGDR · RAdam · Schedule-FreeComment faire varier le taux, et pourquoi Adam a-t-il besoin d'échauffement ? → planifications, variance rectifiée, ou aucune planification.

Échelle et géométrie

  1. LARS · LAMBLots énormes, ‖w‖/‖g‖ très variable selon la couche → un rapport de confiance par couche.
  2. Adafactor · GaLoreL'état de l'optimiseur dévore la mémoire → le factoriser, ou le loger dans un sous-espace de rang faible.
  3. SAMUne perte basse dans une vallée étroite → comparer la pire perte dans un rayon ρ.
  4. Shampoo · SOAP · SophiaUne mise à l'échelle diagonale ne redresse pas une vallée oblique → préconditionneurs matriciels, ou courbure avec écrêtage.
  5. LionMoins d'état et de calcul → ne garder que le signe.
  6. MuonLes poids sont des matrices, pas de longues listes → orthogonaliser toute la mise à jour.

Toutes les animations de l'article sont calculées en direct dans votre navigateur, et chaque pas applique exactement la formule écrite dans le texte. Mettez sur pause, puis faites glisser le curseur pour avancer pas à pas.

Tout part d'une droite

Supposons que vous teniez une petite boutique en ligne et que vous veniez d'expédier 12 colis. Ils pèsent de 0.5 à 1.5 kg, et les frais d'envoi vont de 92 à 150 NT$.

Les frais d'envoi ressemblent à peu près à « frais de base + supplément par kg », ce qui s'écrit comme une droite :

y^=wx+b\hat y = w x + b

xx est le poids (en kg), y^\hat y les frais d'envoi prédits (en centaines de NT$), ww le supplément par kg et bb les frais de base. À partir de ces 12 enregistrements, nous voulons trouver les ww et bb les mieux adaptés.

Commençons par deviner au hasard, 210 NT$ par kg et 20 NT$ de frais de base, soit w=2.1w = 2.1 et b=0.2b = 0.2. Cette droite est trop raide ; pour les 12 colis, la prédiction dépasse le prix réel. Le plus léger est surestimé de 32 NT$, le plus lourd de 185 NT$.

Comment mesurer à quel point l'estimation est mauvaise ? On élève au carré l'erreur de chaque colis, puis on fait la moyenne :

L(w,b)=12n∑i=1n(wxi+b−yi)2L(w,b) = \frac{1}{2n}\sum_{i=1}^{n}\left(w x_i + b - y_i\right)^2

Le carré empêche les erreurs positives et négatives de s'annuler, et pénalise davantage les colis très mal prédits. Le 12\frac{1}{2} devant sert seulement à éliminer le 2 que fera descendre le carré quand nous dériverons tout à l'heure.

Ce LL s'appelle la fonction de perte (loss function). Avec notre estimation, L=0.71L = 0.71.

Vient maintenant l'idée la plus importante de tout l'article.

Chaque couple (w,b)(w, b) est une droite, et correspond aussi à une valeur de perte. Mettons ww en abscisse et bb en ordonnée, et notons en chaque point du plan sa perte ; on obtient une carte du relief. Plus la perte est faible, plus le terrain est bas. Trouver la meilleure droite revient à chercher le point le plus bas de ce paysage.

Chaque droite est un point du paysageÀ gauche, les douze colis et la droite actuelle. À droite, la perte de chaque (w, b). Touchez ou faites glisser à droite pour choisir vous-même une droite.
0.511.5012poids (kg)frais (×100 NT$)
012-1012w (par kg)b (frais de base)
0 NT$ par kg + 120 NT$ de baseL = 0.016

Les courbes concentriques de la carte sont des courbes de niveau. Tous les points d'une même courbe ont la même perte, et plus on approche de l'étoile au centre, plus la perte est faible. L'étoile se trouve en w≈0.59w \approx 0.59, b≈0.61b \approx 0.61, soit 59 NT$ par kg et 61 NT$ de frais de base ; la perte y vaut L≈0.0005L \approx 0.0005.

Remarquez la forme de ce paysage. C'est une vallée oblique, longue et étroite. Cette forme nous accompagnera tout au long de l'article ; beaucoup des méthodes qui suivent cherchent justement à en venir à bout.

Pente et gradient

Debout en un point du paysage, comment savoir de quel côté ça descend ?

Simplifions d'abord. Fixons bb à sa valeur optimale et ne faisons varier que ww ; le paysage se réduit alors à une courbe. La pente de la tangente en un point de la courbe est la dérivée dLdw\frac{dL}{dw} :

La pente indique de quel côté ça descendb est fixé à sa meilleure valeur et seul w bouge. La droite orange est la tangente ; sa pente est la dérivée dL/dw.
012012w (par kg)perte L
w = -0.40dL/dw = -1.08pente < 0 : ça descend à droite

Une pente positive veut dire que la perte augmente quand ww augmente, donc que la descente est à gauche ; avec une pente négative, la descente est à droite ; avec une pente nulle, on est au fond. Aller dans le sens opposé à la pente, c'est descendre.

Quand les deux paramètres peuvent bouger, chacun a sa dérivée partielle, c'est-à-dire la pente obtenue en ne faisant varier que lui, les autres restant fixes. Calculons-les pour notre fonction de perte :

∂L∂w=1n∑i=1n(wxi+b−yi) xi\frac{\partial L}{\partial w} = \frac{1}{n}\sum_{i=1}^{n} (w x_i + b - y_i)\,x_i ∂L∂b=1n∑i=1n(wxi+b−yi)\frac{\partial L}{\partial b} = \frac{1}{n}\sum_{i=1}^{n} (w x_i + b - y_i)

Rangées dans un vecteur, elles forment le gradient :

∇L=(∂L∂w, ∂L∂b)\nabla L = \left(\frac{\partial L}{\partial w},\ \frac{\partial L}{\partial b}\right)

Ces deux expressions se lisent facilement. On prend l'erreur de chaque colis, on la multiplie par l'influence du paramètre sur ce colis, puis on fait la moyenne. L'influence de bb vaut 1 pour tous les colis ; celle de ww est le poids xx du colis, si bien que plus un colis est lourd, plus il a son mot à dire sur ww.

Au point de départ (2.1, 0.2)(2.1,\ 0.2), les 12 colis sont tous surestimés, et le calcul donne ∇L≈(1.24, 1.10)\nabla L \approx (1.24,\ 1.10). Les deux composantes sont positives ; augmenter encore ww ou bb ferait donc monter la perte.

Le gradient, perpendiculaire à la courbe de niveau, pointe vers le hautLes flèches n'indiquent que la direction. En pointillés, la courbe de niveau qui passe par le point ; −∇L est la direction de plus forte descente.
012-1012w (par kg)b (frais de base)∇L−∇L
∇L = (1.04, 0.95)‖∇L‖ = 1.41

La figure montre deux propriétés du gradient :

  1. Il pointe dans la direction de plus forte montée ; −∇L-\nabla L est donc la direction de plus forte descente.
  2. Il est perpendiculaire à la courbe de niveau qui passe par ce point.

Pourquoi ? Si l'on fait un petit pas Δ\Delta autour d'un point θ=(w,b)\theta = (w, b), la perte varie à peu près selon

L(θ+Δ)≈L(θ)+∇L⋅ΔL(\theta + \Delta) \approx L(\theta) + \nabla L \cdot \Delta

C'est le développement de Taylor au premier ordre. Le produit scalaire s'écrit ∇L⋅Δ=∥∇L∥ ∥Δ∥cos⁡φ\nabla L \cdot \Delta = \lVert\nabla L\rVert\,\lVert\Delta\rVert \cos\varphi, où φ\varphi est l'angle entre le gradient et le pas. À longueur de pas fixée, c'est avec φ=180∘\varphi = 180^\circ, c'est-à-dire en allant à l'opposé du gradient, que la perte baisse le plus. Le long d'une courbe de niveau, la perte ne change pas ; ∇L⋅Δ=0\nabla L \cdot \Delta = 0, l'angle vaut 90∘90^\circ, et le gradient est donc perpendiculaire à la courbe de niveau.

BGD : suivre le gradient négatif

Une fois la direction de descente connue, le reste est simple. On fait un petit pas vers −∇L-\nabla L, et on recommence :

θt+1=θt−η ∇L(θt)\theta_{t+1} = \theta_t - \eta\, \nabla L(\theta_t)

η\eta (eta) est le taux d'apprentissage (learning rate) ; il fixe la longueur de chaque pas. Voilà la descente de gradient. Comme chaque pas calcule le gradient sur les 12 colis, on parle aussi de descente de gradient par lots complets (Batch Gradient Descent, BGD).

L'idée est plus ancienne que l'ordinateur. La plus ancienne trace écrite connue est une note de trois pages présentée par Cauchy à la séance de l'Académie des sciences du 18 octobre 1847, « Méthode générale pour la résolution des systèmes d'équations simultanées », publiée dans les Comptes rendus, tome 25, pages 536 à 538. Il cherchait à résoudre les équations simultanées qui déterminent l'orbite d'un corps céleste ; sa méthode consiste à élever chaque équation au carré, à additionner le tout, puis à faire diminuer cette somme en suivant la direction opposée aux dérivées partielles. Il n'y avait pas encore de taux d'apprentissage fixe ; Cauchy propose plusieurs façons de choisir le pas, dont l'une consiste à avancer dans cette direction jusqu'au point où la fonction est minimale.

Faisons un premier pas avec η=0.5\eta = 0.5 :

θ1=(2.1, 0.2)−0.5×(1.24, 1.10)=(1.48, −0.35)\begin{aligned} \theta_1 &= (2.1,\ 0.2) - 0.5 \times (1.24,\ 1.10) \\ &= (1.48,\ -0.35) \end{aligned}

La perte tombe de 0.71 à 0.040, soit plus de 90 % de moins en un seul pas.

Pas à pas, le long du gradient négatifDescente de gradient par lots complets, η = 0.5, au départ de 210 NT$ par kg + 20 NT$ de base.
0.511.5012poids (kg)frais (×100 NT$)
012-1012w (par kg)b (frais de base)
60 NT$ par kg + 60 NT$ de baseL = 0.0005

Joli premier pas. Et ensuite ?

Une fois tombé dans la vallée, le point avance lentement le long du fond. Sur la figure des colis, la droite colle aux données depuis longtemps ; pendant plus d'une centaine de pas, on ne fait plus qu'ajuster, et il faut attendre le pas 168 pour entrer à moins de 0.03 du minimum.

Pourquoi si lentement ? Et si on augmentait un peu η\eta ?

Le taux d'apprentissage : jusqu'où aller à chaque pas

Revenons au cas le plus simple, un bol à une dimension, f(u)=12au2f(u) = \frac{1}{2} a u^2. aa est la courbure du bol, c'est-à-dire sa dérivée seconde ; plus elle est grande, plus le bol est raide. Le gradient vaut aua u, donc à chaque pas :

ut+1=ut−η a ut=(1−ηa) utu_{t+1} = u_t - \eta\, a\, u_t = (1 - \eta a)\, u_t

À chaque pas, uu est multiplié une fois de plus par (1−ηa)(1 - \eta a).

Un bol, quatre tailles de pasf(u) = ½u², de courbure 1. Tous les essais partent de u = −2.4.
η = 0.1 : se traîne
η = 0.9 : rapide
η = 1.6 : oscille
η = 2.1 : diverge
hors du cadre

Dans la figure, a=1a = 1 ; les quatre essais ne diffèrent que par η\eta :

  • η=0.1\eta = 0.1 : chaque pas ne retire que 10 %, on se traîne.
  • η=0.9\eta = 0.9 : il ne reste que 10 % après chaque pas, on atteint vite le fond.
  • η=1.6\eta = 1.6 : 1−ηa=−0.61 - \eta a = -0.6 ; chaque pas passe de l'autre côté, mais de moins en moins loin, et l'on converge en oscillant.
  • η=2.1\eta = 2.1 : 1−ηa=−1.11 - \eta a = -1.1 ; chaque pas passe de l'autre côté et encore plus loin, les oscillations s'amplifient, et l'on diverge.

La condition de convergence est donc ∣1−ηa∣<1|1 - \eta a| < 1, soit η<2/a\eta < 2/a. Plus le bol est raide, plus le taux d'apprentissage doit être petit.

Une vallée longue et étroite

Notre paysage a deux dimensions, et la difficulté vient de ce qu'il a deux courbures.

En travers de la vallée, la pente est raide ; le long du fond, le terrain est presque plat. En termes d'algèbre linéaire, ce sont les deux valeurs propres de la matrice des dérivées secondes de la perte (la hessienne), qui valent ici 2.05 et 0.045, soit un rapport de 46. Ce rapport s'appelle le conditionnement (condition number) et se note κ\kappa.

Un même η\eta doit servir les deux directions à la fois. Pour ne pas diverger dans la direction raide, η\eta doit rester sous 2/2.05≈0.982/2.05 \approx 0.98 ; mais dans la direction plate, chaque pas ne réduit alors l'écart que de 0.98×0.045≈4.4%0.98 \times 0.045 \approx 4.4\% au plus, et il faut au moins plusieurs dizaines de pas. Un η\eta un peu plus grand fait rebondir le point d'un versant à l'autre dans la direction raide ; un peu plus petit, il n'avance plus dans la direction plate.

Une vallée longue et étroiteMêmes colis, même η = 0.9. Seule change la façon d'écrire le poids.
-1012-1012wb
η = 0.9À moins de 0.03 du minimum au pas 93

Avec η=0.9\eta = 0.9, le point rebondit d'un versant à l'autre dans la direction raide et trace un zigzag, tout en progressant lentement le long du fond ; il n'arrive qu'au pas 93.

Pourquoi cette vallée est-elle oblique ? Le fond suit à peu près la direction (1,−1)(1, -1), c'est-à-dire ww plus 1 et bb moins 1. Pour un colis de 1 kg, les frais prédits w×1+bw \times 1 + b ne changent pas du tout. Or le poids moyen des 12 colis est justement de 1 kg ; un ajustement dans cette direction laisse donc les prédictions presque intactes, et la perte presque inchangée. La pente et l'ordonnée à l'origine se compensent, et la vallée penche.

Cliquez sur « moyenne soustraite » dans la figure. Le poids de chaque colis perd 1 kg, et le modèle devient y^=w(x−1)+b′\hat y = w(x - 1) + b'. Les droites que l'on peut tracer sont exactement les mêmes, mais ww et la nouvelle ordonnée à l'origine b′b' ne se contraignent plus l'un l'autre ; la vallée se redresse, le conditionnement tombe à 10.9, et l'arrivée a lieu dès le pas 46. Divisez ensuite par l'écart-type, c'est la « standardisation » ; la pente devient elle aussi un nouveau w′w', les deux directions ont la même courbure, la vallée devient un bol rond, le conditionnement vaut 1, et deux pas suffisent.

Voilà pourquoi on standardise souvent les entrées avant l'entraînement. Mais dans un réseau profond, les paramètres se comptent facilement par centaines de millions, et les entrées de chaque couche ne cessent de changer ; impossible de remodeler le paysage au cas par cas.

Les méthodes qui suivent attaquent le problème sous trois angles, en gros :

  1. Se souvenir des directions récentes, pour que les allers-retours s'annulent (momentum).
  2. Donner à chaque paramètre son propre pas (AdaGrad, RMSProp, Adam).
  3. Estimer la forme du paysage, ou mesurer le pas avec une autre règle (méthode de Newton, Shampoo, Muon).

Contre la falaise

Un taux d'apprentissage trop grand fait diverger. Mais même avec un taux modeste, un seul pas peut parfois vous éjecter.

Le pas qui heurte la falaiseUne pente douce bute en u = 2.4 sur un mur abrupt. Les deux essais utilisent η = 0.6 ; celui de droite plafonne la norme du gradient à 1.
sans écrêtage
-2-1012024uL
écrêté à 1
-2-1012024uL

Ce paysage est une pente douce suivie d'un mur abrupt. Le point descend la pente jusqu'au pied du mur, et un pas tombe pile sur la paroi. Le gradient y est énorme ; au pas suivant, le point est projeté en u=−5.8u = -5.8, hors du cadre. Il lui faut près de dix pas pour revenir au mur, où il remet le pied sur la paroi et se fait de nouveau éjecter ; en 40 pas, il est projeté trois fois, dont deux hors du cadre.

On trouve ce genre de mur dans de vrais RNN. En 2013, en analysant pourquoi les RNN sont difficiles à entraîner, Pascanu, Mikolov et Bengio avancent une hypothèse. Dans les directions où le gradient explose, la courbure est généralement grande elle aussi ; la surface de perte forme alors un mur abrupt, et il suffit d'y poser le pied pour être éjecté de la vallée d'origine. Dans On the difficulty of training recurrent neural networks, ils dessinent un tel mur avec un RNN à une seule unité cachée.

Le remède est simple. Quand le gradient est trop grand, on le réduit. La forme la plus courante est l'écrêtage par la norme (clip by norm) :

g←g⋅min⁡ ⁣(1, c∥g∥)g \leftarrow g \cdot \min\!\left(1,\ \frac{c}{\lVert g \rVert}\right)

Si la longueur du gradient dépasse cc, on la ramène à cc sans changer la direction. Dans le panneau « écrêté à 1 », la norme du gradient est plafonnée à 1 ; le point fait de petits allers-retours au pied du mur, sans s'envoler. Dans PyTorch, c'est torch.nn.utils.clip_grad_norm_.

Quelle valeur donner à cc ? Pascanu et al. conseillent d'observer d'abord la norme moyenne du gradient pendant un certain temps ; tout seuil entre la moitié et dix fois cette valeur permet encore de converger, seule la vitesse en pâtit.

SGD et MBGD : quelques exemples à la fois

À chaque pas, BGD parcourt toutes les données. Avec 12 colis, peu importe ; avec les 1.28 million d'images d'entraînement d'ImageNet, chaque pas exige d'abord une propagation avant et arrière sur ces 1.28 million d'images.

La descente de gradient stochastique (Stochastic Gradient Descent, SGD) tire au hasard un seul exemple à chaque pas, et remplace le gradient global par le sien :

θt+1=θt−η ∇ℓit(θt)\theta_{t+1} = \theta_t - \eta\, \nabla \ell_{i_t}(\theta_t)

ℓi\ell_i est la perte propre au ii-ème exemple, et iti_t l'exemple tiré au pas tt.

Avec un seul exemple, le gradient est forcément imprécis. Mais si chaque exemple a la même chance d'être tiré, son espérance est exactement le gradient global :

Ei[∇ℓi(θ)]=1n∑i=1n∇ℓi(θ)=∇L(θ)\mathbb{E}_{i}\big[\nabla \ell_i(\theta)\big] = \frac{1}{n}\sum_{i=1}^{n} \nabla \ell_i(\theta) = \nabla L(\theta)

En moyenne, la direction est la bonne ; chaque pas porte simplement du bruit.

Le compromis consiste à tirer à chaque fois un petit lot (batch), par exemple 4 exemples, et à moyenner leurs gradients. C'est la descente de gradient par mini-lots (Mini-Batch Gradient Descent, MBGD). Plus le lot est grand, plus le bruit est faible ; la variance du gradient est à peu près inversement proportionnelle à la taille de lot.

12, 4 ou 1 colis par pasLes trois utilisent η = 0.5. À gauche, la droite de l'essai à un colis, et le colis qu'il a tiré à ce pas.
0.511.5012poids (kg)frais (×100 NT$)
012-1012w (par kg)b (frais de base)
BGD (12) : 2400 colis lus · À moins de 0.03 du minimum au pas 168MBGD (4) : 800 colis lus · À moins de 0.03 du minimum au pas 169SGD (1) : 200 colis lus · À moins de 0.03 du minimum au pas 178

Les trois trajectoires utilisent le même η=0.5\eta = 0.5. BGD est la plus régulière ; MBGD tremble légèrement tout du long ; SGD tremble le plus, et le colis entouré sur la figure des colis est celui qu'il a tiré pour ce pas.

Regardez pourtant combien de données chacune a lues. Les trois entrent à moins de 0.03 du minimum autour du pas 170 ; BGD lit 12 exemples par pas et en a lu 2 016 à l'arrivée, MBGD 676, et SGD seulement 178. Rapportée aux données lues, la trajectoire la plus agitée est la plus économe.

Le taux d'apprentissage doit diminuer peu à peu

SGD a un souci que BGD n'a pas. Au minimum, le gradient global est nul, mais le gradient de chaque colis ne l'est pas. Les 12 colis ne peuvent pas tous tomber exactement sur une même droite ; chacun tire encore les paramètres de son côté. Selon le colis tiré, on dévie un peu dans sa direction.

Un taux fixe ne se pose jamaisSGD à un colis, parti exactement du minimum, avec un zoom de ±0.12 autour. Les deux panneaux tirent les mêmes colis.
η fixe = 0.5
η décroissant = 0.5/(1+t/20)
η fixe = 0.500 : en moyenne à 4.2/100 du minimum sur les 50 derniers pasη décroissant = 0.031 : en moyenne à 1.5/100 du minimum sur les 50 derniers pas

Cette figure part directement du minimum, avec un seul exemple par pas. À taux fixe, les paramètres tournent sans cesse autour du minimum ; sur les 50 derniers pas, leur distance moyenne au minimum est de 0.042. Si le taux décroît avec les pas selon ηt=0.5/(1+t/20)\eta_t = 0.5/(1 + t/20), la zone d'errance rétrécit, et la distance moyenne tombe à 0.015.

Comment le faire décroître correctement ? Trop vite, on s'arrête avant d'arriver ; trop lentement, le bruit ne disparaît jamais.

Chercher le minimum, c'est chercher le point où ∇L=0\nabla L = 0, autrement dit la racine d'une équation. C'est précisément ce type de problème qu'étudient Robbins et Monro en 1951 dans « A Stochastic Approximation Method », à ceci près qu'ils n'observent à chaque fois qu'un résultat bruité. Leurs successeurs ont résumé leurs conditions sur le pas en deux lignes :

∑t=1∞ηt=∞,∑t=1∞ηt2<∞\sum_{t=1}^{\infty} \eta_t = \infty, \qquad \sum_{t=1}^{\infty} \eta_t^2 < \infty

La première garantit une longueur totale suffisante pour arriver, quelle que soit la distance de départ ; la seconde limite le bruit accumulé, ce qui permet de finir par s'arrêter. ηt∝1/t\eta_t \propto 1/t satisfait les deux, et la décroissance de la figure ci-dessus appartient à cette famille.

Le bruit a aussi du bon

Le bruit de SGD n'a d'ailleurs pas que des inconvénients.

Coincé sur un point sellef(u, v) = ½u² − ½v² + ¼v⁴, η = 0.2, départ en (1.8, 0). L'essai orange ajoute à chaque gradient un bruit d'amplitude 0.0001 environ.
012-101uvpoint selleminimumminimum
descente de gradient : f = 0.000, ‖∇f‖ = 0.000avec un peu de bruit : f = -0.250, ‖∇f‖ = 0.000

Ce paysage est f(u,v)=12u2−12v2+14v4f(u, v) = \frac{1}{2}u^2 - \frac{1}{2}v^2 + \frac{1}{4}v^4. L'origine est un point selle ; c'est un fond de vallée dans la direction uu, un sommet dans la direction vv, et le gradient y est nul. Les deux vrais fonds de vallée sont en v=±1v = \pm 1.

GD part de (1.8, 0)(1.8,\ 0) ; le gradient selon vv y est nul dès le départ et le reste pour toujours, si bien que le point glisse jusqu'au point selle et s'y arrête. Avec un tout petit peu de bruit (écart-type de 0.0001 seulement), le point est doucement poussé hors de la crête en approchant du point selle, et tombe au pas 64 dans le fond de vallée en (0,−1)(0, -1).

Sur une figure en deux dimensions, le point selle ressemble à un cas particulier. Dans « Identifying and attacking the saddle point problem in high-dimensional non-convex optimization » (2014), Dauphin et al. soutiennent que plus la dimension augmente, plus les points selles sont nombreux par rapport aux minima locaux ; quand l'entraînement ralentit, c'est souvent qu'il est coincé sur les plateaux plats autour des points selles, plutôt que tombé dans un mauvais minimum local.

Le bruit aide à s'en sortir, mais la théorie pose des conditions. En 2015, Ge et al. démontrent que si chaque point selle possède une direction de descente nette (une courbure négative), que la fonction est assez lisse et que le bruit a de la variance dans toutes les directions, alors SGD bruité quitte les points selles en un nombre polynomial de pas. Notre exemple part pile au-dessus de la crête, le pire cas choisi exprès ; depuis un point de départ aléatoire, GD ne s'arrête presque jamais exactement sur un point selle, mais il peut avancer très lentement sur un plateau plat.

SGDM : se souvenir de la direction précédente

Revenons à la vallée longue et étroite. Le problème du zigzag, c'est que dans la direction qui traverse la vallée, le gradient change de signe à chaque pas ; il pousse vers un versant, puis au pas suivant vers l'autre. Dans la direction du fond, le gradient est petit, mais il pointe toujours du même côté.

Si chaque pas tient compte non seulement du gradient actuel, mais aussi de ceux des pas précédents, la partie qui change de signe s'annule, et celle qui pointe toujours du même côté s'accumule.

Moyenne mobile exponentielle

Pour « tenir compte des pas précédents », la méthode la plus courante est la moyenne mobile exponentielle (Exponential Moving Average, EMA) :

mt=β mt−1+(1−β) gtm_t = \beta\, m_{t-1} + (1 - \beta)\, g_t

La nouvelle moyenne est l'ancienne multipliée par β\beta, plus le nouveau gradient multiplié par 1−β1 - \beta. Avec β=0.9\beta = 0.9, le nouveau gradient compte pour un dixième ; celui d'il y a dix pas garde encore 0.910≈35%0.9^{10} \approx 35\% de son influence, et plus un gradient est ancien, plus il s'estompe. Inutile de stocker les gradients passés un par un ; il suffit de retenir un seul nombre.

Moyenner le zigzagGradients du zigzag à η = 0.9, séparés en deux directions, en travers et le long de la vallée. La ligne orange est la moyenne mobile avec β = 0.9.
en travers de la vallée : le signe change à chaque pas
0102030-1.701.7pas
le long de la vallée : petit, toujours du même signe
010203000.06pas
gradient à chaque pasmoyenne mobile

Nous décomposons les gradients de GD dans la vallée en deux composantes, l'une en travers de la vallée, l'autre le long. La composante transversale vaut environ 1.7 au premier pas, puis change de signe à chaque pas, et l'EMA la ramène vite près de 0 ; la composante le long du fond ne vaut qu'environ 0.06, mais sa direction ne change jamais, et l'EMA la conserve sans faiblir.

Momentum

Utiliser cette moyenne pour mettre à jour les paramètres, c'est la méthode du momentum. SGD avec momentum est souvent abrégé en SGDM :

vt=β vt−1+gt,θt+1=θt−η vtv_t = \beta\, v_{t-1} + g_t, \qquad \theta_{t+1} = \theta_t - \eta\, v_t

Ce vv n'a pas le facteur (1−β)(1 - \beta) ; il vaut donc 11−β\frac{1}{1-\beta} fois l'EMA ci-dessus. Quand le gradient pointe toujours du même côté, vv s'accumule jusqu'à g1−β\frac{g}{1-\beta}, soit 10 fois le gradient pour β=0.9\beta = 0.9. Les petits gradients qui n'avançaient pas dans la direction plate se trouvent ainsi amplifiés.

L'image vient de la physique. vv est comme la vitesse d'une boule, le gradient est la poussée que lui donne la pente, et β\beta fixe la part de vitesse conservée à chaque pas.

Cette idée aussi est bien antérieure à l'apprentissage profond. En 1964, Polyak l'écrit

xn+1=xn−α∇f(xn)+β (xn−xn−1)x^{n+1} = x^n - \alpha \nabla f(x^n) + \beta\,(x^n - x^{n-1})

c'est-à-dire qu'au pas de gradient il ajoute « le déplacement précédent » multiplié par β\beta. En éliminant vv des deux équations ci-dessus, on obtient exactement la même formule, avec α\alpha égal à η\eta. Polyak l'appelle méthode de la boule pesante (heavy ball), y voit la version discrète du mouvement d'un corps dans un champ de potentiel, et recommande de prendre β\beta généralement entre 0.8 et 0.99.

Il calcule aussi l'ampleur de l'accélération. Sur une fonction quadratique de conditionnement κ\kappa, le nombre de pas de GD est à peu près proportionnel à κ\kappa, celui de la boule pesante seulement à κ\sqrt{\kappa}. Pour notre vallée, κ≈46\kappa \approx 46 et κ≈6.8\sqrt{\kappa} \approx 6.8. Ce résultat ne vaut toutefois que pour les fonctions quadratiques, ou près d'un minimum où la fonction leur ressemble assez ; en 2016, Lessard et al. construisent une fonction à une dimension de conditionnement 25 sur laquelle la boule pesante, réglée avec les paramètres optimaux du cas quadratique, tombe dans une oscillation qui ne s'amortit jamais.

Même η, avec momentumLa flèche en tête de l'essai orange est son prochain déplacement, −ηv.
012-1012w (par kg)b (frais de base)
descente de gradient (η = 0.9) : À moins de 0.03 du minimum au pas 93momentum (η = 0.9, β = 0.7) : À moins de 0.03 du minimum au pas 19

Avec le même η=0.9\eta = 0.9, GD n'arrive qu'au pas 93 ; avec un momentum β=0.7\beta = 0.7, il arrive dès le pas 19.

Regardez bien la trajectoire avec momentum. Au début, elle n'est pas plus sage ; elle traverse même largement la vallée plusieurs fois. Le momentum annule les rebonds qui changent de signe à chaque pas ; la vitesse déjà accumulée par la boule met encore plusieurs pas à retomber.

Et si β\beta est trop grand ?

Combien de passé retenirMomentum avec η = 0.1 et trois valeurs de β. À gradient constant, le pas finit par atteindre η/(1 − β).
β = 0.5 · η/(1 − β) = 0.2
β = 0.9 · η/(1 − β) = 1.0
β = 0.99 · η/(1 − β) = 10.0
β = 0.5 : Encore à plus de 0.03 du minimum après 200 pasβ = 0.9 : À moins de 0.03 du minimum au pas 51β = 0.99 : Encore à plus de 0.03 du minimum après 200 pas

Les trois figures utilisent η=0.1\eta = 0.1. Avec β=0.5\beta = 0.5, la mémoire est trop courte, l'aide limitée, et le point n'arrive pas en 200 pas ; avec β=0.9\beta = 0.9, il arrive au pas 51 ; avec β=0.99\beta = 0.99, il n'y a presque plus de frottement, la boule tourne en rond autour du fond et ne s'arrête pas non plus en 200 pas.

NAG : un coup d'œil avant de freiner

Le momentum réagit lentement. Près du fond, la boule, emportée par la vitesse accumulée, dépasse la cible ; il faut que le gradient la repousse en sens inverse pendant plusieurs pas pour qu'elle fasse demi-tour.

Le momentum de Nesterov (Nesterov Accelerated Gradient, NAG) ne change qu'une chose. Puisque ce pas va de toute façon avancer selon la vitesse, autant aller d'abord jusque-là, regarder la pente à cet endroit, puis décider de la correction :

vt=β vt−1+∇L(θt−ηβ vt−1)θt+1=θt−η vt\begin{aligned} v_t &= \beta\, v_{t-1} + \nabla L(\theta_t - \eta\beta\, v_{t-1}) \\ \theta_{t+1} &= \theta_t - \eta\, v_t \end{aligned}

La seule différence est l'endroit où l'on calcule le gradient. Le momentum le calcule à la position actuelle ; NAG au point d'anticipation, « après un pas à la vitesse actuelle ». Si le terrain commence déjà à remonter devant, NAG le sent dès ce pas et freine un peu à l'avance.

Regarder devant avant de lire la penteLe bleu lit le gradient là où il se trouve ; l'orange se déplace d'abord de −ηβv jusqu'au point d'anticipation creux et le lit là. Les flèches n'indiquent que la direction.
012-1012w (par kg)b (frais de base)
momentum : À moins de 0.03 du minimum au pas 37Nesterov : À moins de 0.03 du minimum au pas 22η = 0.5, β = 0.8

Le cercle creux est le point d'anticipation de NAG. Avec les mêmes η=0.5\eta = 0.5 et β=0.8\beta = 0.8, le momentum arrive au pas 37, NAG au pas 22.

Pourquoi est-ce si efficace dans une vallée ? En 2013, Sutskever et al. montrent que sur une fonction quadratique, NAG revient à utiliser, dans chaque direction propre, un momentum différent β(1−ηλ)\beta(1 - \eta\lambda), où λ\lambda est la courbure de cette direction. Plus la courbure est forte, plus le momentum est faible. Avec les réglages de cette figure, la direction qui traverse la vallée a λ=2.05\lambda = 2.05, et son momentum effectif tombe à 0.8×(1−0.5×2.05)≈−0.020.8 \times (1 - 0.5 \times 2.05) \approx -0.02, presque aucun élan ; la direction du fond, avec λ=0.045\lambda = 0.045, garde 0.78. Les directions sujettes aux rebonds sont tenues en bride, et celles qui ont besoin d'accélérer accélèrent toujours.

La méthode vient d'un article de Nesterov de 1983 ; c'était à l'origine un résultat théorique d'optimisation convexe, qui garantit une erreur décroissant en 1/k21/k^2. La formulation « gradient au point d'anticipation » est une réécriture de Sutskever, Martens, Dahl et Hinton dans « On the importance of initialization and momentum in deep learning ». Ils font monter progressivement le momentum jusqu'à 0.99, voire 0.999, et, avec une initialisation soigneusement conçue, SGD avec momentum égale sur des autoencodeurs profonds les méthodes du second ordre, plus complexes, qui faisaient alors référence.

AdaGrad : à chaque paramètre son pas

Jusqu'ici, tous les paramètres partagent le même η\eta.

Pour beaucoup de problèmes, ce n'est pas raisonnable. Duchi, Hazan et Singer, les auteurs d'AdaGrad, prennent l'exemple de données textuelles. Les mots courants apparaissent dans chaque exemple, et les paramètres correspondants sont mis à jour sans arrêt ; les mots rares n'apparaissent qu'occasionnellement, mais quand ils apparaissent, ils sont souvent très prédictifs. Un même taux d'apprentissage risque d'être trop grand pour les premiers et trop petit pour les seconds.

AdaGrad fait retenir à chaque paramètre la somme des carrés de tous ses gradients passés, et divise par sa racine carrée :

Gt=Gt−1+gt2θt+1=θt−ηGt+ϵ gt\begin{aligned} G_t &= G_{t-1} + g_t^2 \\ \theta_{t+1} &= \theta_t - \frac{\eta}{\sqrt{G_t} + \epsilon}\, g_t \end{aligned}

Ici, le carré, la racine et la division se font paramètre par paramètre. ϵ\epsilon est un très petit nombre qui évite la division par zéro.

Pour un paramètre aux gradients toujours grands, GG croît vite et le pas rétrécit ; un paramètre rarement mis à jour garde un petit GG et peut faire un grand pas dès qu'un gradient arrive. Le premier pas est encore plus intéressant. Comme G1=g12G_1 = g_1^2, le premier pas de chaque paramètre vaut ±η\pm\eta, quelle que soit la taille du gradient.

AdaGrad : un taux d'apprentissage par coordonnéeη = 0.5. G additionne tous les carrés de gradient jusqu'ici, donc η/√G ne peut que diminuer. Au premier pas, w et b avancent chacun d'exactement η.
012-1012w (par kg)b (frais de base)
taux effectif
00.250.5η/√Gη = 0.5w : 0.392b : 0.445
G = (1.624, 1.261)η/√G = (0.392, 0.445)97 % de G vient des 5 premiers pas

Avec η=0.5\eta = 0.5, le premier pas déplace ww et bb d'exactement 0.5 chacun. Ensuite, les taux effectifs des deux paramètres se figent presque à 0.39 et 0.45, et ne bougent plus. 97 % de GG vient des cinq premiers pas. Au début, loin du minimum, les gradients sont grands, et chaque carré ajouté pèse lourd ; ensuite les gradients deviennent de plus en plus petits, et les ajouter ne change plus grand-chose. Dans cette figure, AdaGrad n'entre à moins de 0.03 du minimum qu'au pas 203, plus tard encore que BGD et ses 168 pas.

GG ne fait que grandir, et le taux effectif η/Gt\eta/\sqrt{G_t} de chaque paramètre ne fait que diminuer, déterminé surtout par les tout premiers pas. Sur un problème convexe, c'est justement ce mécanisme qui assure la convergence ; mais entraîner un réseau profond demande des centaines de milliers de pas sur un paysage qui change sans cesse, et le taux devient souvent trop petit pour avancer avant même d'avoir atteint une bonne région.

RMSProp et AdaDelta : apprendre à oublier

Puisque le problème vient de ce qu'on additionne tous les gradients passés, ne retenons que les plus récents.

Remplacer la somme cumulée d'AdaGrad par une moyenne mobile exponentielle donne RMSProp :

vt=ρ vt−1+(1−ρ) gt2θt+1=θt−ηvt+ϵ gt\begin{aligned} v_t &= \rho\, v_{t-1} + (1 - \rho)\, g_t^2 \\ \theta_{t+1} &= \theta_t - \frac{\eta}{\sqrt{v_t} + \epsilon}\, g_t \end{aligned}

ρ\rho vaut généralement 0.9. Ici, vv est la moyenne des carrés du gradient ; ce n'est pas la vitesse vv de la section sur le momentum. Les grands gradients d'il y a longtemps s'oublient peu à peu ; le taux effectif peut diminuer, mais aussi remonter.

RMSProp a une origine peu commune, puisqu'il n'a pas d'article. Il vient des diapositives du cours « Neural Networks for Machine Learning » donné par Hinton sur Coursera en 2012, cinquième partie du sixième cours (Lecture 6e). On y lit 0.9 MeanSquare+0.1 g20.9\,\mathit{MeanSquare} + 0.1\,g^2, dont la racine carrée sert ensuite à diviser le gradient, avec la mention qu'il s'agit d'un travail non publié de Tijmen Tieleman. Les articles qui le citent par la suite ne peuvent donc citer que ces notes de cours.

Après la pente raide, une longue pente doucePente 1 pour u < 0, puis 0.1 seulement ; le fond est en u ≈ 10. AdaGrad η = 0.5 ; RMSProp η = 0.1, ρ = 0.9. Les deux partent de u = −3.
où en est chacun
-20246810uLAdaGradRMSProp
taille du pas |Δu| (échelle log)
060120180240pas|Δu|0.0010.010.11AdaGradRMSProp
AdaGrad u = 3.45RMSProp u = 10.10

Le paysage de cette figure commence par une forte descente de pente 1, puis une longue descente douce de pente 0.1 seulement ; le fond est en u≈10u \approx 10. Les deux méthodes partent de u=−3u = -3 ; AdaGrad utilise η=0.5\eta = 0.5, RMSProp η=0.1\eta = 0.1 et ρ=0.9\rho = 0.9.

Sur la partie raide, les grands gradients gonflent le dénominateur des deux méthodes. Une fois sur la pente douce, le GG d'AdaGrad se souvient encore de chaque pas de la partie raide, et le pas tombe à environ 0.01 ; RMSProp oublie vite, son dénominateur suit la baisse du gradient, et le pas revient à environ 0.1. Au pas 100, AdaGrad n'a atteint que u≈1.7u \approx 1.7, alors que RMSProp est déjà à 5.1 ; RMSProp atteint le fond vers le pas 150, tandis qu'AdaGrad, au pas 240, n'en est qu'à 3.45. Celui qui a reçu le plus grand taux d'apprentissage est celui qui avance le plus lentement.

La même année, AdaDelta, proposé par Zeiler, utilise la même moyenne mobile et va un peu plus loin. Zeiler remarque que les mises à jour de SGD et d'AdaGrad n'ont pas les bonnes unités. Le gradient a pour unité « perte ÷ paramètre » ; s'en servir pour mettre à jour un paramètre donne une unité fausse. Il faudrait encore diviser par la dérivée seconde (nous la retrouverons avec la méthode de Newton) pour revenir à l'unité « paramètre ». AdaDelta ne calcule pas vraiment de dérivée seconde ; il remplace le η\eta du numérateur par la moyenne quadratique (RMS) des « mises à jour passées » :

Δθt=−RMS[Δθ]t−1RMS[g]t gt\Delta\theta_t = -\frac{\mathrm{RMS}[\Delta\theta]_{t-1}}{\mathrm{RMS}[g]_t}\, g_t

Les unités du numérateur et du dénominateur se simplifient, la mise à jour a la même unité que le paramètre, et il n'y a même plus de taux d'apprentissage à régler.

Adam : réunir les deux

Nous avons maintenant deux outils en main. Le momentum utilise une moyenne mobile du gradient pour traiter les changements incessants de direction ; RMSProp utilise une moyenne mobile du carré du gradient pour ajuster le pas de chaque paramètre.

Adam, proposé par Kingma et Ba en 2014, réunit les deux :

mt=β1 mt−1+(1−β1) gtvt=β2 vt−1+(1−β2) gt2m^t=mt1−β1t,v^t=vt1−β2tθt=θt−1−α m^tv^t+ϵ\begin{aligned} m_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t \\ v_t &= \beta_2\, v_{t-1} + (1 - \beta_2)\, g_t^2 \\ \hat m_t &= \frac{m_t}{1 - \beta_1^t}, \qquad \hat v_t = \frac{v_t}{1 - \beta_2^t} \\ \theta_t &= \theta_{t-1} - \alpha\, \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon} \end{aligned}

mm est l'estimation du moment d'ordre un du gradient, c'est-à-dire sa moyenne ; vv est l'estimation du moment d'ordre deux, la moyenne de son carré. Dans l'article d'Adam, le taux d'apprentissage est noté α\alpha ; il joue le même rôle que η\eta jusqu'ici. Les valeurs par défaut de l'article sont α=0.001\alpha = 0.001, β1=0.9\beta_1 = 0.9, β2=0.999\beta_2 = 0.999, ϵ=10−8\epsilon = 10^{-8}, et ce sont encore aujourd'hui celles de PyTorch.

Nous connaissons déjà les deux premières lignes ; la troisième est nouvelle.

Correction du biais

mm et vv partent tous deux de 0. Au premier pas, m1=0.1 g1m_1 = 0.1\, g_1, soit un dixième seulement du vrai gradient ; v1=0.001 g12v_1 = 0.001\, g_1^2, un millième seulement. Les deux estimations sont tirées vers le bas par le 0 de départ.

En développant mtm_t et en supposant que l'espérance du gradient reste E[g]\mathbb{E}[g], on obtient E[mt]=(1−β1t) E[g]\mathbb{E}[m_t] = (1 - \beta_1^t)\,\mathbb{E}[g]. Diviser par 1−β1t1 - \beta_1^t corrige donc le biais ; même chose pour vv.

Pourquoi cette correction est-elle indispensable ? Les deux estimations ne sont pas biaisées au même degré. Avec β2=0.999\beta_2 = 0.999, vv est tiré vers le bas bien plus fortement que mm ; sans correction, le dénominateur est trop petit, et le pas trop grand.

Les moyennes mobiles d'Adam partent de zéroGradient constant g = 1, β₁ = 0.9, β₂ = 0.999. Pointillés : m et v tels que stockés ; traits pleins : après division par 1 − βᵗ. L'axe du temps est logarithmique.
m et v
110100100000.51tmvm̂ = v̂
facteur de pas
110100100001357tm/√v non corrigémaximum : 6.6× à t = 12m̂/√v̂ corrigé
mt = 1.000vt = 0.6323m/√v non corrigé = 1.26m̂/√v̂ corrigé = 1.00

Supposons un gradient constant égal à 1. Corrigé, m^t/v^t\hat m_t / \sqrt{\hat v_t} vaut 1 dès le premier pas, et le pas vaut exactement α\alpha. Sans correction, le premier pas est 0.1/0.001≈3.160.1/\sqrt{0.001} \approx 3.16 fois plus grand ; le facteur grimpe à 6.6 vers le pas 12, et vaut encore 1.26 au pas 1 000. Dans leurs expériences sur un autoencodeur variationnel, Kingma et Ba constatent d'ailleurs que plus β2\beta_2 est proche de 1, plus l'entraînement sans correction du biais est instable au début.

Un pas d'environ α\alpha

Après correction, m^t/v^t\hat m_t / \sqrt{\hat v_t} reste à peu près autour de ±1\pm 1. Multipliez toute la perte par 100 ; le gradient est multiplié par 100, m^\hat m et v^\sqrt{\hat v} grandissent ensemble, et, au minuscule ϵ\epsilon près, la mise à jour ne change presque pas. Chaque paramètre avance d'environ α\alpha par pas, quelle que soit la taille du gradient.

C'est la principale raison pour laquelle Adam est si commode. Le taux de SGD doit être réglé selon l'échelle du gradient ; l'α\alpha d'Adam correspond plutôt à « de combien on veut déplacer les paramètres à chaque pas », et la valeur par défaut fonctionne souvent encore quand on change de modèle.

Quatre règles, une seule valléeLes quatre utilisent le gradient complet des 12 colis ; seule la règle de mise à jour change. Chaque taux a été choisi pour bien marcher ici, et Adam garde β₁ = 0.9, β₂ = 0.999. Le nombre indique le premier pas à moins de 0.03 du minimum.
GD · η = 0.9
Momentum · η = 0.3, β = 0.9
RMSProp · η = 0.02, ρ = 0.9
Adam · η = 0.2
GD : arrivée au pas 93Momentum : arrivée au pas 47RMSProp : arrivée au pas 130Adam : arrivée au pas 87

Quatre méthodes dans la même vallée, chacune avec un taux d'apprentissage réglé pour bien fonctionner ici ; les nombres indiquent le pas où chacune entre pour la première fois à moins de 0.03 du minimum. Les quatre calculent le gradient sur l'ensemble des 12 colis ; les deux premières sont donc GD sans échantillonnage et GD avec momentum. GD (η=0.9\eta = 0.9) arrive au pas 93 ; le momentum (η=0.3\eta = 0.3, β=0.9\beta = 0.9) au pas 47 ; RMSProp (η=0.02\eta = 0.02) au pas 130 ; Adam (α=0.2\alpha = 0.2) au pas 87.

Adam n'est pas beaucoup plus rapide. Nous verrons pourquoi dans la section « Arrondir la vallée » ; cela tient au fait que la vallée est oblique.

Adam peut aussi passer au momentum de Nesterov. En 2016, Dozat intègre le « coup d'œil en avant » de NAG dans Adam, sous le nom de Nadam. NAG avance d'abord selon le momentum avant de mesurer le gradient ; Nadam ne calcule pas de gradient supplémentaire, mais utilise directement dans la mise à jour « le momentum du pas suivant » β1m^t\beta_1 \hat m_t, auquel s'ajoute le gradient de ce pas. La méthode de référence NAdamW, utilisée plus tard par AlgoPerf (un banc d'essai public qui compare la vitesse des algorithmes d'entraînement, présenté plus loin dans la section « Lequel est le plus rapide ? »), n'est autre que Nadam plus la décroissance des poids d'AdamW, que nous verrons dans la section suivante.

Adam se trompe aussi

Adam est vite devenu le choix par défaut. Mais dans les années qui suivent, plusieurs travaux pointent ses problèmes.

Oublier les grands gradients qui comptent

Reddi, Kale et Kumar construisent un tout petit exemple. Le paramètre xx est contraint à [−1,1][-1, 1], avec un cycle de trois pas ; la perte vaut CxCx au premier pas, puis −x-x aux deux suivants. Avec C=3C = 3, le gradient total d'un cycle vaut 3−1−1=1>03 - 1 - 1 = 1 > 0 ; il faudrait donc pousser xx vers −1-1.

C'est là que le dénominateur d'Adam se trompe. Dès que le grand gradient rare de 3 apparaît, vv grossit aussitôt, et le g/vg/\sqrt{v} de ce pas est écrasé à environ 1.05 ; aux deux pas suivants, le gradient n'est que de −1-1, vv redescend vite, et ces deux pas sont amplifiés à −0.76-0.76 et −0.97-0.97. Sur un cycle, en unités de αt\alpha_t, Adam fait 0.68 de trop dans la mauvaise direction.

Adam part dans le mauvais sensL'exemple de Reddi et al. Sur x ∈ [−1, 1], le gradient vaut +3 un pas sur trois et −1 sinon ; le minimum est donc en x = −1. β₁ = 0, β₂ = 0.1, α_t = 0.5/√t ; les deux partent de x = 1.
0100200300-101txminimum x = −1AdamAMSGrad
gradient : +3 un pas sur 3, −1 sinon
t = 300, gt = -1Adam : x = 1.00, g/√v = -0.97AMSGrad : x = -0.98, g/√v = -0.35

Les deux partent de x=1x = 1, avec un taux 0.5/t0.5/\sqrt{t}. Adam est repoussé à +1+1 tous les trois pas et reste bloqué à la mauvaise extrémité ; AMSGrad atteint environ −0.40-0.40 au pas 100, et −0.98-0.98 au pas 300.

Les valeurs β1=0\beta_1 = 0 et β2=1/(1+C2)=0.1\beta_2 = 1/(1 + C^2) = 0.1 sont celles que l'article choisit pour sa démonstration. La racine du problème est que le taux effectif d'Adam, α/vt\alpha/\sqrt{v_t}, peut augmenter. Dès que les gradients récents sont petits, les grands gradients passés sont oubliés.

Leur correctif, AMSGrad, ne change qu'une chose ; le dénominateur utilise le maximum historique de vv :

v^t=max⁡(v^t−1, vt)\hat v_t = \max(\hat v_{t-1},\ v_t)

Le taux effectif ne peut alors plus que diminuer, jamais augmenter. Dans l'exemple ci-dessus, les trois pas utilisent le même v^\hat v, et l'effet net d'un cycle devient un déplacement de 0.35 dans la bonne direction.

Une moins bonne généralisation ?

Une autre critique vient de « The Marginal Value of Adaptive Gradient Methods in Machine Learning », de Wilson et al. (2017). Ils construisent un problème de classification linéaire où la solution trouvée par SGD a une erreur de test nulle, tandis que celles d'AdaGrad, RMSProp et Adam classent chaque nouvel exemple dans la même classe.

Sur CIFAR-10, en ne réglant que le taux d'apprentissage et son mode de décroissance, ils obtiennent une erreur de test de 7.65 % pour SGD, 9.60 % pour RMSProp et 9.78 % pour Adam. La perte d'entraînement baisse plus vite, mais les résultats de test sont moins bons. Cet article a poussé bon nombre de travaux en vision par ordinateur à rester sur SGD avec momentum.

Deux ans plus tard, Choi et al. relancent les expériences avec le code publié par Wilson et al., en réglant aussi le momentum et ϵ\epsilon ; les quatre méthodes obtiennent alors des erreurs de test presque identiques. L'ampleur de l'écart dépend dans une large mesure des hyperparamètres que l'on règle.

Une décroissance des poids réduite

Le troisième problème est le plus insidieux, et celui qui a eu le plus de conséquences.

La décroissance des poids (weight decay) tire à chaque pas les paramètres un peu vers 0, pour les empêcher de devenir trop grands. Avec SGD, elle équivaut à la régularisation L2. Ajouter λ2∥θ∥2\frac{\lambda}{2}\lVert\theta\rVert^2 à la perte ajoute un terme λθ\lambda\theta au gradient, ce qui réduit un peu les paramètres à chaque pas.

Les premières implémentations d'Adam ajoutaient donc λθ\lambda\theta au gradient. Mais dans Adam, ce terme est lui aussi divisé par v^\sqrt{\hat v}. Pour un paramètre aux gradients toujours grands, v^\sqrt{\hat v} est grand, et la décroissance devient minuscule ; selon les mots de Loshchilov et Hutter, plus les gradients passés d'un poids sont grands, moins il est régularisé.

Leur solution consiste à sortir la décroissance, pour qu'elle ne passe plus par le dénominateur d'Adam :

θt=θt−1−ηt(α m^tv^t+ϵ+λ θt−1)\theta_t = \theta_{t-1} - \eta_t \left( \alpha\, \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon} + \lambda\, \theta_{t-1} \right)

C'est AdamW. Dans cette formule, α\alpha est le taux d'apprentissage, et ηt\eta_t le multiplicateur de la planification du taux d'apprentissage au pas tt, égal à 1 si le taux est fixe.

La décroissance des poids, dans Adam ou en dehorsDeux poids partent de 1 avec des gradients bruités de moyenne nulle ; le bruit de w₁ a une amplitude de 1, celui de w₂ de 0.001. α = 0.002, λ = 0.004. Seule la régularisation les tire vers 0.
L2 dans Adam
025050000.51pasww₁ (grands gradients)w₂ (petits gradients)
AdamW (découplé)
025050000.51pasww₁ (grands gradients)w₂ (petits gradients)
L2 dans Adam : w₁ = 0.96, w₂ = 0.28AdamW (découplé) : w₁ = 0.13, w₂ = 0.14

Les deux poids partent de 1 ; leurs gradients ne sont que du bruit, d'amplitudes différant d'un facteur mille. α=0.002\alpha = 0.002, λ=0.004\lambda = 0.004. Dans la version où L2 est ajouté au gradient, w1w_1, aux grands gradients, ne décroît presque pas et vaut encore 0.96 après 500 pas ; w2w_2, aux petits gradients, est au contraire tiré vers le bas d'environ 0.002 à chaque pas et tombe à 0.28 au pas 500. AdamW traite les deux poids de la même façon et les multiplie par 0.996 à chaque pas ; au pas 500, il ne reste qu'environ 0.13 de chacun.

Dans les expériences sur CIFAR-10, les bons résultats d'Adam avec L2 s'alignent sur une diagonale dans le plan taux d'apprentissage–λ\lambda ; modifier l'un oblige à retoucher l'autre. Chez AdamW, la bonne région est à peu près parallèle aux deux axes, les deux hyperparamètres se règlent séparément, et le meilleur score rattrape celui de SGD. Aujourd'hui, AdamW est presque le choix par défaut pour entraîner les Transformers et les grands modèles de langage.

Planification du taux d'apprentissage

Nous l'avons vu, le taux d'apprentissage de SGD doit diminuer peu à peu. Mais de quelle façon ?

De l'escalier au cosinus

La forme la plus ancienne et la plus courante est l'escalier ; on divise par 10 à intervalles réguliers. La recette classique pour entraîner ResNet-50 compte 90 époques (une époque est un passage complet sur l'ensemble d'entraînement), avec une division par 10 aux époques 30, 60 et 80. Son défaut est qu'il faut attendre la dernière division pour obtenir un bon modèle, et que c'est à vous de décider quand diviser.

En 2016, SGDR adopte plutôt une courbe en cosinus, qui descend en douceur du maximum au minimum :

ηt=ηmin⁡+12(ηmax⁡−ηmin⁡)(1+cos⁡TcurTiπ)\eta_t = \eta_{\min} + \frac{1}{2}\left(\eta_{\max} - \eta_{\min}\right)\left(1 + \cos\frac{T_{\text{cur}}}{T_i}\pi\right)

TcurT_{\text{cur}} est le temps déjà écoulé dans le cycle en cours, TiT_i la longueur de ce cycle. À la fin d'un cycle, le taux remonte d'un coup au maximum et un nouveau cycle commence ; c'est le redémarrage à chaud (warm restart). La longueur du cycle suivant peut être multipliée par TmultT_{\text{mult}}, pour des cycles de plus en plus longs. Ses auteurs ne sont autres que Loshchilov et Hutter, qui signeront plus tard AdamW.

Cinq planifications du tauxLa hauteur est η divisé par son maximum. Escalier : la recette de Goyal et al. sur 90 époques. SGDR : T₀ = 10, T_mult = 2 sur 150 époques. Les échauffements (avec cosinus et dans WSD) occupent les premiers 5 % ; WSD décroît sur les derniers 10 %.
Escalier
100%100%
Cosinus
100%100%
SGDR
100%100%
Échauffement + cosinus
100%100%
WSD
100%100%
Escalier 0Cosinus 0SGDR 0Échauffement + cosinus 0WSD 0

Les cinq planifications de la figure partagent un même curseur. Celle de SGDR utilise T0=10T_0 = 10 et Tmult=2T_{\text{mult}} = 2, avec des redémarrages aux époques 10, 30 et 70.

Les redémarrages ne se sont finalement pas imposés. Dans les expériences de SGDR lui-même, le meilleur modèle unique WRN-28-10 sur CIFAR-10, à 3.86 %, provient d'un cosinus sans aucun redémarrage, en un seul cycle. Les configurations d'entraînement de GPT-3 et de LLaMA utilisent elles aussi un cosinus à cycle unique. Ce qui est resté, c'est la courbe douce, au prix d'avoir de nouveau à connaître à l'avance le nombre total de pas ; les expériences de Chinchilla (l'article de DeepMind sur la façon d'accorder taille du modèle et quantité de données d'entraînement) montrent que si le cycle du cosinus dépasse de plus de 25 % le nombre réel de pas d'entraînement, les résultats se dégradent nettement.

Ne pas fixer l'arrivée à l'avance

La planification en cosinus exige de connaître d'avance la durée totale de l'entraînement. Or pour un grand modèle de langage, on décide souvent en cours de route s'il faut entraîner un peu plus longtemps.

En 2024, MiniCPM utilise une planification en trois phases appelée WSD (Warmup-Stable-Decay). Elle commence par un échauffement (présenté dans la section suivante), garde ensuite le taux constant pendant longtemps, et ne le fait baisser que sur environ le dernier dixième de l'entraînement. Les checkpoints (modèles sauvegardés en cours d'entraînement) enregistrés avant la baisse peuvent servir à tout moment à poursuivre l'entraînement.

En 2024, Defazio et al. vont plus loin et suppriment carrément la planification. Schedule-Free maintient simultanément trois jeux de paramètres :

yt=(1−β) zt+β xtzt+1=zt−γ ∇f(yt)xt+1=(1−1t+1)xt+1t+1 zt+1\begin{aligned} y_t &= (1-\beta)\, z_t + \beta\, x_t \\ z_{t+1} &= z_t - \gamma\, \nabla f(y_t) \\ x_{t+1} &= \left(1 - \tfrac{1}{t+1}\right) x_t + \tfrac{1}{t+1}\, z_{t+1} \end{aligned}

Ici, xx, yy et zz sont trois jeux de paramètres, sans rapport avec le poids xx des colis. zz suit un SGD ordinaire avec un pas γ\gamma fixe ; xx est la moyenne de tous les zz, et c'est le modèle que l'on utilise au final ; le gradient est calculé en yy, entre les deux. Moyenner les zz passés équivaut à une décroissance linéaire dont le point d'arrivée suit à tout moment le pas courant.

Schedule-Free : trois points, une moyenneMini-lots de 4, γ = 0.3, β = 0.9. z fait les pas de SGD, x est la moyenne de tous les z jusqu'ici, et le gradient est pris en y = 0.1·z + 0.9·x. Au début, x est à la traîne, car sa moyenne inclut encore les premiers z, très éloignés.
012-1012w (par kg)b (frais de base)zxy
x (moyenne) : à 0.007 du minimumz (pas de SGD) : à 0.461 du minimumy (où le gradient est pris)

Chaque pas tire 4 colis, avec γ=0.3\gamma = 0.3 et β=0.9\beta = 0.9. Pendant les cent et quelques premiers pas, xx est nettement à la traîne de zz, car il traite tous les zz à égalité, y compris les tout premiers zz, très loin du minimum ; plus on avance, plus xx est stable.

Lors du concours d'algorithmes d'entraînement AlgoPerf 2024, Schedule-Free AdamW remporte la catégorie qui interdit le réglage externe des hyperparamètres, en moyenne environ 8 % plus rapide que la référence ; c'est aussi la seule soumission de cette catégorie à battre la référence. Il lui faut toutefois encore un échauffement ; la plupart des expériences de l'article le fixent à 5 % de l'entraînement total, si bien que la durée totale entre encore en jeu, par le biais de l'échauffement.

L'échauffement

Aujourd'hui, presque toutes les configurations d'entraînement précisent que, pendant les quelques milliers de premiers pas, le taux d'apprentissage doit monter progressivement depuis une très petite valeur. C'est l'échauffement (warmup). Pourquoi ne pas utiliser un grand taux dès le départ ?

Mise à l'échelle linéaire et échauffement

L'échauffement est d'abord formalisé en recette en 2017 par Goyal et al., dans « Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour ». Ils veulent porter le lot de 256 à 8 192 exemples, pour entraîner ResNet-50 en une heure sur 256 GPU.

La première règle est la mise à l'échelle linéaire ; quand le lot est multiplié par kk, le taux d'apprentissage l'est aussi. Pour un lot de 8 192, le taux vaut donc 3.2. Mais au début de l'entraînement, le réseau change très vite, et un taux aussi grand appliqué d'emblée abîme le modèle. Pendant les 5 premières époques, le taux monte donc linéairement de 0.1, la valeur d'origine, à 3.2.

Sans échauffement, l'erreur top-1 (la proportion d'images dont la première proposition est fausse) est de 24.84 % ; un échauffement à petit taux constant fait pire, 25.88 % ; un échauffement progressif donne 23.74 %, rejoignant les 23.60 % du lot de 256. Jusqu'à un lot de 8 192, l'erreur ne bouge presque pas ; elle se dégrade à partir de 16k, avec 27.55 % à 32k et 33.96 % à 64k.

Pourquoi Adam a aussi besoin d'échauffement

Le pas d'Adam vaut environ α\alpha ; en principe, il ne craint pas les gradients trop grands. Pourquoi alors, pour entraîner un Transformer, Adam sans échauffement déraille-t-il si souvent dès le début ?

En 2019, Liu et al., les auteurs de RAdam, en proposent une explication. Au début de l'entraînement, vv n'a vu que quelques gradients, et l'estimation de « la taille du gradient » qu'il fournit est très imprécise. Le premier pas est le cas extrême. v^1=g12\hat v_1 = g_1^2, si bien que le taux adaptatif ψ=1/v^1=1/∣g1∣\psi = 1/\sqrt{\hat v_1} = 1/|g_1| repose sur un seul échantillon, et sa variance diverge même.

Les premiers taux adaptatifs sont erratiques2 000 simulations, gradients tirés de N(0, 1), β₂ = 0.999. Bandes : 50 % et 90 % centraux de ψ = 1/√v̂ à chaque pas ; ligne : médiane ; ▲ : au moins une simulation au-dessus de 100. Les deux axes sont logarithmiques.
12481632641282560.3110100tψ = 1/√v̂4 premiers pas : momentum seul1/σ = 1▲
90 % des simulations : de 0.93 à 1.1maximum : 1.2ρt = 245.1Rectification RAdam rₜ = 0.346

La figure montre 2 000 simulations, avec des gradients tirés d'une loi normale centrée réduite et β2=0.999\beta_2 = 0.999. Au pas 1, 90 % des valeurs simulées de 1/v^1/\sqrt{\hat v} tombent entre 0.50 et 14.4, un facteur de près de trente ; au pas 10, l'intervalle s'est déjà resserré entre 0.73 et 1.6.

RAdam estime l'ampleur de cette variance et multiplie par un coefficient de rectification rtr_t ; pendant les premiers pas, quand la variance est trop grande, il renonce carrément au taux adaptatif. Avec β2=0.999\beta_2 = 0.999, les 4 premiers pas n'utilisent que le momentum ; ensuite rtr_t monte lentement d'une très petite valeur jusqu'à 1, comme un échauffement intégré.

En octobre de la même année, Ma et Yarats font remarquer que rtr_t ne dépend que du numéro de pas tt et de β2\beta_2, et n'a aucun lien avec les données. RAdam équivaut donc à peu près à un échauffement de longueur fixe ; leur règle empirique est de 2/(1−β2)2/(1-\beta_2) pas, soit 2 000 pas pour β2=0.999\beta_2 = 0.999. Dans leur comparaison avec ResNet-50 sur ImageNet, un échauffement linéaire de cette longueur donne des résultats à moins d'un demi-point de pourcentage de ceux de RAdam.

Quand les lots grossissent : LARS et LAMB

La recette de Goyal et al. est très stable jusqu'à un lot de 8 192, mais elle ne tient plus au-delà. L'erreur est de 24.79 % à 16k, 27.55 % à 32k et 33.96 % à 64k. Quels problèmes surgissent quand le lot continue de grossir ?

Selon une première explication, les grands lots trouveraient des fonds de vallée plus aigus. En 2017, Keskar et al. observent que les modèles entraînés avec des lots de 10 % de l'ensemble d'entraînement ont des fonds plus aigus et une précision de test plus faible. Cette explication a ensuite été contestée. Dinh et al. démontrent que l'acuité d'un réseau ReLU peut être augmentée arbitrairement sans changer la fonction ; Hoffer et al. constatent que l'écart disparaît quand on augmente le taux d'apprentissage selon la racine carrée de la taille de lot et qu'on complète le nombre de pas d'entraînement.

Un autre problème est plus direct. You, Gitman et Ginsburg, les auteurs de LARS, mesurent la norme des poids et celle du gradient de chaque couche d'AlexNet-BN au premier pas. Le rapport ∥w∥/∥∇L∥\lVert w\rVert/\lVert\nabla L\rVert vaut 5.76 pour la première couche de convolution et 1 345 pour la première couche entièrement connectée, plus de deux cents fois plus.

Un seul taux, des couches qui bougent très différemmentLes barres montrent de combien un pas modifie chaque couche, ‖Δw‖/‖w‖, en échelle logarithmique. ‖w‖ et ‖∇L‖ viennent de la première itération d'AlexNet-BN (article LARS, Table 2). L'animation augmente le taux global γ ; LARS utilise le coefficient de confiance η = 0.001.
Un taux global (SGD)
10⁻⁵10⁻⁴10⁻³10⁻²10⁻¹110¹mise à jour = poidsconv1.w174%fc6.w0.74%
Rapport de confiance par couche (LARS)
10⁻⁵10⁻⁴10⁻³10⁻²10⁻¹110¹mise à jour = poidsconv1.w1.00%fc6.w1.00%
‖w‖/‖∇L‖ : conv1.w 5.76, fc6.w 1345Avec un taux global, conv1.w bouge 234× plus que fc6.w

Avec un même taux global, la variation relative de la première couche de convolution à chaque pas est 234 fois celle de la couche entièrement connectée. Au-delà d'un certain taux, la mise à jour de la première couche dépasse les poids eux-mêmes, et l'entraînement diverge ; pour la couche entièrement connectée, ce taux reste pourtant minuscule.

LARS calcule pour chaque couche son propre taux λl\lambda^{l}, de sorte que la mise à jour soit proportionnelle à la taille des poids de cette couche :

λl=τ ∥wl∥∥∇L(wl)∥\lambda^{l} = \tau\, \frac{\lVert w^{l}\rVert}{\lVert\nabla L(w^{l})\rVert}

τ\tau est un petit coefficient de confiance, noté η\eta dans l'article et fixé à 0.001 ; nous changeons de lettre pour éviter la confusion avec le taux d'apprentissage. Chaque couche subit alors la même variation relative, et l'entraînement n'est plus bridé par la couche la plus sensible. Avec un lot de 8k, sans LARS et avec le seul échauffement, AlexNet ne parvient pas à augmenter le taux d'apprentissage, quel que soit le réglage, et sa précision top-1 plafonne à 44.8 % ; avec LARS, il remonte à 58.2 %, proche des 58.7 % obtenus avec un lot de 512.

LAMB applique la même mise à l'échelle couche par couche à Adam. On calcule d'abord la mise à jour rr de la couche selon Adam, on ajoute la décroissance des poids λx\lambda x, puis on donne à la mise à jour totale une longueur proportionnelle à celle des poids de la couche :

x(l)←x(l)−η ϕ(∥x(l)∥)∥r(l)+λx(l)∥ (r(l)+λx(l))x^{(l)} \leftarrow x^{(l)} - \eta\, \frac{\phi\big(\lVert x^{(l)}\rVert\big)}{\lVert r^{(l)} + \lambda x^{(l)}\rVert}\,\big(r^{(l)} + \lambda x^{(l)}\big)

x(l)x^{(l)} désigne les poids de la couche ll, et ϕ\phi une fonction qui maintient la norme des poids entre une borne inférieure et une borne supérieure. En 2019, You et al. s'en servent pour ramener le préentraînement de BERT-Large de 81.4 heures sur 16 TPUv3 à 76 minutes sur 1 024 TPUv3 ; le lot est de 64k dans la première phase et de 32k dans la seconde.

L'histoire a une suite. En 2021, Nado et al. règlent à nouveau Adam et corrigent deux problèmes du code open source de BERT, l'absence de correction du biais et une falaise dans la planification du taux ; avec les mêmes lots et le même nombre de pas, Adam rattrape LAMB, et le dépasse même légèrement. Un momentum de Nesterov bien réglé égale aussi LARS dans la configuration ResNet-50 de MLPerf (le banc d'essai de l'industrie pour la vitesse d'entraînement).

Chercher un fond de vallée plat : SAM

Revenons à l'observation de Keskar et al. Un fond de vallée aigu est-il vraiment moins bon ?

Toutes les méthodes précédentes répondent à la question « comment atteindre le fond plus vite ». En 2020, Foret et al. changent de question. Quel fond de vallée est le meilleur ?

Prenons deux fonds de vallée, l'un profond et étroit, l'autre peu profond et large. En perte d'entraînement, l'étroit est plus bas ; mais les données de test diffèrent toujours un peu des données d'entraînement, et dès que les paramètres s'écartent légèrement, la perte de la vallée étroite monte en flèche, alors que celle de la vallée large ne bouge presque pas.

SAM (Sharpness-Aware Minimization) remplace l'objectif par « le pire cas aux alentours » :

min⁡w max⁡∥ϵ∥≤ρ L(w+ϵ)\min_{w}\ \max_{\lVert\epsilon\rVert \le \rho}\ L(w + \epsilon)

Ici, ww représente l'ensemble des paramètres du modèle ; ϵ\epsilon est une perturbation des paramètres, distincte du ϵ\epsilon qui évitait la division par zéro ; ρ\rho est le rayon de la perturbation, sans rapport non plus avec le ρ\rho de RMSProp. Dans un rayon ρ\rho, on cherche le point où la perte est la plus haute, puis on fait baisser la perte en ce point. Le max intérieur s'approxime au premier ordre ; la pire direction est alors celle du gradient, ϵ^=ρ ∇L/∥∇L∥\hat\epsilon = \rho\, \nabla L / \lVert\nabla L\rVert. À chaque pas, on se pousse donc d'abord de ϵ^\hat\epsilon vers le haut de la pente, on y calcule le gradient, puis on revient à la position d'origine pour la mettre à jour avec ce gradient.

Comparer les vallées par leur pire perte dans un rayon ρTrait plein : la perte L. Pointillés : la pire perte à distance ρ au plus, ce que SAM minimise. L'animation élargit ρ ; la flèche de chaque minimum pointe vers son pire voisin.
0123400.511.5Lvallée étroitevallée large
L au fond : étroite 0.33, large 0.58Pire dans ρ : étroite 1.36, large 0.80Selon ce critère, la vallée large l'emporte

La courbe pleine est la perte d'origine, la courbe en pointillés la pire perte dans un rayon ρ\rho, c'est-à-dire ce que SAM cherche réellement à faire baisser. À ρ=0\rho = 0, les deux courbes se confondent ; le fond de la vallée étroite est à 0.33, plus bas que les 0.58 de la vallée large. Quand ρ\rho passe à 0.1, la pire perte autour de la vallée étroite monte à 0.63, contre 0.60 seulement pour la vallée large, et le classement s'inverse ; à ρ=0.45\rho = 0.45, l'écart se creuse à 1.36 contre 0.80. Ce que SAM change, c'est le critère de comparaison des fonds de vallée.

Le prix à payer est deux calculs de gradient par pas. Sur ImageNet, la meilleure erreur top-1 de ResNet-152 en entraînement standard est de 20.3 %, contre 18.4 % avec SAM ; l'effet est plus net encore quand le bruit d'étiquettes est fort. Andriushchenko et Flammarion ont ensuite montré que la perturbation n'est efficace que calculée séparément sur chaque mini-lot ; la version sur toutes les données, celle que décrit la borne de généralisation de l'article, n'aide presque pas. La relation entre acuité et généralisation fait encore débat aujourd'hui.

Quand la mémoire manque : Adafactor et GaLore

Adam doit stocker deux nombres supplémentaires par paramètre, mm et vv. Avec beaucoup de paramètres, ces deux états pèsent lourd.

Mémoire d'entraînement d'un modèle 7B, hors activationsCalculée d'après les dimensions de LLaMA-7B (32 couches, d = 4096, FFN 11008, vocabulaire de 32000), tout en fp32, 1 Go = 10⁹ octets. Adafactor ne garde pas de moment d'ordre un ; GaLore ne projette que les matrices d'attention et de MLP (r = 1024) et utilise Adam pour le reste ; les gradients sont comptés en taille complète.
04080120160GBAdamWAdafactorGaLore (r = 1024)107.8 GB53.9 GB72.7 GB
paramètresgradientsétat de l'optimiseurÉtat de l'optimiseur : AdamW 53.9 Go, Adafactor 0.011 Go, GaLore 18.8 Go

Avec les dimensions de LLaMA-7B, 6.7 milliards de paramètres stockés en fp32 occupent 27 Go pour les paramètres eux-mêmes, 27 Go pour les gradients, et encore 54 Go pour les deux états d'AdamW, soit environ 108 Go au total, sans compter les résultats intermédiaires laissés par la propagation avant (les activations).

Ne garder que les sommes de lignes et de colonnes

Shazeer et Stern, les auteurs d'Adafactor, s'attaquent à vv. Pour une matrice de poids n×mn \times m, vv est aussi de taille n×mn \times m. Ils ne stockent que la somme de chaque ligne, RR, et celle de chaque colonne, CC, et reconstruisent vv au besoin :

V^=R CΣR\hat V = \frac{R\, C}{\Sigma R}

ΣR\Sigma R est la somme de toutes les sommes de lignes, c'est-à-dire la somme de toute la matrice. Cela revient à approcher vv par une matrice de rang 1 ; de rang 1 veut dire que chaque ligne n'est qu'un multiple d'un même vecteur. Le stockage passe de nmnm à n+mn + m.

Sommes de lignes et de colonnes, le reste reconstruitUne matrice V de moments d'ordre deux, de taille 6×8. Adafactor stocke R = V·1 (sommes des lignes) et C = 1ᵀ·V (sommes des colonnes), et utilise V̂ = R·C / ΣR à la place de V.
V (complète)RCV̂ = R·C / ΣR
Nombres stockés : 48 → 14Erreur relative moyenne de V̂ : 21 %

Une matrice 6×8 demandait 48 nombres ; il n'en faut plus que 14. La matrice reconstruite n'est évidemment pas identique ; dans cet exemple, l'erreur relative moyenne est de 21 %, mais vv ne sert qu'à fixer l'ordre de grandeur du pas de chaque paramètre, et une erreur de ce niveau a peu d'effet. En traduction anglais-allemand sur WMT'14, le BLEU (un score de qualité de traduction, plus il est haut, mieux c'est) est de 25.6 avant factorisation et de 25.4 après.

Adafactor supprime aussi le momentum et ne stocke même pas mm, et c'est là que les ennuis commencent. Sans momentum ni échauffement, le BLEU tombe à 0.1 ; l'entraînement échoue complètement. En cherchant la cause, les auteurs découvrent qu'avec β2=0.999\beta_2 = 0.999, vv ne suit pas l'évolution du gradient, et que la mise à jour grimpe vers le pas 800 à plus du double de sa valeur normale. La solution est l'écrêtage de la mise à jour (update clipping), qui limite à 1 la moyenne quadratique de la mise à jour entière, combiné à un β2\beta_2 qui augmente lentement avec les pas. T5 utilise précisément Adafactor ; PaLM l'utilise aussi, mais en gardant le momentum et en abandonnant même la factorisation.

Faire tourner Adam dans un petit espace

En 2024, GaLore prend un autre angle. Ses auteurs, Zhao et al., remarquent que le gradient d'une matrice de poids se concentre souvent sur quelques directions, autrement dit qu'il est de rang faible. Autant alors projeter le gradient dans un petit espace, y faire tourner Adam, puis reprojeter le résultat :

Rt=Pt⊤Gt,G~t=α Pt NtR_t = P_t^\top G_t, \qquad \tilde G_t = \alpha\, P_t\, N_t

PtP_t provient de la décomposition en valeurs singulières du gradient (qui décompose une matrice en quelques directions, chacune avec son propre facteur d'étirement), dont on garde les rr directions les plus importantes ; NtN_t est la mise à jour calculée par Adam sur la petite matrice RtR_t, et α\alpha un facteur d'échelle propre à GaLore. Les états d'Adam n'occupent plus que r×nr \times n au lieu de m×nm \times n. Tous les TT pas, on refait une décomposition en valeurs singulières et on change de sous-espace.

Adam dans un petit sous-espace, puis reprojectionUn gradient G de 6×10 dont les directions principales dérivent. Tous les 10 pas, P est recalculé à partir des 2 premiers vecteurs singuliers à gauche de G ; les deux moments d'Adam vivent sur R = PᵀG. La courbe montre la part de ‖G‖² conservée par le sous-espace.
GPR = PᵀGAdam met à jour iciα·P·N, retour en 6×100%50%100%010203040part de ‖G‖² conservée
État de l'optimiseur : Adam complet 120 nombres, GaLore 52 (P plus deux moments r×n)Conservé : 99 %

Contrairement à LoRA (une méthode de fine-tuning qui n'entraîne qu'une paire de petites matrices de rang faible), GaLore garde des poids de rang plein ; seuls les états de l'optimiseur sont contraints. En préentraînement de LLaMA 1B sur C4, la perplexité de GaLore (l'incertitude d'un modèle de langage sur le token suivant, plus elle est basse, mieux c'est ; un token est l'unité de base avec laquelle le modèle lit le texte) est de 15.64, contre 15.56 pour l'entraînement de rang plein et 19.21 pour LoRA.

Le résumé de l'article affirme que la version 8 bits permet de préentraîner un modèle 7B sur un GPU grand public de 24 Go comme la RTX 4090. Cette mémoire, environ 22 Go, a été mesurée avec seulement 256 tokens par lot ; l'expérience 7B menée à son terme a utilisé 64 A100. Le prix à payer est une décomposition en valeurs singulières à chaque changement de sous-espace. Sur un modèle 1B, l'article estime GaLore environ 17 % plus lent qu'Adam 8 bits ; sur un modèle 7B, une décomposition en valeurs singulières prend environ 10 minutes selon les mesures de LLaMA-Factory, et jusqu'à 20 minutes selon GaLore 2, l'article publié ensuite par l'équipe de GaLore.

Arrondir la vallée : méthode de Newton, Shampoo, SOAP, Sophia

Revenons à la question de savoir pourquoi Adam n'est guère plus rapide. Dans la même vallée, GD arrive au pas 93 et Adam au pas 87, à peine plus tôt.

La méthode de Newton

Si l'on connaît la forme du paysage, on peut arrondir directement la vallée. La méthode de Newton corrige le gradient par l'inverse de la hessienne :

θt+1=θt−H−1∇L(θt)\theta_{t+1} = \theta_t - H^{-1} \nabla L(\theta_t)

Sur une fonction quadratique, ce pas mène droit au minimum. Vu autrement, multiplier par H−1H^{-1} revient à changer de coordonnées ; dans les nouvelles coordonnées, la vallée est ronde et le gradient pointe droit vers le fond. Cette façon d'« arrondir d'abord le paysage, puis avancer » s'appelle le préconditionnement (preconditioning).

Arrondir la vallée en changeant de coordonnéesLa vallée des colis, centrée sur son minimum. La descente de gradient (η = 0.9) tourne dans chaque système de coordonnées, puis l'image se transforme vers le suivant : coordonnées d'origine, chaque axe remis à l'échelle selon sa propre courbure (diagonale), puis transformation par la matrice complète H^½.
matrice complète : droit au but
κ = 1.0d'origine : κ = 45.7échelle diagonale : κ = 45.6matrice complète : κ = 1.0

Cette figure se déforme d'un système de coordonnées à l'autre, parmi trois. Dans les coordonnées d'origine, le conditionnement vaut 45.7. En redimensionnant seulement chaque axe séparément, c'est-à-dire avec un préconditionnement diagonal, il devient 45.6, presque inchangé, parce que les deux éléments diagonaux de la hessienne sont déjà presque égaux, 1.09 et 1. Il faut changer de coordonnées avec la hessienne complète pour que le conditionnement tombe à 1.

Voilà pourquoi Adam n'est guère plus rapide dans notre vallée. Adam, RMSProp et AdaGrad ne font que fixer un pas propre à chaque paramètre, ce qui revient à redimensionner le long des axes ; or tout le problème de notre vallée tient à son inclinaison, que ce redimensionnement ne peut pas corriger.

Alors pourquoi ne pas utiliser directement la méthode de Newton ? Pour un modèle à nn paramètres, la hessienne est de taille n×nn \times n. Avec un milliard de paramètres, il faut stocker 101810^{18} nombres, puis inverser la matrice. Et quand le paysage n'est pas convexe (une fonction convexe n'a qu'une seule vallée, sans sommet ni point selle), la hessienne peut avoir des valeurs propres négatives, et la méthode de Newton fonce alors vers un sommet.

Shampoo et SOAP

Shampoo, de Gupta, Koren et Singer, trouve un compromis. Les paramètres d'un réseau de neurones sont surtout des matrices ; pour une matrice de poids m×nm \times n, le préconditionnement complet exige une matrice mn×mnmn \times mn. Shampoo utilise à la place deux petites matrices, à gauche et à droite, qui accumulent respectivement GG⊤GG^\top et G⊤GG^\top G :

Lt=Lt−1+GtGt⊤Rt=Rt−1+Gt⊤GtWt+1=Wt−η Lt−1/4 Gt Rt−1/4\begin{aligned} L_t &= L_{t-1} + G_t G_t^\top \\ R_t &= R_{t-1} + G_t^\top G_t \\ W_{t+1} &= W_t - \eta\, L_t^{-1/4}\, G_t\, R_t^{-1/4} \end{aligned}

Lt−1/4L_t^{-1/4} est la puissance −1/4-1/4 d'une matrice ; on la calcule en décomposant LtL_t en valeurs propres, puis en remplaçant chaque valeur propre par sa puissance −1/4-1/4. Pour une couche 1 024×1 024, le préconditionnement complet compte environ 1.1×10121.1 \times 10^{12} éléments ; Shampoo n'en demande qu'environ 2.1×1062.1 \times 10^{6}. Distributed Shampoo, développé plus tard chez Meta avec de nombreuses modifications d'ingénierie, remporte en 2024 la catégorie d'AlgoPerf qui autorise le réglage externe des hyperparamètres, en moyenne environ 28 % plus rapide que la référence NAdamW ; il n'est toutefois le plus rapide que sur deux des huit charges de travail, et n'atteint pas la cible sur ResNet dans le budget de temps.

Shampoo ne recalcule les racines matricielles que de temps en temps, et le préconditionneur reste entièrement figé entre deux calculs. Vyas et al., les auteurs de SOAP, découvrent que Shampoo avec un exposant de 1/2 équivaut à faire tourner Adafactor dans la base propre de Shampoo. SOAP fait donc passer le gradient dans la base propre de Shampoo, y fait tourner Adam, puis ramène la mise à jour dans les coordonnées d'origine. La base n'est toujours mise à jour que de loin en loin, mais le moment d'ordre deux l'est à chaque pas. Sur un modèle de langage de 360 millions de paramètres, quand la fréquence de recalcul passe de chaque pas à tous les 100 pas, la perte finale de Shampoo monte de 2.824 à 2.932, presque au niveau des 2.943 d'AdamW ; celle de SOAP ne passe que de 2.820 à 2.870.

Sophia

Sophia emprunte la voie diagonale, mais regarde la diagonale de la hessienne plutôt que le carré du gradient. Elle estime la hessienne diagonale hh tous les 10 pas, puis écrête coordonnée par coordonnée :

θt+1=θt−η clip ⁣(mtmax⁡(γht, ϵ), 1)\theta_{t+1} = \theta_t - \eta\, \mathrm{clip}\!\left(\frac{m_t}{\max(\gamma h_t,\ \epsilon)},\ 1\right)

Si la courbure est positive et assez grande, le pas suit la proportion de la méthode de Newton ; si elle est négative ou trop petite, ϵ\epsilon soutient le dénominateur, et l'écrêtage limite le pas à η\eta au plus.

Là où la courbure devient négativef(x) = x⁴/4 − x² + 0.6x + 2, départ en x = 0.1, où f″ < 0. Le pas de Newton file vers le sommet ; Sophia écrête m / max(γh, ε) dans [−1, 1]. Réglages de démonstration : β₁ = β₂ = 0.9, f″ exacte à chaque pas, γ = 1, η = 0.15 (l'article utilise β₁ = 0.96, β₂ = 0.99 et estime la hessienne tous les 10 pas).
GD (η = 0.1)
f″ < 0
Newton
f″ < 0
écrêtage à la Sophia
f″ < 0
GD (η = 0.1) : x = -1.55Newton : x = 0.32écrêtage à la Sophia : x = -1.49

Cette fonction à une dimension a une courbure négative près du point de départ. La méthode de Newton converge vers le maximum local x=0.316x = 0.316 ; elle est partie vers le sommet. Dans la zone de courbure négative, Sophia avance de 0.15 à chaque pas et descend jusqu'aux abords du fond. Dans le panneau de gauche, GD ne regarde que la pente ; il descend lui aussi tout du long et s'arrête vers −1.55-1.55. Comme il n'utilise pas du tout la courbure, une courbure négative ne peut pas le tromper, mais son pas ne s'adapte pas non plus à la courbure.

Ses auteurs, Liu et al., affirment que sur GPT-2, Sophia atteint la même perte en deux fois moins de pas qu'AdamW. Aucune évaluation indépendante ultérieure n'a retrouvé un écart aussi grand. Defazio signale sur GitHub qu'une fois le taux d'AdamW relevé, les deux font jeu égal sur un modèle de 125 millions de paramètres ; en 2025, « Fantastic Pretraining Optimizers », dont trois des auteurs de Sophia sont coauteurs, ne mesure pas non plus d'accélération significative en dessous de 500 millions de paramètres.

Ne garder que le signe : Lion

Revenons à la mémoire. Adam stocke deux états, mm et vv, pour chaque paramètre ; peut-on en garder un de moins ?

Lion a été trouvé par recherche de programmes, par Chen et al. chez Google. Ils font évoluer des programmes dans un espace construit à partir d'opérations élémentaires ; la règle retenue est la suivante :

ct=β1 mt−1+(1−β1) gtθt=θt−1−η (sign(ct)+λ θt−1)mt=β2 mt−1+(1−β2) gt\begin{aligned} c_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t \\ \theta_t &= \theta_{t-1} - \eta\,\big(\mathrm{sign}(c_t) + \lambda\, \theta_{t-1}\big) \\ m_t &= \beta_2\, m_{t-1} + (1 - \beta_2)\, g_t \end{aligned}

La direction de mise à jour ne garde que le signe ; chaque paramètre avance donc d'exactement η\eta à chaque pas. Lion ne stocke qu'un momentum mm, un état de moins qu'Adam. β1=0.9\beta_1 = 0.9 décide de la direction du pas, β2=0.99\beta_2 = 0.99 assure la mémoire à long terme du momentum ; les deux rôles sont séparés. Comme la taille de chaque pas est fixe, le taux d'apprentissage de Lion doit être 3 à 10 fois plus petit que celui d'AdamW, et sa décroissance des poids 3 à 10 fois plus grande.

Lion ne garde que le signeLes deux partent de 210 NT$ par kg + 20 NT$ de base, avec une planification en cosinus sur 200 pas (taux maximal : Adam 0.2, Lion 0.05). À chaque pas de Lion, chaque coordonnée bouge d'exactement ±η.
012-1012w (par kg)b (frais de base)
40 premiers pas en gros plan
Adam : à 0.022 du minimumLion : à 0.023 du minimumTaux actuels : Adam 0.000, Lion 0.0000

Adam et Lion font tous deux 200 pas avec une planification en cosinus, et finissent tous deux à environ 0.02 du minimum. Dans le panneau « 40 premiers pas en gros plan », les deux composantes du gradient ont d'abord le même signe ; Lion avance alors d'autant sur ww que sur bb à chaque pas, le long d'une diagonale à 45°.

Pour un ViT préentraîné sur JFT, Lion rattrape AdamW avec environ un tiers du calcul ; mais sur des modèles de langage de 1.1 à 7.5 milliards de paramètres, sa perplexité ne se distingue pas de celle d'Adafactor du début à la fin. La plupart des évaluations indépendantes ultérieures le trouvent à peu près au niveau d'AdamW.

Changer de règle

L'opération sign a l'air grossière, mais elle repose sur une explication élégante.

« La direction de plus forte pente » dépend de la façon dont on mesure les longueurs. La longueur habituelle est la norme L2 ; sur le cercle unité, la direction qui fait le plus baisser la perte est −g/∥g∥-g/\lVert g\rVert. Avec la norme L∞, qui ne regarde que la plus grande coordonnée, le « cercle » unité devient un carré, et la direction de plus forte pente tombe sur un coin, exactement −sign(g)-\mathrm{sign}(g).

Le pas le plus raide dépend de la mesure des longueursParmi les pas de longueur au plus 1, prendre celui qui fait baisser la perte le plus vite, ⟨g, d⟩ minimal. Avec la longueur habituelle (un cercle), c'est −g/‖g‖. Mesuré par la plus grande coordonnée (un carré), c'est toujours un coin, −sign(g).
Norme L2 : cercle
g
Norme L∞ : carré
g
g = (0.94, 0.34)L2 : (-0.94, -0.34)L∞ : (-1, -1)

En 2024, Bernstein et Newhouse généralisent ce point de vue dans « Old Optimizer, New Norm ». Sans moyennes mobiles exponentielles, Adam est la descente de plus forte pente pour la norme L∞ ; Shampoo sans accumulation est exactement la descente de plus forte pente pour la norme spectrale. La norme spectrale mesure de combien de fois, au plus, une matrice peut étirer un vecteur ; c'est de là que part Muon, dans la section suivante.

Traiter les poids comme des matrices : Muon

Mis à part la lignée de Shampoo, la plupart des méthodes fixent le pas coordonnée par coordonnée, ce qui revient à étaler les paramètres en une longue liste de nombres traités chacun de son côté. Or les poids d'un réseau de neurones sont surtout des matrices.

Le gradient d'une matrice de poids est souvent dominé par quelques directions, avec des valeurs singulières très inégales. Une mise à jour qui suit directement le gradient fait beaucoup bouger ces quelques directions, et presque pas les autres. Muon « orthogonalise » la matrice de momentum. On décompose la matrice de momentum MM en valeurs singulières, M=UΣV⊤M = U\Sigma V^\top, on remplace toutes les valeurs singulières par 1, et on ne garde que UV⊤UV^\top. Toutes les directions bougent alors d'autant.

À partir d'octobre 2024, Keller Jordan utilise Muon dans les courses de vitesse d'entraînement de NanoGPT et bat plusieurs records ; il ne le présente dans un billet de blog qu'en décembre. Muon ne s'applique qu'aux matrices de poids bidimensionnelles internes au réseau ; la couche d'embedding, la couche de sortie et les paramètres vectoriels restent sous AdamW.

Une décomposition en valeurs singulières exacte coûte trop cher ; Muon l'approxime par une itération de Newton–Schulz. On divise d'abord la matrice par sa norme de Frobenius, pour que toutes les valeurs singulières tombent entre 0 et 1, puis on répète cinq fois :

X←aX+b (XX⊤)X+c (XX⊤)2XX \leftarrow aX + b\,(XX^\top)X + c\,(XX^\top)^2 X

Les coefficients sont (a,b,c)=(3.4445, −4.7750, 2.0315)(a, b, c) = (3.4445,\ -4.7750,\ 2.0315).

Ce polynôme pousse les petites valeurs singulières vers le haut et tire les grandes vers le bas.

Cinq itérations de Newton–SchulzUne matrice de mise à jour 2×2, d'abord divisée par sa norme de Frobenius, puis itérée par X ← aX + b(XXᵀ)X + c(XXᵀ)²X, (a, b, c) = (3.4445, −4.7750, 2.0315). À gauche, ce que la matrice fait du cercle unité. À droite, ses deux valeurs singulières.
Cercle unité après X
Valeurs singulières
≈0.68–1.2 après cinq pas (notre calcul)00.511.5σ₁σ₂
Matrice d'origine : σ₁ = 2.05, σ₂ = 0.083σ₁ = 0.940, σ₂ = 0.697

Cette matrice 2×2 écrase d'abord le cercle unité en une ellipse aplatie ; ses valeurs singulières sont 2.05 et 0.083. Après division par la norme, elles valent 0.999 et 0.040. Après cinq pas, elles deviennent 0.94 et 0.70 ; l'ellipse se rapproche d'un cercle sans en devenir exactement un. Jordan précise dans un commentaire du code que ces coefficients visent seulement à ramener les valeurs singulières entre environ 0.5 et 1.5, une imprécision acceptée en échange de moins d'itérations ; d'après nos calculs, après cinq pas, elles tombent en réalité entre environ 0.68 et 1.2.

En 2025, Moonshot AI porte Muon aux grands modèles dans « Muon is Scalable for LLM Training ». Ils ajoutent la décroissance des poids et multiplient la mise à jour de chaque matrice par 0.2max⁡(r,c)0.2\sqrt{\max(r, c)} (rr et cc étant le nombre de lignes et de colonnes de la matrice), pour fixer la moyenne quadratique de la mise à jour autour de 0.2, en ligne avec la taille typique chez AdamW ; on peut alors reprendre directement le taux d'apprentissage et la décroissance des poids d'AdamW. Dans leurs expériences de lois d'échelle (scaling laws), Muon atteint la même perte avec seulement environ 52 % du calcul d'AdamW. Kimi K2 de Moonshot et V4 de DeepSeek ont ensuite utilisé Muon pour la majeure partie de leurs paramètres.

Lequel est le plus rapide ?

Chaque article sur un nouvel optimiseur contient une figure où il bat AdamW en vitesse. Lesquelles disent vrai ?

AlgoPerf tente de répondre à cette question par des règles. Il mesure « le temps nécessaire pour atteindre une cible fixée sur un matériel fixé ». Il compte 8 charges de travail, toujours sur 8 V100, et deux catégories ; l'une autorise un réglage externe limité des hyperparamètres, l'autre l'interdit mais accorde un budget de temps triple. Lors de la première édition, en 2024, Distributed Shampoo et Schedule-Free AdamW remportent chacun une catégorie, comme nous l'avons vu ; dans la catégorie qui autorise le réglage externe, Schedule-Free, de la même équipe, prend aussi la deuxième place.

Côté préentraînement de modèles de langage, Wen, Hall, Ma et Liang règlent soigneusement les hyperparamètres d’AdamW et de dix optimiseurs plus récents dans « Fantastic Pretraining Optimizers and Where to Find Them » (2025). Ils constatent d'abord qu'en faisant seulement passer le taux d'AdamW de la recette GPT-3 de 6e-4 à 8e-3, un modèle de 130 millions de paramètres va environ 2 fois plus vite. Bien des articles qui revendiquent un facteur 2 se comparent à un AdamW mal réglé.

Une fois la référence bien réglée, les optimiseurs matriciels comme Muon et SOAP sont environ 1.3 à 1.4 fois plus rapides entre 130 et 520 millions de paramètres, et ce facteur tombe à environ 1.1 pour 1.2 milliard de paramètres ; les optimiseurs coordonnée par coordonnée comme Lion et Sophia font à peu près jeu égal avec AdamW. Les auteurs avertissent aussi que la perte en cours d'entraînement peut tromper. Muon prend souvent une large avance au début, puis, une fois le taux d'apprentissage redescendu, finit au même niveau qu'AdamW.

À plus grande échelle, c'est une autre histoire. Dans « SOAP, Muon, and Beyond » (juillet 2026), NVIDIA compare des modèles de plusieurs milliards de paramètres entraînés sur plus de mille milliards de tokens, et mesure toujours un avantage de SOAP et de Muon sur AdamW. Leur lot de référence est d'environ 25 millions de tokens par pas ; en le multipliant par deux ou trois, AdamW se dégrade tandis que Muon reste stable ; le SOAP d'origine connaît lui aussi, avec de grands lots, des pics soudains de perte, et ne tient qu'avec une version qui réorthogonalise la base à chaque pas. Les deux études diffèrent par la taille des modèles, la quantité de données et la taille des lots ; leurs résultats peuvent être vrais en même temps.

Récapitulons

Depuis les trois pages de Cauchy en 1847, le cœur de la descente de gradient reste de suivre le gradient négatif. On l'écrit aujourd'hui en général sur une ligne :

θt+1=θt−η ∇L(θt)\theta_{t+1} = \theta_t - \eta\, \nabla L(\theta_t)

Les méthodes qui ont suivi comblent chacune l'une de ses lacunes :

  1. SGD, MBGD : trop de données, donc on ne regarde qu'un petit lot à la fois ; le prix est le bruit, et le taux d'apprentissage doit diminuer peu à peu.
  2. SGDM, NAG : dans la vallée, le point rebondit d'un versant à l'autre ; on retient les directions récentes pour que les rebonds s'annulent, et NAG freine en plus un pas plus tôt.
  3. AdaGrad, RMSProp, Adam : un seul pas pour tous les paramètres n'est pas raisonnable, alors chacun reçoit le sien ; RMSProp apprend à oublier, Adam y ajoute le momentum et la correction du biais.
  4. AMSGrad, AdamW : corriger les défauts d'Adam, qui oublie les grands gradients et réduit la décroissance des poids.
  5. Cosinus, WSD, Schedule-Free, échauffement : comment le taux d'apprentissage évolue dans le temps, si l'on peut se passer de connaître l'arrivée à l'avance, et pourquoi il faut accélérer progressivement au début.
  6. LARS, LAMB : quand les lots grossissent, chaque couche doit ajuster son propre pas.
  7. SAM : chercher non seulement un fond de vallée bas, mais aussi un fond plat.
  8. Adafactor, GaLore, Lion : trop d'états, pas assez de mémoire ; on stocke moins.
  9. Shampoo, SOAP, Sophia, Muon : estimer la forme du paysage, ou changer de règle pour mesurer la longueur d'un pas.

Si vous devez entraîner un modèle aujourd'hui, AdamW avec échauffement et planification en cosinus ou WSD reste le point de départ le plus sûr. Si le modèle est assez grand et compte beaucoup de matrices de poids, Muon et SOAP valent la peine d'être essayés. Quel que soit votre choix, réglez d'abord le taux d'apprentissage.

La prochaine fois qu'un nouvel optimiseur se dit deux fois plus rapide, commencez par demander : « Et le taux d'apprentissage d'AdamW, vous l'avez réglé ? »