Retour à la bibliothèque
arXiv 2024ICLR 2025OptimiseursNotes de lecture

SOAP

Adam pivote

Article original

SOAP: Improving and Stabilizing Shampoo using Adam

Auteurs de l’article

Nikhil Vyas · Depen Morwani · Rosie Zhao …

Afficher les 8 auteurs

Nikhil Vyas · Depen Morwani · Rosie Zhao · Mujin Kwun · Itai Shapira · David Brandfonbrener · Lucas Janson · Sham Kakade

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

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

@misc{optimizerssoap2024,
  title = {{SOAP: Improving and Stabilizing Shampoo using Adam}},
  author = {Nikhil Vyas and Depen Morwani and Rosie Zhao and Mujin Kwun and Itai Shapira and David Brandfonbrener and Lucas Janson and Sham Kakade},
  year = {2024},
  eprint = {2409.11321},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2409.11321}
}
Sur cette page

Avec Shampoo, il faut toujours trancher une question. À quelle fréquence faire l'étape la plus coûteuse ?

À chaque étape, Shampoo met à jour deux matrices de statistiques, LL et RR, mais ce qui multiplie réellement le gradient, ce sont leurs puissances matricielles, qui demandent une décomposition en éléments propres ou un calcul itératif de racines. Cette étape coûte trop cher ; les implémentations ne la font donc que toutes les ff étapes et réutilisent l'ancien résultat entre-temps.

Nikhil Vyas, Depen Morwani et leurs collègues de Harvard ont mesuré l'effet de ce ff. Sur un modèle de langage de 360 millions de paramètres, la perte de test finale de Shampoo est d'environ 2.824 avec f=1f=1, d'environ 2.868 avec f=10f=10 et d'environ 2.932 avec f=100f=100 ; dans le même cadre, AdamW est à environ 2.943. En espaçant les calculs pour économiser, Shampoo rend presque tout son avantage sur AdamW.

En août 2024, Shampoo venait de remporter la catégorie à réglage externe d'AlgoPerf. Cet article veut le rendre un peu moins cher, et un peu plus facile à régler.

Définir le problème

Shampoo maintient deux préconditionneurs, à gauche et à droite, pour une matrice de poids m×nm\times n :

L←L+GG⊤,R←R+G⊤G,W←W−η L−1/4 G R−1/4L \leftarrow L + GG^\top,\qquad R \leftarrow R + G^\top G,\qquad W \leftarrow W - \eta\,L^{-1/4}\,G\,R^{-1/4}

L'exposant d'origine est −1/4-1/4, et les implémentations ultérieures passent le plus souvent à −1/2-1/2. Un Shampoo utilisable en pratique (par exemple DistributedShampoo de Meta) demande, en plus du taux d'apprentissage et du momentum, de fixer le coefficient de moyenne mobile des statistiques, le ϵ\epsilon du calcul des racines de matrices, des exposants distincts pour les paramètres 1D et 2D, l'optimiseur auquel le grafting emprunte la taille du pas, et la fréquence de mise à jour des préconditionneurs.

Il y a deux problèmes. D'abord, dès qu'on espace les mises à jour, les performances baissent, car entre deux décompositions en éléments propres, tout le préconditionneur est figé et ignore comment évolue l'échelle des gradients. Ensuite, il y a trop d'hyperparamètres.

Les auteurs commencent par comprendre ce que fait vraiment Shampoo dans sa base propre. Si on pouvait le séparer en une « partie chère » et une « partie bon marché », on pourrait peut-être calculer la partie chère lentement et mettre à jour la partie bon marché à chaque étape.

Résoudre le problème

Shampoo, c'est Adafactor dans une base tournée

Commençons par idéaliser Shampoo. On prend la puissance 1/21/2 ; LL et RR sont les espérances sur tout le jeu de données, L=E[GG⊤]L=\mathbb E[GG^\top] et R=E[G⊤G]R=\mathbb E[G^\top G] ; et on multiplie par un scalaire de correction fondé sur Trace(L)\mathrm{Trace}(L). La mise à jour devient

W←W−η Tr(L)  L−1/2 G R−1/2W \leftarrow W - \eta\,\sqrt{\mathrm{Tr}(L)}\;L^{-1/2}\,G\,R^{-1/2}

Décomposons LL et RR en éléments propres, L=QLΛQL⊤L = Q_L\Lambda Q_L^\top et R=QRMQR⊤R=Q_R M Q_R^\top, de valeurs propres respectives λ1,…,λm\lambda_1,\dots,\lambda_m et μ1,…,μn\mu_1,\dots,\mu_n. En substituant :

L−1/2 G R−1/2=QL  [Λ−1/2 (QL⊤G QR) M−1/2]  QR⊤L^{-1/2}\,G\,R^{-1/2} = Q_L\;\Big[\Lambda^{-1/2}\,\big(Q_L^\top G\,Q_R\big)\,M^{-1/2}\Big]\;Q_R^\top

Cette ligne se lit en trois temps. On fait d'abord tourner le gradient dans la base propre, G′=QL⊤GQRG' = Q_L^\top G Q_R ; dans ce repère, l'élément (i,j)(i,j) est multiplié par (λiμj)−1/2(\lambda_i\mu_j)^{-1/2} ; enfin, on revient au repère d'origine.

L'étape du milieu est une mise à l'échelle élément par élément, dont le coefficient est « une quantité de la ligne ii » multipliée par « une quantité de la colonne jj », donc de rang 1. C'est exactement ce que fait Adafactor. Pour économiser la mémoire, Adafactor ne stocke pas le moment d'ordre deux de chaque élément, seulement la somme AiA_i de chaque ligne et la somme CjC_j de chaque colonne, puis reconstruit V^ij=AiCj/∑iAi\hat V_{ij} = A_iC_j/\sum_i A_i.

Si l'on exécute Adafactor dans ce repère tourné, que vaut la somme d'une ligne ? Notons uiu_i et vjv_j les ii-ième et jj-ième vecteurs colonnes de QLQ_L et QRQ_R :

Ai=E[∑j(ui⊤G vj)2]=E[∥ui⊤G∥2]=ui⊤ E[GG⊤] ui=λiA_i = \mathbb E\Big[\sum_j \big(u_i^\top G\,v_j\big)^2\Big] = \mathbb E\big[\|u_i^\top G\|^2\big] = u_i^\top\,\mathbb E[GG^\top]\,u_i = \lambda_i

La deuxième égalité utilise le fait que les vjv_j forment une base orthonormée. De même, Cj=μjC_j=\mu_j et ∑iAi=Tr(L)\sum_iA_i=\mathrm{Tr}(L). La mise à l'échelle d'Adafactor pour (i,j)(i,j) est (λiμj/Tr(L))−1/2(\lambda_i\mu_j/\mathrm{Tr}(L))^{-1/2}, exactement la même que celle de Shampoo ci-dessus.

C'est le Claim 1 de l'article. Shampoo avec la puissance 1/21/2 revient à exécuter Adafactor dans la base propre du préconditionneur de Shampoo. La partie chère consiste à trouver la base (décomposition en éléments propres), la partie bon marché à mettre à l'échelle coordonnée par coordonnée dans cette base.

D'Adafactor à Adam

Sous cet angle, on voit d'où vient le problème de fréquence de Shampoo. Ne recalculer que toutes les ff étapes, c'est figer à la fois la « base » et la « mise à l'échelle » ; or la mise à l'échelle n'est qu'une poignée de moyennes mobiles élément par élément, très bon marché à mettre à jour à chaque étape. La base peut changer lentement, mais rien n'oblige la mise à l'échelle à l'attendre.

Tant qu'à mettre à jour la mise à l'échelle à chaque étape, les auteurs remplacent carrément Adafactor par Adam, avec un moment d'ordre deux complet, élément par élément, sans factorisation de rang 1. Voici l'algorithme (Algorithm 3), où ⊙\odot désigne le produit élément par élément :

G′=QL⊤ G QRM←β1M+(1−β1) GM′=QL⊤ M QRV←β2V+(1−β2) G′⊙G′W←W−η  QL (M′V^+ϵ) QR⊤L←β2L+(1−β2) GG⊤,R←β2R+(1−β2) G⊤G\begin{aligned} G' &= Q_L^\top\,G\,Q_R \\ M &\leftarrow \beta_1 M + (1-\beta_1)\,G \\ M' &= Q_L^\top\,M\,Q_R \\ V &\leftarrow \beta_2 V + (1-\beta_2)\,G'\odot G' \\ W &\leftarrow W - \eta\; Q_L\,\Big(\frac{M'}{\sqrt{\hat V}+\epsilon}\Big)\,Q_R^\top \\ L &\leftarrow \beta_2 L + (1-\beta_2)\,GG^\top,\qquad R \leftarrow \beta_2 R + (1-\beta_2)\,G^\top G \end{aligned}

La base n'est mise à jour que toutes les ff étapes, par une étape de la méthode de la puissance itérée suivie d'une décomposition QR, Q←QR(PQ)Q \leftarrow \mathrm{QR}(PQ), où PP est LL ou RR et QQ la base précédente. Seule la première fois utilise une décomposition en éléments propres complète.

Quelques détails méritent qu'on s'y arrête.

Le momentum MM est stocké dans le repère d'origine et projeté à chaque étape. Comme la base change toutes les ff étapes, un momentum stocké dans l'ancien repère ne serait plus aligné sur la nouvelle base au moment du changement. Le moment d'ordre deux VV vit en revanche directement dans le repère tourné et n'est pas tourné lors des changements de base ; le résumé de l'article qualifie cette base de « slowly changing ». Au changement de base, le code officiel réordonne VV selon l'amplitude des valeurs propres, pour qu'une même direction retombe dans la même case.

Les paramètres 1D (biais, poids de LayerNorm) passent directement par AdamW. L'embedding d'entrée et la couche de sortie ont une dimension égale à la taille du vocabulaire ; stocker une matrice de vecteurs propres aussi grande coûterait trop cher, et le QQ de ce côté est donc fixé à l'identité. Quand les deux côtés sont l'identité, SOAP redevient Adam ; c'est pourquoi l'article décrit SOAP comme « Adam dans un espace tourné ».

Les hyperparamètres en moins

Le nom SOAP vient de ShampoO with Adam in the Preconditioner's eigenbasis. Par rapport à AdamW, il n'ajoute qu'un hyperparamètre, la fréquence ff de mise à jour de la base. Par rapport à Shampoo, tout ce qui suit disparaît :

  • l'exposant des puissances de matrices, puisque la mise à l'échelle revient au V\sqrt{V} d'Adam ;
  • le ϵ\epsilon ajouté aux valeurs propres lors du calcul des racines, remplacé par le ϵ\epsilon d'Adam lui-même ;
  • le grafting, puisque Adam fixe la taille du pas coordonnée par coordonnée dans l'espace tourné, sans rien emprunter à un autre optimiseur ;
  • le coefficient de moyenne mobile de LL et RR, qui reprend directement le β2\beta_2 d'Adam.

Le coût

La mémoire est la même que pour DistributedShampoo. Une couche m×nm\times n doit stocker quatre matrices carrées, LL, QLQ_L, RR et QRQ_R, plus le gradient, MM et VV, soit 2m2+2n2+3mn2m^2+2n^2+3mn au total ; AdamW n'a besoin que de 3mn3mn.

À chaque étape, Shampoo multiplie une fois par le préconditionneur à gauche et une fois à droite ; SOAP doit d'abord projeter, puis reprojeter en sens inverse, ce qui ajoute une série de multiplications matricielles à gauche et à droite, d'où un coût par étape légèrement supérieur à celui de Shampoo. En échange, on peut espacer davantage les mises à jour.

Figure 7 (gauche) de l'article : surcoût en temps d'entraînement de SOAP par rapport à AdamW (axe vertical logarithmique) en fonction de la fréquence de préconditionnement (axe horizontal logarithmique). Le surcoût est d'environ 27 % pour une fréquence de 1, 9 % pour 3, 3.7 % pour 10, 2.4 % pour 32 et 2 % pour 100.
Moitié gauche de la Figure 7 de l'article de Vyas et al., extraite de la page 13 du PDF, licence arXiv, citation académique.

Avec un changement de base à chaque étape, le temps d'entraînement augmente d'environ 27 % ; avec f=10f=10, d'environ 3.7 %, et avec f=100f=100, d'environ 2 %. La courbe ne descend pas à 0, car qu'on change de base ou non, chaque étape doit mettre à jour LL et RR en fp32 et faire deux projections. Ces chiffres ont été mesurés sur un seul H100, avec de l'accumulation de gradients pour obtenir de grands lots.

Discussion

Configuration expérimentale

Toutes les expériences portent sur le préentraînement de modèles de langage. Les données sont C4, avec le tokenizer de T5 ; les modèles, construits sur le code d'OLMo, sont de type decoder-only, en trois tailles, 210, 360 et 660 millions de paramètres (hors embedding), de largeur 1024, 1024 et 1408 et de profondeur 12, 24 et 24, avec RoPE et QK LayerNorm, en précision mixte bf16. Les séquences font 1024 tokens et chaque lot compte environ 2 millions de tokens ; le volume d'entraînement est d'environ 20 fois le nombre de paramètres en tokens, soit 3 200 étapes pour 360m et 6 400 étapes pour 660m.

Les trois optimiseurs commencent par un balayage du taux d'apprentissage. Pour AdamW, β1\beta_1 et β2\beta_2 sont aussi balayés sur 360m ; pour Shampoo, avec DistributedShampoo, on balaie en plus ϵ\epsilon, le coefficient de moyenne mobile des statistiques et quatre jeux d'exposants, des balayages qui améliorent tous la perte de moins de 0.004. Pour SOAP, seul le taux d'apprentissage est balayé. La configuration commune comprend β1=0.95\beta_1=0.95, une décroissance des poids découplée de 10−410^{-4}, une z-loss de 10−410^{-4}, et, après l'échauffement, une décroissance en cosinus jusqu'à 0.1 fois la valeur maximale.

Il faut aussi préciser comment on mesure « combien plus vite ». Une planification en cosinus dépend du nombre total d'étapes, et comparer des checkpoints intermédiaires d'un même entraînement serait injuste. Les auteurs relancent donc SOAP en entraînements complets de 0.5, 0.625, 0.75 et 0.875 fois la longueur, ajustent la relation entre perte finale et nombre d'étapes par a+bN−βa+bN^{-\beta}, puis cherchent à quelle longueur SOAP rattrape la perte finale d'AdamW et celle de Shampoo.

Résultats principaux

Figure 1 de l'article : les graphiques de gauche et du centre montrent la perte d'entraînement du modèle de 660 millions de paramètres, avec des lots de 2 millions de tokens et une fréquence de 10, en fonction respectivement du nombre d'étapes et du temps réel normalisé à 1 pour AdamW ; AdamW, en bleu, est le plus haut, Shampoo, en vert, au milieu, SOAP, en orange, le plus bas, et la courbe orange clair est SOAP avec une planification raccourcie, une ligne pointillée marquant l'endroit où elle rejoint le point final d'AdamW. Le graphique de droite montre la perte de test finale du modèle de 360 millions de paramètres en fonction de la fréquence de préconditionnement ; Shampoo, en vert, monte d'environ 2.82 à 2.93 avec la fréquence, SOAP, en orange, ne monte qu'à 2.87, et la ligne pointillée bleue en haut correspond à AdamW.
Figure 1 de l'article de Vyas et al., extraite de la page 3 du PDF, licence arXiv, citation académique.

Commençons par le graphique de gauche. Les courbes bleue, verte et orange correspondent à AdamW, Shampoo et SOAP, tous entraînés sur 6 400 étapes ; à l'arrivée, SOAP est le plus bas. La courbe orange clair est SOAP avec une planification raccourcie, et la ligne pointillée montre qu'il rejoint le point final d'AdamW dès environ 3 600 étapes. Le graphique du centre passe au temps réel en abscisse, et l'écart entre les trois courbes se réduit un peu, parce que chaque étape de SOAP et de Shampoo coûte plus cher que celle d'AdamW.

Selon les estimations d'efficacité de l'article, voici les chiffres pour trois configurations :

ConfigurationRattraper AdamWRattraper Shampoo
360m, 2 millions0.50 / 0.520.75 / 0.74
660m, 2 millions0.565 / 0.620.80 / 0.78
360m, 256 0000.72 / 0.830.875 / 0.90

D'après les graduations indiquées sur la Figure 2 de l'article ; chaque case donne « rapport d'étapes / rapport de temps », et la taille de lot de la première colonne est en tokens. Les rapports de temps face à Shampoo sont convertis pour cette note (sur tout l'entraînement, Shampoo prend respectivement 1.06, 1.12 et 1.11 fois le temps d'AdamW).

Avec de grands lots, SOAP n'a besoin que de 50 % à 57 % des étapes d'AdamW et d'environ 52 % à 62 % de son temps ; face à Shampoo, il économise un peu plus de 20 %. C'est de là que vient la phrase du résumé, « plus de 40 % d'itérations et plus de 35 % de temps réel en moins qu'AdamW, environ 20 % de moins que Shampoo ». En poussant 360m jusqu'à 100 fois son nombre de paramètres en tokens (33.5 milliards), l'avantage de SOAP sur AdamW se maintient.

Ablation sur la fréquence

Les chiffres cités en ouverture viennent de la moitié droite de la Figure 1, reproduite ici.

Moitié droite de la Figure 1 de l'article : perte de test finale du modèle de 360 millions de paramètres, avec des lots de 2 millions de tokens, en fonction de la fréquence de préconditionnement (1, 3, 10, 32, 100). Les triangles verts de Shampoo montent d'environ 2.824 jusqu'à 2.932 ; les triangles orange de SOAP partent d'environ 2.820, sont encore à 2.823 à f=10 et montent à 2.870 à f=100 ; la ligne pointillée bleue en haut est AdamW, à environ 2.943.
Moitié droite de la Figure 1 de l'article de Vyas et al., extraite de la page 3 du PDF, licence arXiv, citation académique. Shampoo en vert, SOAP en orange, AdamW en pointillés bleus.

Les deux courbes restent sous la ligne pointillée d'AdamW ; pour ff de 1 à 100, les deux battent AdamW. À f=1f=1, ils sont presque identiques (2.820 contre 2.824), comme on l'attend si, avec un recalcul à chaque étape, seule la différence entre Adafactor et Adam les sépare. Ensuite, Shampoo monte jusqu'à 2.932, tandis que SOAP est encore à 2.823 à f=10f=10 et ne monte à 2.870 qu'à f=100f=100.

Ces résultats appuient l'explication des auteurs. SOAP est à 2.823 à f=10f=10, et à f=32f=32 il n'est qu'environ 0.018 au-dessus de f=1f=1, encore bien en dessous des 2.868 et 2.898 de Shampoo aux mêmes fréquences ; ce qui dégrade réellement Shampoo, c'est que la mise à l'échelle est figée elle aussi.

Taille de lot

Figure 4 de l'article : à gauche, nombre d'étapes nécessaires au modèle de 360 millions de paramètres pour atteindre une perte de 2.842, en fonction de la taille de lot, les deux axes en échelle logarithmique, AdamW en bleu et SOAP en orange, en trait plein la mesure réelle et en pointillés la mise à l'échelle linéaire idéale ; à droite, perte d'entraînement avec des lots de 256 000 tokens et une fréquence de 80, AdamW en bleu, Shampoo en vert, SOAP en orange.
Figure 4 de l'article de Vyas et al., extraite de la page 10 du PDF, licence arXiv, citation académique.

Idéalement, doubler la taille de lot divise par deux le nombre d'étapes nécessaires pour atteindre une même perte ; c'est la ligne pointillée du graphique de gauche. Plus le trait plein s'en éloigne, plus le surplus de lot est gaspillé. Le trait plein bleu d'AdamW s'en écarte de plus en plus dès 512, et à 2048 il lui faut près du double des étapes idéales ; le trait plein orange de SOAP colle davantage à sa propre ligne pointillée, et les auteurs en concluent que la taille de lot critique de SOAP est plus grande. Par souci d'équité, chaque fois que le lot est divisé par kk, la fréquence est multipliée par kk, pour garder constante la part du surcoût des décompositions en éléments propres.

Le graphique de droite correspond au plus petit lot, 256 000 tokens. SOAP y utilise 25 % d'étapes de moins qu'AdamW et environ 10 % de moins que Shampoo. Comparé au tableau ci-dessus, l'avantage fond nettement avec de petits lots. Les auteurs précisent que ce sont des résultats préliminaires, et que fixer « lot × fréquence » n'est pas forcément le meilleur compromis ; la baisse d'intérêt des méthodes du second ordre avec de petits lots concorde avec les travaux antérieurs. Le README officiel conseille lui aussi d'utiliser des lots aussi grands que possible.

Variantes économes en mémoire, et GaLore

SOAP demande 2m2+2n22m^2+2n^2 de mémoire de plus qu'AdamW. L'article essaie deux façons d'économiser. Exécuter Adafactor au lieu d'Adam dans l'espace tourné économise un mnmn, presque sans changer la perte ; ne tourner que le côté le plus court, l'autre restant à l'identité, augmente un peu plus la perte, mais reste à égalité avec Shampoo ou légèrement meilleur. En combinant les deux, la mémoire tombe à 2min⁡(m,n)2+2mn2\min(m,n)^2+2mn, déjà moins que les 3mn3mn d'AdamW sur un Transformer standard, et cette variante bat toujours AdamW.

La version de rang plein de GaLore ressemble beaucoup à SOAP, avec trois différences principales. La projection de GaLore vient de la SVD du gradient courant, celle de SOAP de la moyenne mobile de GG⊤GG^\top ; GaLore stocke le momentum dans l'espace projeté et ne le ramène pas au changement de base, alors que SOAP le stocke dans l'espace d'origine ; GaLore ne projette que d'un côté. Sur le modèle de 210 millions de paramètres, le meilleur résultat de GaLore est 3.12, mieux qu'AdamW mais moins bien que les 3.10 de Shampoo ; les auteurs en concluent que chacune de ces modifications de SOAP est nécessaire.

L'idée avait en fait déjà été décrite. Dans l'annexe B de l'article Distributed Shampoo de 2020, Anil et al. présentent un algorithme essentiellement équivalent à SOAP sur les couches 2D, sans expériences à l'appui, en indiquant seulement que des expériences non publiées n'avaient montré aucune amélioration. Les auteurs de SOAP le signalent honnêtement dans leurs travaux connexes, et supposent que la différence vient de détails d'implémentation.

Limites

L'article énumère clairement ses propres limites. Le plus grand modèle compte 660 millions de paramètres, deux ordres de grandeur de moins que les grands modèles de l'époque ; les auteurs supposent que les conclusions s'étendent à plus grande échelle, mais cela « remains to be validated ». Seuls des modèles de langage sont testés. Le débit est mesuré sur un seul GPU, et la comparaison d'implémentations distribuées est laissée à plus tard. Les calculs sur LL et RR se font tous en fp32, et la QR de PyTorch ne prend pas en charge de précision plus basse ; le plancher du surcoût ne peut donc pas encore être abaissé.

Une vérification indépendante un an plus tard

En 2025, Wen, Hall, Ma et Liang, de Stanford, publient « Fantastic Pretraining Optimizers and Where to Find Them », qui compare AdamW et dix nouveaux optimiseurs, chacun soigneusement réglé, sur des modèles de 130 millions à 1.2 milliard de paramètres et des volumes de données de 1 à 8 fois Chinchilla.

Sur les modèles de 300 et 520 millions de paramètres, ils mesurent que SOAP est 1.2 à 1.3 fois plus rapide qu'un AdamW bien réglé ; à 1.2 milliard de paramètres, SOAP comme Muon ne sont plus qu'à environ 1.1 fois. Autre constat, quand le rapport données/modèle atteint 8 fois ou plus, SOAP et Kron dépassent Muon, le plus fort quand les données sont peu nombreuses. Leur implémentation de SOAP découpe en outre les poids en blocs et stocke le momentum en bf16 à 1.2 milliard de paramètres, ce qui la distingue légèrement de l'original.

Conclusion

SOAP part d'une équivalence, selon laquelle Shampoo avec la puissance 1/21/2 revient à exécuter Adafactor dans sa base propre. Une fois séparées la base, chère, et la mise à l'échelle, bon marché, la base peut n'être mise à jour que toutes les 10 étapes ou plus, tandis que la mise à l'échelle est mise à jour à chaque étape à la manière d'Adam ; les hyperparamètres se réduisent à une seule fréquence de plus qu'AdamW. Sur des modèles de langage de 360 et 660 millions de paramètres, avec de grands lots, SOAP demande environ moitié moins d'étapes qu'AdamW, et 38 % à 48 % de temps réel en moins.

Pour l'essayer, le soap.py officiel peut être copié tel quel dans votre projet. Partez des réglages du README, β=(0.95,0.95)\beta=(0.95, 0.95) et une fréquence de 10, mesurez précisément de combien chaque étape est plus lente qu'avec AdamW, puis décidez s'il faut espacer davantage. Si la mémoire est juste, la rotation d'un seul côté et la variante Adafactor sont deux replis validés par l'article.

Dans le corps de l'article, Fantastic cite nommément SOAP comme l'un des rares articles à avoir balayé indépendamment les hyperparamètres de sa référence, et dont l'accélération annoncée est la plus proche de leurs propres mesures. Pour un article d'optimiseur, ce genre de compliment est rare.