Retour à la bibliothèque
arXiv 2014ICLR 2015OptimiseursNotes de lecture

Adam

Le premier pas d'Adam

Article original

Adam: A Method for Stochastic Optimization

Auteurs de l’article

Diederik P. Kingma · Jimmy Ba

Publication
ICLR 2015Conférence
Premier dépôt sur arXiv
arXiv:1412.6980
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{optimizersadam2014,
  title = {{Adam: A Method for Stochastic Optimization}},
  author = {Diederik P. Kingma and Jimmy Ba},
  year = {2014},
  eprint = {1412.6980},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1412.6980}
}
Sur cette page

En première page de l'article, une note de bas de page précise que les deux auteurs ont contribué à parts égales, et que l'ordre des noms a été tiré à pile ou face sur Google Hangout.

Après le tirage, Diederik Kingma passe devant, Jimmy Ba derrière, et l'article est mis en ligne sur arXiv en décembre 2014. La légende de l'Algorithm 1 contient la phrase « Good default settings for the tested machine learning problems », suivie de quatre nombres, α=0.001\alpha=0.001, β1=0.9\beta_1=0.9, β2=0.999\beta_2=0.999, ϵ=10−8\epsilon=10^{-8}.

Dix ans plus tard, dans PyTorch, les valeurs par défaut de torch.optim.Adam sont toujours ces quatre nombres.

Cette note décortique l'Algorithm 1 ligne par ligne. Qu'estiment exactement les deux moyennes mobiles ? Pourquoi diviser par 1−βt1-\beta^t ? Quelle distance parcourt-on à chaque pas ? Qu'ont démontré les expériences de l'article, et quelle partie a ensuite été réfutée ?

Définir le problème

Pour entraîner un réseau de neurones, nous n'avons que des gradients calculés sur des mini-lots, et chaque pas est bruité ; les régularisations comme le dropout ajoutent encore une couche d'aléa. Les paramètres se comptent facilement par millions, les méthodes du second ordre coûtent trop cher, et l'article se limite d'emblée aux méthodes du premier ordre.

Le SGD de base utilise le même taux d'apprentissage pour tous les paramètres. Or l'amplitude des gradients peut varier de plusieurs ordres de grandeur d'un paramètre à l'autre ; un même taux d'apprentissage est trop grand pour certains et trop petit pour d'autres.

Deux approches traitaient déjà ce problème.

  • AdaGrad garde, pour chaque paramètre, la somme des carrés de tous ses gradients passés, et divise le gradient par sa racine carrée, θt+1=θt−α gt/∑i=1tgi2\theta_{t+1}=\theta_t-\alpha\, g_t\big/\sqrt{\sum_{i=1}^{t} g_i^2}. Une caractéristique rare a une petite somme de carrés, donc un grand pas ; la méthode est particulièrement efficace sur les données creuses. En contrepartie, la somme ne fait que croître, et le taux d'apprentissage diminue sans cesse.
  • RMSProp remplace la somme par une moyenne mobile exponentielle, qui ne regarde que les gradients récents. Le taux d'apprentissage ne diminue plus sans fin, et la méthode s'accommode mieux d'une fonction objectif qui change au fil du temps.

Adam veut réunir les avantages des deux. La section 5 de l'article souligne en outre que RMSProp n'a pas de correction du biais. Quand β2\beta_2 est proche de 1 (justement le réglage dont les gradients creux ont besoin), RMSProp sans correction fait des pas initiaux énormes, et diverge souvent d'emblée.

L'article cherche donc à savoir si l'on peut construire un optimiseur qui n'utilise que des gradients du premier ordre, dont la mémoire ne demande que deux copies supplémentaires de la taille des paramètres, qui gère à la fois les gradients creux et les objectifs non stationnaires, et qui avance de façon stable dès le début de l'entraînement.

Résoudre le problème

Algorithm 1

Commençons par écrire l'algorithme en entier. Toutes les opérations se font élément par élément ; gt2g_t^2 désigne gt⊙gtg_t\odot g_t, et βt\beta^t est β\beta à la puissance tt :

gt←∇θft(θt−1)mt←β1 mt−1+(1−β1) gtvt←β2 vt−1+(1−β2) gt2m^t←mt / (1−β1t)v^t←vt / (1−β2t)θt←θt−1−α m^t / (v^t+ϵ)\begin{aligned} g_t &\leftarrow \nabla_\theta f_t(\theta_{t-1}) \\ m_t &\leftarrow \beta_1\, m_{t-1} + (1-\beta_1)\, g_t \\ v_t &\leftarrow \beta_2\, v_{t-1} + (1-\beta_2)\, g_t^2 \\ \hat m_t &\leftarrow m_t \,/\, (1-\beta_1^t) \\ \hat v_t &\leftarrow v_t \,/\, (1-\beta_2^t) \\ \theta_t &\leftarrow \theta_{t-1} - \alpha\, \hat m_t \,/\, \big(\sqrt{\hat v_t}+\epsilon\big) \end{aligned}

Au départ, m0=v0=0m_0=v_0=0 et t=0t=0 ; chaque itération commence par incrémenter tt.

mtm_t est la moyenne mobile exponentielle du gradient ; l'article l'appelle estimation du moment d'ordre un, c'est-à-dire de la moyenne du gradient. vtv_t est la moyenne mobile exponentielle du carré du gradient, une estimation du moment d'ordre deux (la variance non centrée). Le nom Adam vient de adaptive moment estimation (d'après les remerciements, ce sont Ivo Danihelka et Tom Schaul qui l'ont trouvé).

La mise à jour vaut m^t/v^t\hat m_t/\sqrt{\hat v_t}. Le numérateur donne la direction et, comme c'est une moyenne mobile, il a un effet de momentum ; le dénominateur donne à chaque paramètre sa propre échelle. Cela revient à donner à chaque paramètre son propre taux d'apprentissage α/v^t\alpha/\sqrt{\hat v_t}, simplement réestimé à chaque pas à partir des gradients récents.

L'article propose aussi une écriture un peu plus économe en calcul, qui fusionne les deux corrections en un seul coefficient :

αt=α⋅1−β2t1−β1t,θt←θt−1−αt mt / (vt+ϵ^)\alpha_t=\alpha\cdot\frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t},\qquad \theta_t\leftarrow\theta_{t-1}-\alpha_t\, m_t\,/\,\big(\sqrt{v_t}+\hat\epsilon\big)

Les deux écritures ne diffèrent que par l'endroit où l'on ajoute ϵ\epsilon ; le ϵ^\hat\epsilon ci-dessus et le ϵ\epsilon de l'Algorithm 1 sont deux grandeurs différentes. Cette petite différence est restée dans les frameworks ; nous y reviendrons dans la discussion.

La correction du biais

Les deux divisions du milieu sont la principale différence entre cet article et RMSProp, et c'est précisément ce que dérive la section 3.

En développant la récurrence de vtv_t, on obtient une somme pondérée de tous les carrés des gradients passés :

vt=(1−β2)∑i=1tβ2 t−i gi2v_t=(1-\beta_2)\sum_{i=1}^{t}\beta_2^{\,t-i}\, g_i^2

Prenons l'espérance des deux côtés. Si l'on suppose que l'espérance du carré du gradient ne change pas dans le temps, on peut sortir E[gt2]\mathbb E[g_t^2], et il reste une série géométrique :

E[vt]=E[gt2]⋅(1−β2)∑i=1tβ2 t−i+ζ=E[gt2]⋅(1−β2t)+ζ\mathbb E[v_t]=\mathbb E[g_t^2]\cdot(1-\beta_2)\sum_{i=1}^{t}\beta_2^{\,t-i}+\zeta =\mathbb E[g_t^2]\cdot(1-\beta_2^t)+\zeta

Si le moment d'ordre deux est réellement stationnaire, ζ=0\zeta=0 ; même s'il varie, ζ\zeta reste petit tant que β2\beta_2 donne un poids assez faible aux gradients trop anciens. Le facteur 1−β2t1-\beta_2^t qui reste vient uniquement du départ à v0=0v_0=0 ; en divisant par ce facteur, l'estimation retrouve la bonne échelle. La dérivation pour mtm_t est identique.

Calculons le premier pas avec les valeurs par défaut. À t=1t=1 :

  • m1=0.1 g1m_1=0.1\,g_1, soit un dixième seulement de la vraie valeur ;
  • v1=0.001 g12v_1=0.001\,g_1^2, ce qui donne 0.0316 ∣g1∣0.0316\,|g_1| après la racine carrée, environ un trentième seulement de la vraie échelle.

Les deux sont trop petits, mais vv l'est davantage. Sans correction, le premier pas vaut α⋅0.1/0.0316≈3.16 α\alpha\cdot 0.1/0.0316\approx 3.16\,\alpha. Avec la correction, m^1=g1\hat m_1=g_1 et v^1=g12\hat v_1=g_1^2, et le premier pas de chaque paramètre vaut exactement α⋅sign⁡(g1)\alpha\cdot\operatorname{sign}(g_1).

Voilà le premier pas d'Adam. Que le gradient vaille 10−610^{-6} ou 10310^{3}, chaque paramètre ne se déplace que de α\alpha.

Et sans correction, combien de temps durent ces pas trop grands ? Si l'on suppose un gradient identique à chaque étape, la longueur du pas sans correction vaut α (1−β1t)/1−β2t\alpha\,(1-\beta_1^t)/\sqrt{1-\beta_2^t}. Traçons-la.

Graphique en courbes ; en abscisse, l'étape t (échelle logarithmique, de 1 à 20 000) ; en ordonnée, la longueur du pas sans correction du biais, en unités de α, avec β1 fixé à 0.9. La courbe bleue de β2 = 0.99 culmine à environ 2.1α à l'étape 13, et revient près de α vers deux cents étapes ; la courbe orange en tirets de β2 = 0.999 culmine à environ 6.6α à l'étape 12, et vaut encore environ 1.26α à l'étape 1 000 ; la courbe verte en pointillés de β2 = 0.9999 culmine à environ 20.7α à l'étape 12, vaut encore environ 3.2α à l'étape 1 000, et ne revient à α qu'après plus de dix mille étapes. Avec correction du biais, les trois courbes valent α en permanence.
Graphique créé pour cette note, calculé d'après l'Algorithm 1 de l'article, en supposant un gradient identique à chaque étape.

Les trois courbes culminent vers les étapes 12 et 13. À ce moment, mtm_t a déjà accumulé environ 70 % de sa vraie valeur ; avec β2=0.999\beta_2=0.999, vtv_t n'en a accumulé qu'environ 1 %, et à peine plus de 10 % après la racine carrée. Le numérateur a rattrapé son retard, pas le dénominateur. Avec β2=0.999\beta_2=0.999, le maximum est de 6.6 α6.6\,\alpha, et il faut plus de 1 700 étapes pour revenir sous 1.1 α1.1\,\alpha ; avec β2=0.9999\beta_2=0.9999, le maximum est de 20.7 α20.7\,\alpha, et il en faut plus de 17 000.

Si l'on retire en plus le momentum (β1=0\beta_1=0), le premier pas sans correction vaut α/1−β2\alpha/\sqrt{1-\beta_2}, soit 100 α100\,\alpha pour β2=0.9999\beta_2=0.9999. Le taux d'apprentissage est réglé à 10−310^{-3}, et le premier pas équivaut pourtant à un taux de 10−110^{-1}.

C'est exactement la situation que décrit l'article. Les gradients creux exigent un β2\beta_2 très grand pour moyenner assez d'échantillons, et plus β2\beta_2 est proche de 1, plus le biais initial non corrigé est sévère.

Quelle distance pour un pas ?

La section 2.1 analyse ensuite la mise à jour elle-même. Posons d'abord ϵ=0\epsilon=0 ; le pas effectif vaut alors Δt=α m^t/v^t\Delta_t=\alpha\,\hat m_t/\sqrt{\hat v_t}.

m^t/v^t\hat m_t/\sqrt{\hat v_t} est la « moyenne du gradient » divisée par la « racine carrée de la moyenne du carré du gradient ». Comme ∣E[g]∣≤E[g2]|\mathbb E[g]|\le\sqrt{\mathbb E[g^2]}, la valeur absolue de ce rapport ne dépasse généralement pas 1, et ∣Δt∣|\Delta_t| est donc à peu près borné par α\alpha.

Il y a une exception. Si le gradient d'un paramètre a toujours été nul et ne prend une valeur qu'à ce pas-ci, m^t\hat m_t vaut environ (1−β1)gt(1-\beta_1)g_t et v^t\hat v_t environ (1−β2)gt2(1-\beta_2)g_t^2, et le rapport devient (1−β1)/1−β2(1-\beta_1)/\sqrt{1-\beta_2}. La borne supérieure que donne l'article distingue donc deux cas :

∣Δt∣≤{α⋅(1−β1)/1−β2,si 1−β1>1−β2α,sinon|\Delta_t|\le \begin{cases} \alpha\cdot(1-\beta_1)/\sqrt{1-\beta_2}, & \text{si } 1-\beta_1>\sqrt{1-\beta_2}\\[2pt] \alpha, & \text{sinon} \end{cases}

Avec les valeurs par défaut, 1−β1=0.11-\beta_1=0.1 est supérieur à 0.001≈0.0316\sqrt{0.001}\approx0.0316 ; le réglage par défaut tombe donc dans le premier cas, et le pire cas vaut 3.16 α3.16\,\alpha. Cela n'arrive que pour des paramètres extrêmement creux ; d'après l'article, quand la parcimonie est moins extrême, le pas effectif est plus petit que cette borne.

Cette propriété a trois conséquences pratiques.

  1. α\alpha est la taille du pas. C'est à peu près la distance parcourue à chaque pas dans l'espace des paramètres ; l'article la compare à une région de confiance tracée autour des paramètres courants. Si l'on sait à peu près à quelle distance de l'initialisation se trouve une bonne solution, on peut en déduire l'ordre de grandeur de α\alpha.
  2. Indépendance vis-à-vis de l'échelle du gradient. Si l'on multiplie le gradient par cc, m^t\hat m_t est multiplié par cc et v^t\hat v_t par c2c^2, et le rapport ne change pas. Si l'on multiplie la fonction de perte par 1000, le pas de SGD est multiplié par 1000, alors qu'Adam n'est pas affecté du tout.
  3. Recuit automatique. L'article emprunte l'expression « rapport signal sur bruit » pour désigner m^t/v^t\hat m_t/\sqrt{\hat v_t}. Près de l'optimum, la direction du gradient change souvent de signe ; sa moyenne s'approche de 0 alors que la moyenne de son carré demeure, le rapport diminue, et le pas avec lui.

Liens avec AdaGrad et RMSProp

La section 5 replace Adam dans sa famille d'origine.

Par rapport à RMSProp, il y a deux différences. RMSProp avec momentum divise d'abord le gradient par l'échelle, puis applique le momentum au résultat ; Adam estime séparément les moments d'ordre un et deux du gradient, puis divise l'un par l'autre. L'autre différence est la correction du biais.

Le lien avec AdaGrad est plus intéressant. Avec β1=0\beta_1=0, 1−β21-\beta_2 tendant vers 0 et un taux d'apprentissage remplacé par αt=α/t\alpha_t=\alpha/\sqrt t, le v^t\hat v_t corrigé devient 1t∑i=1tgi2\frac1t\sum_{i=1}^t g_i^2 ; réinjecté dans la mise à jour, il donne exactement AdaGrad. Cette correspondance ne tient que si l'on garde la correction du biais ; sans elle, β2\beta_2 tendant vers 1 fait tendre 1−β2t1-\beta_2^t vers 0, et la mise à jour devient infinie.

L'article note aussi que v^t\hat v_t peut se voir comme une approximation de la diagonale de la matrice d'information de Fisher ; Adam revient à un préconditionnement (preconditioning) par l'inverse de sa racine carrée. C'est un peu plus prudent que le gradient naturel, qui utilise directement l'inverse de la matrice de Fisher.

AdaMax

La section 7.1 propose une extension. Adam met le gradient à l'échelle avec une norme L2L^2 ; les auteurs généralisent à LpL^p :

vt=β2p vt−1+(1−β2p) ∣gt∣pv_t=\beta_2^p\, v_{t-1}+(1-\beta_2^p)\,|g_t|^p

Pour pp grand, le calcul devient numériquement instable ; mais si l'on fait tendre p→∞p\to\infty en posant ut=lim⁡p→∞vt1/pu_t=\lim_{p\to\infty}v_t^{1/p}, seul le plus grand terme survit dans la somme pondérée, et l'on obtient une récurrence très simple :

ut=max⁡(β2 ut−1, ∣gt∣),θt←θt−1−α1−β1t⋅mtutu_t=\max\big(\beta_2\, u_{t-1},\ |g_t|\big),\qquad \theta_t\leftarrow\theta_{t-1}-\frac{\alpha}{1-\beta_1^t}\cdot\frac{m_t}{u_t}

utu_t est « le plus grand gradient passé, atténué au fil du temps ». Si ∣g∣=10|g|=10 apparaît à un pas, uu passe à 10, puis est multiplié par 0.999 à chaque pas ; mille pas plus tard, il vaut encore environ 3.7. Il n'a pas besoin de correction du biais, car utu_t vaut au moins le ∣gt∣|g_t| courant et ne remonte pas lentement depuis 0. La borne sur le pas est aussi plus simple, ∣Δt∣≤α|\Delta_t|\le\alpha. L'article recommande par défaut α=0.002\alpha=0.002, avec les mêmes β1\beta_1 et β2\beta_2 qu'Adam.

Par ailleurs, la section 7.2 propose une moyenne mobile exponentielle des paramètres, θˉt←β2θˉt−1+(1−β2)θt\bar\theta_t\leftarrow\beta_2\bar\theta_{t-1}+(1-\beta_2)\theta_t, dont le biais initial est lui aussi corrigé par 1−β2t1-\beta_2^t.

La preuve de convergence

La section 4 analyse Adam dans le cadre de l'optimisation convexe en ligne. À chaque pas, l'algorithme fait face à une fonction convexe ftf_t inconnue à l'avance ; le critère est le regret, c'est-à-dire l'excès de perte cumulée par rapport au meilleur paramètre fixe choisi a posteriori :

R(T)=∑t=1T[ft(θt)−ft(θ∗)]R(T)=\sum_{t=1}^{T}\big[f_t(\theta_t)-f_t(\theta^*)\big]

Les conditions du Theorem 4.1 sont nombreuses. Il faut des gradients bornés, des distances bornées entre les itérés, β12/β2<1\beta_1^2/\sqrt{\beta_2}<1, un taux d'apprentissage décroissant en αt=α/t\alpha_t=\alpha/\sqrt t, et un β1\beta_1 qui décroît lui aussi dans le temps, selon β1,t=β1λt−1\beta_{1,t}=\beta_1\lambda^{t-1}. Sous ces conditions, l'article obtient un regret en O(T)O(\sqrt T), et le regret moyen R(T)/TR(T)/T tend vers 0.

En pratique, on fait rarement tourner Adam dans ces conditions ; le taux d'apprentissage est souvent fixe ou suit une autre planification, et β1\beta_1 reste fixé à 0.9. L'article reconnaît lui-même, à la section 6.2, que cette analyse ne s'applique pas aux problèmes non convexes comme les réseaux de neurones.

Ce théorème s'est ensuite révélé faux. En 2018, Reddi, Kale et Kumar montrent qu'à une étape, la preuve en annexe traite v^t/αt−v^t−1/αt−1\sqrt{\hat v_t}/\alpha_t-\sqrt{\hat v_{t-1}}/\alpha_{t-1} comme une quantité qui ne peut pas être négative. Cette quantité mesure la variation dans le temps de « l'inverse du taux d'apprentissage effectif » ; le vtv_t d'Adam est une moyenne mobile, qui diminue quand les gradients diminuent, et la quantité peut donc être négative. Ils relèvent aussi des problèmes dans les lemmes 10.3 et 10.4, et construisent un problème convexe à une dimension qui satisfait les conditions du théorème, et sur lequel Adam converge vers le pire point.

Discussion

Les trois séries d'expériences, régression logistique, perceptron multicouche et réseau convolutif, utilisent toutes une taille de lot de 128, avec les mêmes paramètres initiaux pour tous les optimiseurs comparés ; les hyperparamètres comme le taux d'apprentissage et le momentum sont cherchés sur une grille dense, et seule la meilleure combinaison est rapportée. L'article ne trace que des courbes de perte ; pour les trois premières séries, il précise qu'il s'agit de la perte d'entraînement, et aucune précision de test n'est donnée. Gardez-le en tête en lisant les figures ; ces expériences comparent « qui fait baisser la perte d'entraînement le plus vite ».

Régression logistique

Deux graphiques en courbes. À gauche, la régression logistique sur MNIST ; en abscisse les époques (0 à 45), en ordonnée la perte d'entraînement : Adam (rouge) et SGD avec momentum de Nesterov (vert) descendent tous deux rapidement vers 0.26 à 0.27, tandis qu'AdaGrad (bleu) est encore autour de 0.46 à la 45e époque. À droite, la régression logistique sur des caractéristiques en sac de mots d'IMDB, avec dropout pour les quatre méthodes : les courbes d'Adagrad, RMSProp et Adam descendent toutes vers 0.25 ; SGD Nesterov (rouge) oscille violemment et reste vers 0.35.
Figure 1 de l'article de Kingma et Ba, extraite de la page 6 du PDF, licence arXiv, citation académique.

La régression logistique est un problème convexe ; pas de minimum local à craindre, ce qui en fait un bon terrain pour comparer simplement les optimiseurs. Dans cette série, le taux d'apprentissage décroît en α/t\alpha/\sqrt t, comme le veut la théorie de la section 4.

À gauche, MNIST, où l'on classe directement le vecteur de 784 pixels. Adam et SGD avec momentum font à peu près jeu égal, et tous deux sont bien plus rapides qu'AdaGrad.

C'est le graphique de droite qui montre ce qu'Adam veut prouver. Les auteurs transforment les critiques de films d'IMDB en vecteurs de sac de mots sur les 10 000 mots les plus fréquents ; chaque critique n'utilise que très peu de ces mots, ce qui donne des caractéristiques très creuses. Pour éviter le surapprentissage, 50 % de dropout est appliqué aux caractéristiques. Ici, AdaGrad devance largement SGD, et Adam est aussi rapide qu'AdaGrad. Adam a bien hérité de l'avantage sur les caractéristiques creuses.

Perceptron multicouche

Vient ensuite un réseau entièrement connecté à deux couches de 1000 unités ReLU chacune, toujours sur MNIST. Dans la version avec dropout, la perte d'entraînement d'Adam est inférieure à celles d'AdaGrad, RMSProp, SGD avec momentum et AdaDelta.

Dans la version sans dropout, avec une décroissance des poids L2 à la place, les auteurs comparent aussi Adam à SFO. SFO est une méthode quasi-Newton qui fonctionne par mini-lots et met à jour une information de courbure à chaque pas ; elle est 5 à 10 fois plus lente qu'Adam, et sa mémoire croît linéairement avec le nombre de mini-lots. Adam est plus rapide, qu'on compte en itérations ou en temps réel ; et comme SFO suppose que chaque sous-fonction est déterministe, elle ne converge pas avec du dropout.

Réseau convolutif

Deux courbes de perte d'entraînement d'un réseau convolutif sur CIFAR-10. À gauche, seulement les 3 premières époques : Adam (magenta) et Adam avec dropout (jaune) descendent le plus vite, vers 0.6 à 0.7 à la 3e époque ; AdaGrad (bleu) est vers 1.2. À droite, 45 époques, avec une ordonnée logarithmique : Adam et SGD Nesterov (rouge) plongent vers la 15e époque et finissent entre 4 et 6 fois 10 puissance −4 ; AdaGrad et AdaGrad avec dropout restent entre 0.6 et 0.8 ; Adam et SGD avec dropout sont vers 0.02 à 0.04.
Figure 3 de l'article de Kingma et Ba, extraite de la page 7 du PDF, licence arXiv, citation académique.

Le réseau comporte trois étages de convolution 5×55\times5 suivis d'un max-pooling 3×33\times3 de stride 2, avec 64, 64 et 128 canaux, puis une couche entièrement connectée de 1000 ReLU ; l'entrée est d'abord blanchie, et du dropout est appliqué à la couche d'entrée et à la couche entièrement connectée.

Sur les 3 premières époques, à gauche, Adam et AdaGrad descendent tous deux très vite. Mais à droite, sur 45 époques, AdaGrad s'arrête très tôt, alors qu'Adam et SGD avec momentum descendent jusque sous 10−310^{-3}.

Les auteurs en donnent une explication très concrète. Ils observent qu'après quelques époques, v^t\hat v_t devient si petit qu'il est presque nul ; le dénominateur est dominé par ϵ\epsilon, et le moment d'ordre deux ne décrit plus la géométrie du problème. Sur les réseaux convolutifs, c'est surtout le moment d'ordre un qui agit, en moyennant le bruit des mini-lots. En poussant cette explication plus loin, quand le dénominateur est dominé par ϵ\epsilon, Adam se comporte plutôt comme un SGD avec momentum, ce qui concorde avec la proximité des deux courbes. Les auteurs écrivent aussi, très honnêtement, qu'Adam n'apporte qu'une petite amélioration par rapport à SGD avec momentum ; son avantage est d'ajuster automatiquement l'échelle du taux d'apprentissage pour chaque couche, sans avoir à choisir à la main un taux plus petit pour les couches convolutives.

ϵ\epsilon est présenté comme « une petite constante qui évite la division par zéro », mais dès que v^t\sqrt{\hat v_t} devient du même ordre de grandeur que lui, il participe réellement à la mise à jour.

L'expérience sur la correction du biais

Deux groupes de petits graphiques, chacun de 2 lignes et 3 colonnes, pour l'entraînement d'un autoencodeur variationnel. Le groupe de gauche est pris après 10 époques, celui de droite après 100 époques ; chaque ligne correspond à β1 = 0 ou 0.9, chaque colonne à β2 = 0.99, 0.999 ou 0.9999. Dans chaque petit graphique, l'abscisse est log10(α), de −5 à −1, et l'ordonnée la perte, de 95 à 140. La courbe rouge est avec correction du biais, la verte sans. Pour β2 = 0.99, les deux courbes se superposent presque ; plus β2 est proche de 1, plus tôt la courbe verte sort du graphique. À 10 époques et β1 = 0, les courbes vertes de β2 = 0.999 et 0.9999 sont presque entièrement hors du graphique, et le minimum de la courbe rouge est vers 110. Après 100 époques, le minimum de la courbe rouge est autour de 100 dans les six graphiques.
Figure 4 de l'article de Kingma et Ba, extraite de la page 8 du PDF, licence arXiv, citation académique.

C'est la figure de l'article qui teste la conception le plus directement. Les auteurs entraînent un autoencodeur variationnel (VAE, une seule couche cachée de 500 unités softplus, variable latente gaussienne de dimension 50), en balayant β1∈{0,0.9}\beta_1\in\{0,0.9\}, β2∈{0.99,0.999,0.9999}\beta_2\in\{0.99,0.999,0.9999\}, et α\alpha de 10−510^{-5} à 10−110^{-1}. L'article considère Adam sans correction du biais comme une forme de RMSProp avec momentum.

Dans chaque petit graphique, l'abscisse est le taux d'apprentissage et l'ordonnée la perte ; la courbe rouge est avec correction, la verte sans.

  • Dans la colonne β2=0.99\beta_2=0.99, les courbes rouge et verte se superposent à peu près ; seule la courbe verte de la ligne β1=0\beta_1=0 sort du graphique, au plus grand taux d'apprentissage. Avec ce réglage, le biais dû à l'absence de correction disparaît en une ou deux centaines de pas, et son effet sur l'ensemble de l'entraînement est faible.
  • En allant à droite jusqu'à β2=0.9999\beta_2=0.9999, la courbe verte sort du graphique dès que le taux d'apprentissage devient assez grand. Le cas le plus grave est la première ligne du groupe de gauche, β1=0\beta_1=0, où les courbes vertes de β2=0.999\beta_2=0.999 et 0.99990.9999 sont presque entièrement hors du graphique ; sans correction, le premier pas de ces deux cases vaut respectivement 31.6 α31.6\,\alpha et 100 α100\,\alpha.
  • Dans le groupe de droite, entraîné 100 époques, le minimum de la courbe rouge est autour de 100 dans les six graphiques ; dans la colonne β2=0.9999\beta_2=0.9999, ce minimum se situe à α=10−3\alpha=10^{-3}. Au même taux d'apprentissage, la courbe verte est déjà hors du graphique pour β1=0\beta_1=0, et remonte vers 110 pour β1=0.9\beta_1=0.9 ; la plage de taux d'apprentissage utilisables est bien plus large pour la courbe rouge.

Les auteurs concluent que, pour β2\beta_2 proche de 1, l'absence de correction du biais rend l'entraînement instable, surtout pendant les premières époques ; les meilleurs résultats sont obtenus avec un 1−β21-\beta_2 très petit et la correction du biais. Sur tous les hyperparamètres qu'ils ont balayés, Adam fait au moins aussi bien que RMSProp.

Les auteurs ajoutent une observation. En fin d'entraînement, les unités cachées se spécialisent chacune et les gradients deviennent plus creux ; l'avantage d'un grand β2\beta_2 est alors plus net. Autrement dit, un β2\beta_2 proche de 1 est justement le réglage souhaité, et la correction du biais permet de l'utiliser sans crainte.

Où ajouter ϵ\epsilon

Revenons à la différence entre les deux écritures. L'Algorithm 1 ajoute ϵ\epsilon au v^t\sqrt{\hat v_t} corrigé, alors que l'écriture économe ajoute ϵ^\hat\epsilon au vt\sqrt{v_t} non corrigé. En convertissant l'une dans l'autre, ϵ^=ϵ1−β2t\hat\epsilon=\epsilon\sqrt{1-\beta_2^t} ; l'écart est maximal en début d'entraînement.

Les frameworks ont fait des choix différents. PyTorch suit l'Algorithm 1, avec eps=1e-8 par défaut ; la documentation de Keras précise que son epsilon est le ϵ^\hat\epsilon de l'article, avec une valeur par défaut de 1e-7. Quand on transporte des hyperparamètres d'un framework à l'autre, les deux s'appellent epsilon, mais ce sont deux grandeurs différentes.

Cette constante en apparence anodine est aussi réglée dans l'entraînement des grands modèles. OLMo 2 a abaissé le ϵ\epsilon d'AdamW de 10−510^{-5} à 10−810^{-8}, et rapporte que la norme du gradient en début d'entraînement est ainsi devenue plus basse et plus stable.

Les années sans correction du biais

La dérivation de la section 3 ressemble à un détail, mais elle a eu une vraie suite.

Dans le code officiel de BERT, l'optimiseur BERTAdam a supprimé les deux lignes de correction du biais ; cette écriture a ensuite été copiée dans Hugging Face Transformers (revenu à l'Adam standard seulement en juillet 2019), AllenNLP et d'autres bibliothèques courantes. En 2020, l'article de Zhang et al., « Revisiting Few-sample BERT Fine-tuning », cherche pourquoi l'affinage de BERT sur de petits jeux de données est instable, et découvre que c'est justement l'une des causes principales.

Ils affinent le modèle sur quatre petits jeux de données, RTE, MRPC, STS-B et CoLA, avec 50 graines aléatoires pour chacun. Sans correction du biais, de nombreux affinages n'apprennent rien du tout ; sur RTE, par exemple, 48 % des exécutions ont une précision inférieure à 55 %, proche du hasard. En rétablissant la correction du biais, la variance des résultats diminue fortement.

La cause est la même que dans le graphique des pas plus haut. L'affinage sur ces petits jeux de données compte généralement moins de mille pas, et tout le processus se déroule dans la phase où le biais est le plus fort. Sur MNLI, où l'entraînement compte bien plus de pas, l'écart avec ou sans correction tombe dans la marge d'erreur (précision sur le jeu de validation, 86.0 sans correction, 85.9 avec).

Trois questions ensuite

Adam est vite devenu l'optimiseur par défaut ; dans les années suivantes, les critiques qui le visent suivent à peu près trois lignes :

  1. Convergence. L'erreur de preuve mentionnée plus haut. Avec un exemple où un grand gradient apparaît tous les trois pas, Reddi et al. montrent que vtv_t « oublie » les grands gradients rares, et proposent AMSGrad, qui garde le maximum historique.
  2. Généralisation. En 2017, Wilson et al. constatent sur plusieurs tâches de vision et de langage que la perte d'entraînement d'Adam baisse vite, mais que ses résultats en test sont souvent inférieurs à ceux d'un SGD bien réglé.
  3. Régularisation. Loshchilov et Hutter montrent que, dans Adam, écrire la régularisation L2 dans le gradient n'équivaut pas à appliquer directement une décroissance des poids, et proposent AdamW.

Conclusion

Adam estime séparément, avec deux moyennes mobiles exponentielles, la moyenne du gradient et la moyenne de son carré, et leur rapport donne à chaque paramètre son propre pas ; la division par 1−βt1-\beta^t corrige le biais dû au départ à zéro, et place dès le premier pas la mise à jour à l'échelle de α\alpha. La preuve la plus convaincante de l'article est l'expérience sur le VAE, qui montre que plus β2\beta_2 est proche de 1, plus la correction du biais compte. Les autres expériences ne comparent que la perte d'entraînement, et sur le réseau convolutif, l'écart avec SGD avec momentum est faible. Quant au théorème de convergence, on a montré trois ans plus tard qu'il était faux.

Si vous implémentez Adam vous-même, ou si vous reprenez le code d'entraînement de quelqu'un d'autre, vérifiez d'abord que les deux lignes de correction du biais sont toujours là, puis si ϵ\epsilon est ajouté avant ou après la correction du biais, et quelle est sa valeur. Moins l'entraînement compte de pas, plus ces deux détails pèsent sur le résultat ; et quand vous transportez des hyperparamètres d'un framework à l'autre, rappelez-vous que les deux epsilon ne sont peut-être pas la même grandeur.

En 2025, l'article a reçu le prix Test of Time d'ICLR, sept ans après qu'on a montré que sa preuve de convergence posait problème. Quant à l'ordre des auteurs, c'est toujours celui qu'a décidé la pièce.