Retour à la bibliothèque
arXiv 2019ICLR 2020OptimiseursNotes de lecture

LAMB

LARS déguisé en agneau

Article original

Large Batch Optimization for Deep Learning: Training BERT in 76 minutes

Auteurs de l’article

Yang You · Jing Li · Sashank Reddi …

Afficher les 10 auteurs

Yang You · Jing Li · Sashank Reddi · Jonathan Hseu · Sanjiv Kumar · Srinadh Bhojanapalli · Xiaodan Song · James Demmel · Kurt Keutzer · Cho-Jui Hsieh

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

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

@misc{optimizerslamb2019,
  title = {{Large Batch Optimization for Deep Learning: Training BERT in 76 minutes}},
  author = {Yang You and Jing Li and Sashank Reddi and Jonathan Hseu and Sanjiv Kumar and Srinadh Bhojanapalli and Xiaodan Song and James Demmel and Kurt Keutzer and Cho-Jui Hsieh},
  year = {2019},
  eprint = {1904.00962},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1904.00962}
}
Sur cette page

Soumis à ICLR 2018, LARS a été refusé. La décision des relecteurs est très précise ; elle relève que la méthode n'est validée que sur une seule tâche, ImageNet, qu'elle ajoute des hyperparamètres, et que la mise à l'échelle couche par couche du taux d'apprentissage n'a aucun fondement théorique.

Un an plus tard, Yang You, premier auteur de LARS, devenu chercheur étudiant chez Google Brain, revient avec un article qui répond à chacune de ces objections. La nouvelle tâche est BERT, le nouvel optimiseur s'appelle LAMB, et deux théorèmes de convergence complètent le tout. Le titre ne fait pas dans la modestie et affiche directement « 76 minutes ».

Définir le problème

Le préentraînement de BERT-Large se fait en deux phases, d'abord 900 000 étapes avec des séquences de longueur 128, puis les 100 000 dernières étapes avec des séquences de longueur 512, le batch étant de 512 dans les deux cas. Sur 16 TPUv3, cela prend environ 3 jours (81.4 heures selon la mesure de l'article).

Pour réduire ce temps, le plus direct est d'ajouter des machines et d'agrandir le batch, mais les deux voies toutes tracées sont des impasses. La première est LARS, qui ramène l'entraînement de ResNet-50 sur ImageNet à quelques minutes, mais ne fonctionne pas sur BERT :

Batch5124K8K16K32K
LARS90.7290.5490.5589.59diverge
LAMB91.7591.1491.2691.3591.48

D'après la Table 2 de l'article ; F1 sur le jeu de développement de SQuAD v1.1, sélection de colonnes ; le F1 du BERT-Large officiel est de 90.395.

La seconde est AdamW, déjà utilisé par BERT. Les auteurs essaient trois réglages, les valeurs par défaut de BERT, les hyperparamètres de LAMB repris tels quels, et un réglage refait par leurs soins. À 16K, le F1 n'atteint que 88.1, en deçà de l'objectif de 90.4 ; dans le tableau de réglage de l'annexe, toutes les configurations à échauffement plus court divergent. Avec un batch mixte de 64K pour la première phase et de 32K pour la seconde, « même après un long réglage, impossible d'obtenir un résultat raisonnable ».

Peut-on garder l'avantage de l'adaptation élément par élément d'Adam, y ajouter le rapport de confiance couche par couche de LARS, et faire tenir BERT jusqu'à 32K ? C'est la question à laquelle répond cet article.

Résoudre le problème

Une transformation en deux étapes

Les auteurs commencent par abstraire LARS en une stratégie générale, applicable à n'importe quel optimiseur de base. Si la mise à jour de chaque couche par l'algorithme de base (SGD ou Adam) est xt+1=xt+ηtutx_{t+1} = x_t + \eta_t u_t, on la modifie ainsi :

  1. Normaliser d'abord la mise à jour de chaque couche à une longueur unité : ut/∥ut∥u_t / \|u_t\|.
  2. Multiplier le taux d'apprentissage, couche par couche, par ϕ(∥xt∥)\phi(\|x_t\|), où ϕ\phi est une fonction de la norme des poids.

Avec SGD comme base, la mise à jour de la couche ii devient

xt+1(i)=xt(i)−ηt ϕ(∥xt(i)∥)∥gt(i)∥ gt(i)x_{t+1}^{(i)} = x_t^{(i)} - \eta_t \,\frac{\phi(\|x_t^{(i)}\|)}{\|g_t^{(i)}\|}\, g_t^{(i)}

La première étape ne garde que la direction et jette la taille du gradient. La mise à jour devient biaisée, mais selon les auteurs, avec un très grand batch, la direction du gradient est globalement fiable et le biais reste faible ; l'avantage est qu'un gradient soudain énorme ou minuscule ne se répercute plus directement sur la mise à jour. La seconde étape aligne l'ordre de grandeur de la mise à jour sur celui des poids. En pratique, les auteurs utilisent

ϕ(z)=min⁡{max⁡{z,γl},γu}\phi(z) = \min\{\max\{z, \gamma_l\}, \gamma_u\}

c'est-à-dire qu'ils bornent la norme des poids entre une limite basse et une limite haute, pour éviter qu'une couche fraîchement initialisée, de norme très petite ou très grande, reçoive un rapport aberrant. L'article ne précise pas les valeurs réellement données à γl\gamma_l et γu\gamma_u.

Si ϕ(z)=z\phi(z) = z, le taux d'apprentissage global est multiplié par ∥xt(i)∥/∥gt(i)∥\|x_t^{(i)}\|/\|g_t^{(i)}\|, exactement le trust ratio de LARS. Les auteurs interprètent en outre ce rapport comme une estimation grossière de l'inverse de la constante de Lipschitz du gradient de la couche ; les couches à forte courbure font automatiquement de petits pas.

LAMB

En prenant Adam comme base, on obtient LAMB (Layer-wise Adaptive Moments optimizer for Batch training). À chaque étape, on calcule d'abord, comme dans Adam, les moments d'ordre un et deux, avec correction du biais :

mt=β1mt−1+(1−β1) gt,m^t=mt/(1−β1t)vt=β2vt−1+(1−β2) gt2,v^t=vt/(1−β2t)\begin{aligned} m_t &= \beta_1 m_{t-1} + (1-\beta_1)\, g_t, & \hat m_t &= m_t/(1-\beta_1^t) \\ v_t &= \beta_2 v_{t-1} + (1-\beta_2)\, g_t^2, & \hat v_t &= v_t/(1-\beta_2^t) \end{aligned} rt=m^tv^t+ϵr_t = \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon}

On ajoute ensuite la décroissance des poids découplée, puis on applique à toute la couche la mise à l'échelle par le trust ratio :

xt+1(i)=xt(i)−ηt ϕ(∥xt(i)∥)∥rt(i)+λxt(i)∥(rt(i)+λxt(i))x_{t+1}^{(i)} = x_t^{(i)} - \eta_t \, \frac{\phi(\|x_t^{(i)}\|)}{\|r_t^{(i)} + \lambda x_t^{(i)}\|} \left(r_t^{(i)} + \lambda x_t^{(i)}\right)

Il y a ici deux niveaux d'adaptation. v^t\sqrt{\hat v_t} ajuste le pas élément par élément à l'intérieur de la couche, et le trust ratio égalise, d'une couche à l'autre, le rapport entre la mise à jour et les poids. Placer la décroissance des poids à l'intérieur de la norme est un choix délibéré des auteurs ; le terme de décroissance et la mise à jour d'Adam déterminent ensemble la distance parcourue par la couche. Les valeurs par défaut sont β1=0.9\beta_1=0.9, β2=0.999\beta_2=0.999, ϵ=10−6\epsilon=10^{-6} et λ=0.01\lambda=0.01, avec pour taux d'apprentissage la décroissance linéaire d'origine de BERT, η0(1−t/T)\eta_0(1-t/T). Les auteurs notent aussi qu'avec β1=β2=0\beta_1=\beta_2=0, LAMB dégénère en signSGD, avec un taux d'apprentissage multiplié par la racine carrée de la dimension de la couche.

Figure 12 de l'article : diagramme en barres du trust ratio de chacune des 52 couches à la 50e itération de l'entraînement d'un ResNet-50 sur ImageNet avec LAMB. La couche 0 est la plus haute, à environ 0.10 ; les autres se situent pour la plupart entre 0.006 et 0.065, globalement de plus en plus bas vers les dernières couches, et les couches d'un même bloc résiduel alternent régulièrement entre valeurs hautes et basses.
Figure 12 de l'article de You et al., extraite de la page 21 du PDF, licence arXiv, citation académique.

Cette figure d'annexe relève le trust ratio de chaque couche de ResNet-50 à la 50e itération d'entraînement. En abscisse, le numéro de la couche ; en ordonnée, le rapport. La première couche est la plus haute, vers 0.10 ; les couches les plus basses, en fin de réseau, ne sont qu'autour de 0.006, soit un écart de plus d'un facteur dix, et les couches d'un même bloc résiduel alternent entre haut et bas. Les auteurs y voient le trust ratio en train d'accélérer « les couches qui apprennent lentement ».

Analyse de convergence

C'est la partie qu'on avait reproché à LARS de ne pas fournir. Dans un cadre d'optimisation stochastique non convexe avec régularisation L2L_2, les auteurs supposent la perte LiL_i-smooth par rapport à la couche ii, et définissent L∞=max⁡iLiL_\infty = \max_i L_i (la couche la plus raide) et Lavg=∑iLi/hL_{avg} = \sum_i L_i / h (la moyenne sur les hh couches).

Le point de comparaison est SGD. Avec une taille de batch bb égale au nombre total d'étapes TT et un taux d'apprentissage bien choisi, la borne de SGD dépend de L∞L_\infty. L'intuition est la même que pour le tableau des rapports par couche de LARS ; avec un seul taux d'apprentissage pour tout le réseau, on doit s'aligner sur la couche la plus raide.

Les bornes de LARS (Theorem 2) et de LAMB (Theorem 3) font intervenir LavgL_{avg} à la place, sous plusieurs conditions :

  • b=Tb = T, c'est-à-dire un batch du même ordre que le nombre total d'étapes ;
  • l'analyse ne traite que le cas β1=0\beta_1 = 0 et décroissance des poids λ=0\lambda = 0 ;
  • ϕ\phi admet des bornes positives αl≤ϕ≤αu\alpha_l \le \phi \le \alpha_u ;
  • la borne de LAMB en LavgL_{avg} exige en plus β2=0\beta_2 = 0 et le même nombre de paramètres dans chaque couche ; pour β2>0\beta_2 > 0, les auteurs n'obtiennent qu'une borne moins bonne, tout en disant croire qu'en pratique, le cas β2>0\beta_2 > 0 devrait se comporter mieux que le cas β2=0\beta_2 = 0, et laissent la question à de futurs travaux.

Les critères de convergence diffèrent aussi ; SGD mesure le carré de la norme du gradient, LARS le carré de la somme des normes du gradient par couche. Les auteurs expliquent en annexe que la borne de LARS ne bat celle de SGD que si le gradient est « plus dense » que la courbure et le bruit ; sinon, c'est la borne supérieure de SGD qui est meilleure. Autrement dit, ces deux théorèmes montrent que la mise à l'échelle par couche est avantageuse sous certaines conditions, et les β1=0.9\beta_1 = 0.9 et β2=0.999\beta_2 = 0.999 utilisés dans les expériences sortent du champ des théorèmes.

Discussion

De 3 jours à 76 minutes

Les expériences BERT reprennent les données officielles (2.5 milliards de mots de Wikipedia et 800 millions de mots de BooksCorpus) et la procédure d'affinage sur SQuAD v1.1, dont les réglages restent inchangés. LAMB ne règle qu'un taux d'apprentissage, et ne le règle même pas à nouveau quand le batch grandit ; il le met à l'échelle selon la règle de la racine carrée, 6.25×10−46.25\times10^{-4} pour un batch de 512, multiplié par 2\sqrt 2 à chaque doublement, jusqu'à 5×10−35\times10^{-3} à 32K ; la proportion d'échauffement passe de 1/320 à 1/5 du nombre total d'étapes. Le nombre d'époques étant fixe, plus le batch est grand, moins il y a d'étapes.

BatchÉtapesTPUv3DuréeF1
512 (officiel)1000k1681.4 h90.395
5121000k1682.8 h91.752
4K125k128693.6 m91.137
16K31 250512200.0 m91.345
32K15 6251024101.2 m91.475
64K/32K8 599102476.19 m90.584

D'après la Table 1 de l'article, sélection de lignes.

32K est le maximum que peut contenir un Pod TPUv3 complet (1 024 puces) avec des séquences de longueur 512. Sur les 15 625 étapes, 14 063 se font en longueur 128 et 1 562 en longueur 512, en 100 minutes environ ; 64 fois plus de ressources donnent une accélération de 49.1 fois.

Pour aller plus vite encore, les auteurs utilisent un batch différent dans chaque phase. Dans la première, les séquences sont courtes et le batch peut monter jusqu'à 131 072, mais au-delà de 65 536, on ne gagne plus rien en vitesse ; la première phase utilise donc 65 536, et la seconde revient à 32 768. Passer d'un grand batch à un plus petit met l'entraînement sens dessus dessous ; les auteurs y remédient en refaisant, au début de la seconde phase, un échauffement du taux d'apprentissage depuis 0, avant la décroissance habituelle. Au total, 8 599 étapes et 76 minutes.

Figure 8 de l'article : facteur d'accélération selon le nombre de TPU, en noir l'accélération linéaire idéale, en bleu le résultat réel. De 16 à 128 puces, les deux sont proches ; à 512 puces, environ 25 contre 32 ; à 1024 puces, environ 49 contre 64 ; tout à droite, la barre bleue de 1024-mixed atteint environ 65, légèrement au-dessus des 64 idéaux.
Figure 8 de l'article de You et al., extraite de la page 20 du PDF, licence arXiv, citation académique.

Les barres noires représentent l'accélération linéaire idéale, les bleues les mesures. Avec 1 024 puces et un batch de 32K, on n'obtient qu'un facteur 49 ; les auteurs attribuent l'écart au volume de communication de la synchronisation des gradients, BERT ayant 300 millions de paramètres contre 25 millions seulement pour ResNet-50. Le batch mixte, tout à droite, atteint un facteur 65.2 ; dépasser la valeur idéale n'a rien d'étonnant, puisqu'il fait presque moitié moins d'étapes qu'avec un batch fixe de 32K.

Le chiffre de 76 minutes doit se lire avec le F1. Les 90.584 du batch mixte dépassent les 90.395 du BERT officiel, mais c'est le score le plus bas de toutes les configurations de LAMB, les autres se situant entre 91.1 et 91.9.

ImageNet

Côté ResNet-50, les auteurs veulent montrer qu'une méthode adaptative comme LAMB peut elle aussi atteindre le niveau de SGD avec momentum. Avec un batch de 16K et 90 époques, AdaGrad, Adam et AdamW, même soigneusement réglés, n'obtiennent que 55.38 %, 66.04 % et 67.27 % ; avec l'échauffement et la décroissance par paliers de Goyal et al., ils n'atteignent que 72.01 %, 73.48 % et 73.07 %. Le SGD avec momentum rapporté par Goyal et al. obtient 75.20 %, LAMB 76.66 %. De 512 à 32K, sans aucun nouveau réglage, le top-1 de LAMB reste entre 76.42 % et 77.11 %, le minimum étant à 32K ; face à LARS, à 32K, on a 76.4 % contre 76.3 %.

Reality Check

Deux ans plus tard, Nado et ses collègues de Google refont les expériences BERT dans « A Large Batch Optimizer Reality Check », dont le sous-titre donne directement la conclusion, à savoir que les optimiseurs génériques traditionnels suffisent pour toutes les tailles de batch.

Ils reprennent la même configuration en deux phases et le même nombre d'étapes, en remplaçant seulement LAMB par Adam, soigneusement réglé à nouveau :

BatchÉtapesLAMBAdam
32K15 62591.4891.58
64K/32K8 59990.5891.04
64K7 818–90.46

D'après la Table 3 de Nado et al. ; F1 sur le jeu de développement de SQuAD v1.1 ; les valeurs de LAMB sont reprises de l'article LAMB.

À 32K, la perte de préentraînement d'Adam est aussi plus basse, 1.277 contre 1.342. Avec 64K du début à la fin, Adam atteint 90.46 en 7 818 étapes, soit plus de sept cents étapes de moins que le batch mixte de LAMB.

Qu'est-ce qui distingue les conditions des deux camps ? Nado et al. pointent deux détails d'implémentation qui ont pu désavantager l'Adam de l'article LAMB. D'abord, l'Adam du code open source de BERT n'a pas de correction du biais, alors que celle-ci a en elle-même un effet d'échauffement. Ensuite, la planification du taux d'apprentissage de BERT présente une falaise au début de la décroissance, celle-ci étant appliquée par erreur dès l'échauffement ; ce code se retrouve dans plus de 3 000 copies du programme d'entraînement de BERT sur GitHub. L'effort de réglage n'est pas non plus le même. Pour chacune des deux phases de préentraînement, Nado et al. recherchent séparément le taux d'apprentissage, β1\beta_1, β2\beta_2, l'exposant de la courbe d'échauffement et la décroissance des poids, avec environ 30 essais par phase, et 130 pour la seconde phase à 64K, ϵ\epsilon étant fixé à 10−1110^{-11}. En sens inverse, ils n'ont pas relancé LAMB, et comparent des nombres d'étapes, pas des temps réels mesurés ; leur argument est qu'Adam est plus simple à calculer, et qu'à nombre d'étapes égal, il ne sera pas plus lent sur un système optimisé.

Sur ResNet-50 (batch de 32 768, 6 000 étapes), ils appliquent aussi LAMB tel quel à tous les paramètres, et n'obtiennent que 27.3 % ; en confiant les paramètres de BatchNorm et les biais à Adam, on remonte à 76.3 %. La normalisation couche par couche peut donc réellement nuire à certains paramètres, et l'article LAMB ne dit pas comment ceux-ci sont traités. Ils écrivent dans leur discussion que les règles de mise à jour de LARS et de LAMB n'ont pas plus de lien avec les « grands batchs » que celles du momentum ou d'Adam ; les hypothèses sur lesquelles reposent les bornes de convergence (pas de momentum, β2=0\beta_2 = 0) sont très éloignées de la pratique, et l'on peut démontrer des bornes similaires pour Adam.

Un autre éclairage vient de MoCo v3. En 2021, Chen, Xie et He essaient aussi LAMB pour entraîner ViT de façon auto-supervisée ; avec ViT-B/16 et un batch de 4096, LAMB atteint 72.5 % avec un taux d'apprentissage de 5×10−45\times10^{-4}, un peu mieux qu'AdamW ; à 6×10−46\times10^{-4} et 8×10−48\times10^{-4}, la précision chute de 1.6 et de 6.0 points. Les auteurs le jugent trop sensible au taux d'apprentissage pour s'en servir commodément dans des ablations.

Conclusion

Pour passer de 81 heures à 76 minutes, LAMB transpose à Adam le rapport de confiance couche par couche de LARS, et y ajoute 1 024 TPUv3, un batch mixte et un nouvel échauffement en seconde phase ; il apporte aussi les théorèmes de convergence qui manquaient à LARS. Les vérifications ultérieures montrent que, pour peu que l'implémentation d'Adam soit sans défaut et chaque phase sérieusement réglée, Adam ne fait pas moins bien que LAMB à batch et nombre d'étapes égaux ; et les conditions de validité des théorèmes sont très éloignées de l'entraînement réel.

Avant de passer à LAMB, vérifiez quelle version votre bibliothèque implémente, s'il y a ou non correction du biais, ϕ\phi et normalisation préalable du gradient, et si LayerNorm et les biais sont exclus du trust ratio. Ensuite, au même nombre d'étapes, réglez sérieusement un Adam avec correction du biais comme point de comparaison.

Le record des 76 minutes a finalement été égalé, en moins d'étapes, par Adam, celui-là même que LAMB voulait remplacer.