Ouvrez un script d'entraînement PyTorch ; dans la boucle, on trouve presque toujours ces deux lignes :
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 :
Les bases
- BGDLe point de départ : chaque pas lit toutes les données.
- SGD · MBGDLire toutes les données à chaque pas est trop lent → tirer un exemple ou un petit lot.
- SGDMZigzags et bruit → accumuler une vitesse.
- NAGLe momentum dépasse la cible → prendre le gradient au point d'anticipation.
Un pas par paramètre
- AdaGradUn seul taux pour tous les paramètres → mettre chacun à l'échelle selon ses gradients accumulés.
- RMSProp · AdaDeltaLe taux d'AdaGrad ne fait que baisser → une moyenne mobile qui sait oublier.
- Adam · NadamRéunir momentum et pas par paramètre, et corriger le départ à zéro.
Corriger Adam
- AMSGradAdam peut converger au mauvais endroit → ne jamais laisser v diminuer.
- AdamWAdam divise aussi la régularisation L2 → découpler la décroissance des poids.
- 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
- LARS · LAMBLots énormes, ‖w‖/‖g‖ très variable selon la couche → un rapport de confiance par couche.
- Adafactor · GaLoreL'état de l'optimiseur dévore la mémoire → le factoriser, ou le loger dans un sous-espace de rang faible.
- SAMUne perte basse dans une vallée étroite → comparer la pire perte dans un rayon ρ.
- Shampoo · SOAP · SophiaUne mise à l'échelle diagonale ne redresse pas une vallée oblique → préconditionneurs matriciels, ou courbure avec écrêtage.
- LionMoins d'état et de calcul → ne garder que le signe.
- 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 :
est le poids (en kg), les frais d'envoi prédits (en centaines de NT$), le supplément par kg et les frais de base. À partir de ces 12 enregistrements, nous voulons trouver les et les mieux adaptés.
Commençons par deviner au hasard, 210 NT$ par kg et 20 NT$ de frais de base, soit et . 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 :
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 devant sert seulement à éliminer le 2 que fera descendre le carré quand nous dériverons tout à l'heure.
Ce s'appelle la fonction de perte (loss function). Avec notre estimation, .
Vient maintenant l'idée la plus importante de tout l'article.
Chaque couple est une droite, et correspond aussi à une valeur de perte. Mettons en abscisse et 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.
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 , , soit 59 NT$ par kg et 61 NT$ de frais de base ; la perte y vaut .
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 à sa valeur optimale et ne faisons varier que ; le paysage se réduit alors à une courbe. La pente de la tangente en un point de la courbe est la dérivée :
Une pente positive veut dire que la perte augmente quand 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 :
Rangées dans un vecteur, elles forment le gradient :
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 vaut 1 pour tous les colis ; celle de est le poids du colis, si bien que plus un colis est lourd, plus il a son mot à dire sur .
Au point de départ , les 12 colis sont tous surestimés, et le calcul donne . Les deux composantes sont positives ; augmenter encore ou ferait donc monter la perte.
La figure montre deux propriétés du gradient :
- Il pointe dans la direction de plus forte montée ; est donc la direction de plus forte descente.
- Il est perpendiculaire à la courbe de niveau qui passe par ce point.
Pourquoi ? Si l'on fait un petit pas autour d'un point , la perte varie à peu près selon
C'est le développement de Taylor au premier ordre. Le produit scalaire s'écrit , où est l'angle entre le gradient et le pas. À longueur de pas fixée, c'est avec , 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'angle vaut , 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 , et on recommence :
(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 :
La perte tombe de 0.71 à 0.040, soit plus de 90 % de moins en un seul pas.
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 ?
Le taux d'apprentissage : jusqu'où aller à chaque pas
Revenons au cas le plus simple, un bol à une dimension, . 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 , donc à chaque pas :
À chaque pas, est multiplié une fois de plus par .
Dans la figure, ; les quatre essais ne diffèrent que par :
- : chaque pas ne retire que 10 %, on se traîne.
- : il ne reste que 10 % après chaque pas, on atteint vite le fond.
- : ; chaque pas passe de l'autre côté, mais de moins en moins loin, et l'on converge en oscillant.
- : ; 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 , soit . 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 .
Un même doit servir les deux directions à la fois. Pour ne pas diverger dans la direction raide, doit rester sous ; mais dans la direction plate, chaque pas ne réduit alors l'écart que de au plus, et il faut au moins plusieurs dizaines de pas. Un 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.
Avec , 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 , c'est-à-dire plus 1 et moins 1. Pour un colis de 1 kg, les frais prédits 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 . Les droites que l'on peut tracer sont exactement les mêmes, mais et la nouvelle ordonnée à l'origine 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 , 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 :
- Se souvenir des directions récentes, pour que les allers-retours s'annulent (momentum).
- Donner à chaque paramètre son propre pas (AdaGrad, RMSProp, Adam).
- 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.
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 , 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) :
Si la longueur du gradient dépasse , on la ramène à 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 à ? 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 :
est la perte propre au -ème exemple, et l'exemple tiré au pas .
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 :
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.
Les trois trajectoires utilisent le même . 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.
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 , 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ù , 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 :
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. 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.
Ce paysage est . L'origine est un point selle ; c'est un fond de vallée dans la direction , un sommet dans la direction , et le gradient y est nul. Les deux vrais fonds de vallée sont en .
GD part de ; le gradient selon 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 .
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) :
La nouvelle moyenne est l'ancienne multipliée par , plus le nouveau gradient multiplié par . Avec , le nouveau gradient compte pour un dixième ; celui d'il y a dix pas garde encore 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.
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 :
Ce n'a pas le facteur ; il vaut donc fois l'EMA ci-dessus. Quand le gradient pointe toujours du même côté, s'accumule jusqu'à , soit 10 fois le gradient pour . Les petits gradients qui n'avançaient pas dans la direction plate se trouvent ainsi amplifiés.
L'image vient de la physique. est comme la vitesse d'une boule, le gradient est la poussée que lui donne la pente, et 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
c'est-à-dire qu'au pas de gradient il ajoute « le déplacement précédent » multiplié par . En éliminant des deux équations ci-dessus, on obtient exactement la même formule, avec égal à . 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 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 , le nombre de pas de GD est à peu près proportionnel à , celui de la boule pesante seulement à . Pour notre vallée, et . 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.
Avec le même , GD n'arrive qu'au pas 93 ; avec un momentum , 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 est trop grand ?
Les trois figures utilisent . Avec , la mémoire est trop courte, l'aide limitée, et le point n'arrive pas en 200 pas ; avec , il arrive au pas 51 ; avec , 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 :
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.
Le cercle creux est le point d'anticipation de NAG. Avec les mêmes et , 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 , où 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 , et son momentum effectif tombe à , presque aucun élan ; la direction du fond, avec , 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 . 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 .
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 :
Ici, le carré, la racine et la division se font paramètre par paramètre. est un très petit nombre qui évite la division par zéro.
Pour un paramètre aux gradients toujours grands, croît vite et le pas rétrécit ; un paramètre rarement mis à jour garde un petit et peut faire un grand pas dès qu'un gradient arrive. Le premier pas est encore plus intéressant. Comme , le premier pas de chaque paramètre vaut , quelle que soit la taille du gradient.
Avec , le premier pas déplace et 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 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.
ne fait que grandir, et le taux effectif 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 :
vaut généralement 0.9. Ici, est la moyenne des carrés du gradient ; ce n'est pas la vitesse 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 , 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.
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 . Les deux méthodes partent de ; AdaGrad utilise , RMSProp et .
Sur la partie raide, les grands gradients gonflent le dénominateur des deux méthodes. Une fois sur la pente douce, le 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 , 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 du numérateur par la moyenne quadratique (RMS) des « mises à jour passées » :
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 :
est l'estimation du moment d'ordre un du gradient, c'est-à-dire sa moyenne ; est l'estimation du moment d'ordre deux, la moyenne de son carré. Dans l'article d'Adam, le taux d'apprentissage est noté ; il joue le même rôle que jusqu'ici. Les valeurs par défaut de l'article sont , , , , 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
et partent tous deux de 0. Au premier pas, , soit un dixième seulement du vrai gradient ; , un millième seulement. Les deux estimations sont tirées vers le bas par le 0 de départ.
En développant et en supposant que l'espérance du gradient reste , on obtient . Diviser par corrige donc le biais ; même chose pour .
Pourquoi cette correction est-elle indispensable ? Les deux estimations ne sont pas biaisées au même degré. Avec , est tiré vers le bas bien plus fortement que ; sans correction, le dénominateur est trop petit, et le pas trop grand.
Supposons un gradient constant égal à 1. Corrigé, vaut 1 dès le premier pas, et le pas vaut exactement . Sans correction, le premier pas est 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 est proche de 1, plus l'entraînement sans correction du biais est instable au début.
Un pas d'environ
Après correction, reste à peu près autour de . Multipliez toute la perte par 100 ; le gradient est multiplié par 100, et grandissent ensemble, et, au minuscule près, la mise à jour ne change presque pas. Chaque paramètre avance d'environ 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' 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 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 () arrive au pas 93 ; le momentum (, ) au pas 47 ; RMSProp () au pas 130 ; Adam () 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 » , 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 est contraint à , avec un cycle de trois pas ; la perte vaut au premier pas, puis aux deux suivants. Avec , le gradient total d'un cycle vaut ; il faudrait donc pousser vers .
C'est là que le dénominateur d'Adam se trompe. Dès que le grand gradient rare de 3 apparaît, grossit aussitôt, et le de ce pas est écrasé à environ 1.05 ; aux deux pas suivants, le gradient n'est que de , redescend vite, et ces deux pas sont amplifiés à et . Sur un cycle, en unités de , Adam fait 0.68 de trop dans la mauvaise direction.
Les deux partent de , avec un taux . Adam est repoussé à tous les trois pas et reste bloqué à la mauvaise extrémité ; AMSGrad atteint environ au pas 100, et au pas 300.
Les valeurs et sont celles que l'article choisit pour sa démonstration. La racine du problème est que le taux effectif d'Adam, , 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 :
Le taux effectif ne peut alors plus que diminuer, jamais augmenter. Dans l'exemple ci-dessus, les trois pas utilisent le même , 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 ; 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 à la perte ajoute un terme au gradient, ce qui réduit un peu les paramètres à chaque pas.
Les premières implémentations d'Adam ajoutaient donc au gradient. Mais dans Adam, ce terme est lui aussi divisé par . Pour un paramètre aux gradients toujours grands, 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 :
C'est AdamW. Dans cette formule, est le taux d'apprentissage, et le multiplicateur de la planification du taux d'apprentissage au pas , égal à 1 si le taux est fixe.
Les deux poids partent de 1 ; leurs gradients ne sont que du bruit, d'amplitudes différant d'un facteur mille. , . Dans la version où L2 est ajouté au gradient, , aux grands gradients, ne décroît presque pas et vaut encore 0.96 après 500 pas ; , 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– ; 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 :
est le temps déjà écoulé dans le cycle en cours, 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 , pour des cycles de plus en plus longs. Ses auteurs ne sont autres que Loshchilov et Hutter, qui signeront plus tard AdamW.
Les cinq planifications de la figure partagent un même curseur. Celle de SGDR utilise et , 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 :
Ici, , et sont trois jeux de paramètres, sans rapport avec le poids des colis. suit un SGD ordinaire avec un pas fixe ; est la moyenne de tous les , et c'est le modèle que l'on utilise au final ; le gradient est calculé en , entre les deux. Moyenner les passés équivaut à une décroissance linéaire dont le point d'arrivée suit à tout moment le pas courant.
Chaque pas tire 4 colis, avec et . Pendant les cent et quelques premiers pas, est nettement à la traîne de , car il traite tous les à égalité, y compris les tout premiers , très loin du minimum ; plus on avance, plus 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 , 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 ; 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, 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. , si bien que le taux adaptatif repose sur un seul échantillon, et sa variance diverge même.
La figure montre 2 000 simulations, avec des gradients tirés d'une loi normale centrée réduite et . Au pas 1, 90 % des valeurs simulées de 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 ; pendant les premiers pas, quand la variance est trop grande, il renonce carrément au taux adaptatif. Avec , les 4 premiers pas n'utilisent que le momentum ; ensuite 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 ne dépend que du numéro de pas et de , 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 pas, soit 2 000 pas pour . 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 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.
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 , de sorte que la mise à jour soit proportionnelle à la taille des poids de cette couche :
est un petit coefficient de confiance, noté 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 de la couche selon Adam, on ajoute la décroissance des poids , puis on donne à la mise à jour totale une longueur proportionnelle à celle des poids de la couche :
désigne les poids de la couche , et 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 » :
Ici, représente l'ensemble des paramètres du modèle ; est une perturbation des paramètres, distincte du qui évitait la division par zéro ; est le rayon de la perturbation, sans rapport non plus avec le de RMSProp. Dans un rayon , 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, . À chaque pas, on se pousse donc d'abord de 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.
La courbe pleine est la perte d'origine, la courbe en pointillés la pire perte dans un rayon , c'est-à-dire ce que SAM cherche réellement à faire baisser. À , 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 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 ; à , 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, et . Avec beaucoup de paramètres, ces deux états pèsent lourd.
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 à . Pour une matrice de poids , est aussi de taille . Ils ne stockent que la somme de chaque ligne, , et celle de chaque colonne, , et reconstruisent au besoin :
est la somme de toutes les sommes de lignes, c'est-à-dire la somme de toute la matrice. Cela revient à approcher 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 à .
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 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 , 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 , 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 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 :
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 directions les plus importantes ; est la mise à jour calculée par Adam sur la petite matrice , et un facteur d'échelle propre à GaLore. Les états d'Adam n'occupent plus que au lieu de . Tous les pas, on refait une décomposition en valeurs singulières et on change de sous-espace.
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 :
Sur une fonction quadratique, ce pas mène droit au minimum. Vu autrement, multiplier par 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).
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 à paramètres, la hessienne est de taille . Avec un milliard de paramètres, il faut stocker 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 , le préconditionnement complet exige une matrice . Shampoo utilise à la place deux petites matrices, à gauche et à droite, qui accumulent respectivement et :
est la puissance d'une matrice ; on la calcule en décomposant en valeurs propres, puis en remplaçant chaque valeur propre par sa puissance . Pour une couche 1 024×1 024, le préconditionnement complet compte environ éléments ; Shampoo n'en demande qu'environ . 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 tous les 10 pas, puis écrête coordonnée par coordonnée :
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, soutient le dénominateur, et l'écrêtage limite le pas à au plus.
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 ; 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 . 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, et , 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 :
La direction de mise à jour ne garde que le signe ; chaque paramètre avance donc d'exactement à chaque pas. Lion ne stocke qu'un momentum , un état de moins qu'Adam. décide de la direction du pas, 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.
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 que sur à 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 . 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 .
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 en valeurs singulières, , on remplace toutes les valeurs singulières par 1, et on ne garde que . 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 :
Les coefficients sont .
Ce polynôme pousse les petites valeurs singulières vers le haut et tire les grandes vers le bas.
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 ( et é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 :
Les méthodes qui ont suivi comblent chacune l'une de ses lacunes :
- 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.
- 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.
- 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.
- AMSGrad, AdamW : corriger les défauts d'Adam, qui oublie les grands gradients et réduit la décroissance des poids.
- 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.
- LARS, LAMB : quand les lots grossissent, chaque couche doit ajuster son propre pas.
- SAM : chercher non seulement un fond de vallée bas, mais aussi un fond plat.
- Adafactor, GaLore, Lion : trop d'états, pas assez de mémoire ; on stocke moins.
- 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é ? »
