Retour à la bibliothèque
arXiv 2024NeurIPS 2024OptimiseursNotes de lecture

Schedule-Free

Le chemin le moins planifié

Article original

The Road Less Scheduled

Auteurs de l’article

Aaron Defazio · Xingyu Alice Yang · Harsh Mehta · Konstantin Mishchenko · Ahmed Khaled · Ashok Cutkosky

Publication
NeurIPS 2024Conférence
Premier dépôt sur arXiv
arXiv:2405.15682
Citer cet article · BibTeX

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

@misc{optimizersschedulefree2024,
  title = {{The Road Less Scheduled}},
  author = {Aaron Defazio and Xingyu Alice Yang and Harsh Mehta and Konstantin Mishchenko and Ahmed Khaled and Ashok Cutkosky},
  year = {2024},
  eprint = {2405.15682},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2405.15682}
}
Sur cette page

Le 1er août 2024, MLCommons publie les résultats de la première compétition AlgoPerf d'algorithmes d'entraînement.

Si vous n'avez jamais entendu parler d'AlgoPerf, c'est une compétition qui porte sur les optimiseurs et sur la procédure d'entraînement elle-même. Modèles, données et matériel (8 V100) sont fixés, et il s'agit d'amener le plus vite possible 8 tâches au score de validation visé ; ces tâches vont de la traduction automatique à la classification d'images, en passant par la reconstruction IRM, la reconnaissance vocale, les graphes moléculaires et la prédiction du taux de clics. La compétition comporte deux catégories. Dans la catégorie à réglage externe, on peut fournir un espace de recherche d'hyperparamètres, dans lequel les organisateurs tirent 5 configurations à essayer ; dans la catégorie auto-réglée, aucune recherche d'hyperparamètres n'est permise en dehors de l'entraînement, et la méthode doit se débrouiller seule avec toutes les tâches en un seul entraînement. La solution la plus courante consiste à utiliser une configuration unique pour tout ; en compensation, le temps d'entraînement maximal est multiplié par 3.

Dans la catégorie auto-réglée, une seule soumission bat la référence des organisateurs ; il s'agit de Schedule Free AdamW, soumis par des chercheurs de Meta et de Samsung, avec un score de 0.8542, contre 0.8194 pour la référence, NAdamW avec échauffement linéaire et décroissance cosinus ; les quatre autres soumissions sont toutes sous 0.4. Ce qui distingue le plus cette méthode, c'est qu'elle se passe entièrement de planification du taux d'apprentissage et n'a pas besoin de connaître à l'avance le nombre d'étapes d'entraînement.

L'article correspondant s'intitule « The Road Less Scheduled » ; le titre reprend le « less traveled » du poème « The Road Not Taken » de Frost, et la conclusion cite effectivement le poème. Le premier auteur est Aaron Defazio, de Meta FAIR, dont les travaux précédents sur D-Adaptation s'attaquaient déjà à la question du réglage du taux d'apprentissage. Le code est publié sur PyPI dès avril sous forme de paquet schedulefree, alors que l'article n'arrive sur arXiv qu'à la fin mai.

Définir le problème

Une planification a besoin d'une ligne d'arrivée

Les planifications du taux d'apprentissage les plus courantes aujourd'hui sont la décroissance cosinus et la décroissance linéaire ; toutes deux exigent de connaître le nombre total d'étapes TT pour pouvoir tracer la courbe. Se tromper sur TT coûte cher. Selon les mesures de l'annexe de Chinchilla, un cycle cosinus plus long de plus de 25 % que le nombre réel d'étapes dégrade nettement le modèle ; et si l'on veut prolonger un entraînement en cours de route, il faut tout replanifier.

La moyenne, excellente en théorie, médiocre en pratique

L'autre voie consiste à renoncer à la planification et à moyenner les paramètres. La moyenne de Polyak–Ruppert est l'approche la plus classique ; SGD avance normalement avec un pas fixe, et l'on maintient à côté la moyenne de tous les points parcourus :

zt+1=zt−γgt,xt+1=(1−ct+1) xt+ct+1 zt+1,ct+1=1t+1z_{t+1} = z_t - \gamma g_t, \qquad x_{t+1} = (1 - c_{t+1})\,x_t + c_{t+1}\,z_{t+1}, \quad c_{t+1} = \frac{1}{t+1}

Avec ct+1=1/(t+1)c_{t+1} = 1/(t+1), xx est exactement la moyenne à poids égaux de z1,…,ztz_1, \dots, z_t. Selon la théorie classique de la convergence, pour un problème convexe et lipschitzien, c'est xx qu'il faut rendre, et non le dernier zz. En pratique, cette moyenne est bien moins bonne que le dernier itéré de SGD, ce que les auteurs présentent comme un consensus officieux du domaine de l'optimisation.

Des travaux théoriques récents montrent en outre qu'une planification à décroissance linéaire suffit à elle seule pour que le dernier itéré atteigne la vitesse optimale dans le pire cas. Planification et moyenne jouent donc en théorie à peu près le même rôle, mais la planification exige de connaître TT. Existe-t-il, se demandent alors les auteurs, une méthode de moyenne qui égale en pratique les planifications sans renoncer aux garanties théoriques ?

Résoudre le problème

Trois suites

Les mises à jour de Schedule-Free SGD sont les équations (3) à (5) :

yt=(1−β) zt+β xtzt+1=zt−γ ∇f(yt,ζt)xt+1=(1−ct+1) xt+ct+1 zt+1,ct+1=1t+1\begin{aligned} y_t &= (1-\beta)\,z_t + \beta\,x_t \\ z_{t+1} &= z_t - \gamma\,\nabla f(y_t, \zeta_t) \\ x_{t+1} &= (1 - c_{t+1})\,x_t + c_{t+1}\,z_{t+1}, \quad c_{t+1} = \frac{1}{t+1} \end{aligned}

On part de z1=x1z_1 = x_1. Les trois suites se répartissent les rôles :

  • zz est la suite de base ; c'est là que l'optimiseur sous-jacent fait ses pas, ici un SGD ordinaire.
  • xx est la suite d'évaluation, la moyenne à poids égaux de zz, et aussi le modèle rendu au final.
  • yy est le point où l'on calcule le gradient, interpolé entre zz et xx.

Par rapport à la moyenne de Polyak–Ruppert, seule la première ligne s'ajoute ; le gradient n'est plus calculé en zz, mais en yy, entre zz et xx.

Deux extrêmes

β\beta détermine de quel côté penche yy. Avec β=0\beta = 0, y=zy = z ; le gradient est calculé en zz, et l'on retrouve la moyenne de Polyak–Ruppert. Avec β=1\beta = 1, y=xy = x ; le gradient est calculé au point moyen, ce qu'on appelle primal averaging, qui offre lui aussi la garantie optimale dans le pire cas, mais converge, de l'avis général, trop lentement pour être utile.

Figure 2 de l'article : perte de test d'un modèle de traduction LSTM sur IWSLT14 ; en abscisse, de 0 à 60 000 étapes, en ordonnée, de 4.0 à 5.5. La courbe orange en tirets de la moyenne de Polyak finit à 4.35, la courbe bleu-vert en tirets-points du primal averaging à 4.44, la courbe rouge de la planification cosinus à 4.23, et la courbe noire de Schedule-Free descend vers 4.35 dès les 10 000 premières étapes, pour finir à 4.18, la plus basse du début à la fin.
Figure 2 de l'article de Defazio et al., extraite de la page 4 du PDF, CC BY 4.0.

Cette figure porte sur un LSTM de traduction allemand-anglais sur IWSLT14. Les deux extrêmes perdent face à une planification cosinus bien réglée ; la moyenne de Polyak finit à 4.35, le primal averaging à 4.44, le cosinus à 4.23. Schedule-Free se place entre les deux, avec β=0.9\beta = 0.9, finit à 4.18, et descend plus vite que tous les autres dès les 10 000 premières étapes.

Selon les auteurs, zz se déplace plus vite que xx, si bien que l'interpolation conserve la convergence rapide de la moyenne de Polyak ; et comme yy est tiré vers xx, le point où l'on calcule le gradient ne s'éloigne pas trop du modèle rendu, ce qui renforce la stabilité.

Une autre forme de momentum

Le rôle de β\beta ressemble beaucoup à celui d'un momentum, et l'article le compare d'ailleurs au momentum classique par moyenne mobile exponentielle (EMA). Quand le gradient gtg_t de l'étape tt entre dans yy, son effet immédiat est (1−β) gt(1-\beta)\,g_t, soit 0.1 gt0.1\,g_t pour β=0.9\beta = 0.9, exactement comme avec un momentum EMA. La différence porte sur les 90 % restants. Le momentum EMA en ajoute l'essentiel au cours des quelque 10 étapes suivantes ; Schedule-Free, lui, les incorpore très lentement, par l'intermédiaire de la moyenne xx.

En théorie, ce momentum n'a pas d'effet secondaire. Le Theorem 1 établit que si FF est convexe, que la perte ff de chaque échantillon est GG-lipschitzienne et que les échantillons sont indépendants et identiquement distribués, alors, avec γ=D/(GT)\gamma = D/(G\sqrt{T}) (DD étant la distance du point de départ à la solution optimale), on a pour tout β\beta dans [0,1][0, 1] :

E[F(xT)−F(x⋆)]≤DGT\mathbb{E}[F(x_T) - F(x_\star)] \le \frac{DG}{\sqrt{T}}

C'est la vitesse optimale pour les problèmes convexes non lisses, constante comprise. Par comparaison, dans le même cadre, un momentum EMA dégrade au contraire la garantie dans le pire cas.

1/(t+1)1/(t+1), ce n'est pas une planification décroissante ?

Arrivé ici, vous vous dites peut-être que le 1/(t+1)1/(t+1) de la mise à jour de xx, c'est tout simplement un taux d'apprentissage décroissant, non ?

En un sens, oui. Avec la Figure 4, les auteurs montrent quelle part de chaque gradient finit par entrer dans yy et dans xx :

Figure 4 de l'article : diagrammes en barres sur quatre lignes et trois colonnes. Les quatre lignes correspondent à la planification à décroissance linéaire, à la moyenne de Polyak, au primal averaging et à Schedule-Free ; les trois colonnes, aux moments où l'entraînement atteint 1/3, 2/3 et la fin. En abscisse, l'étape ; en ordonnée, la part de chaque gradient finalement incorporée. En orange, la part dans la suite d'évaluation x ; dans les lignes Polyak, primal et Schedule-Free, c'est chaque fois un triangle qui descend linéairement de 1 jusqu'à l'instant courant, de même forme que la planification à décroissance linéaire. En bleu, la part dans y, le point où l'on calcule le gradient ; pour la moyenne de Polyak, la zone bleue vaut 1 à chaque instant, le primal averaging n'a aucune partie bleue en plus, et Schedule-Free se situe entre les deux, avec une part des gradients récents plus élevée que pour le primal averaging.
Figure 4 de l'article de Defazio et al., extraite de la page 7 du PDF, CC BY 4.0. Schedule-Free y utilise β=0.6\beta = 0.6.

Commençons par la première ligne. Avec une planification à décroissance linéaire, à 1/3, à 2/3 comme à la fin, chaque gradient est ajouté aux paramètres selon le taux d'apprentissage du moment ; les pas étant de plus en plus petits, on obtient une rampe. Mais l'extrémité de cette rampe est fixée en TT.

Passons à la partie orange des trois lignes suivantes, c'est-à-dire xx. Pour les trois méthodes de moyenne, xx ressemble à chaque instant à une décroissance linéaire qui se termine à l'instant courant tt. C'est pour cela que la moyenne peut remplacer une planification. Elle contient en fait une planification implicite, dont l'extrémité avance avec tt, sans qu'il faille connaître TT à l'avance.

La partie bleue est yy, et c'est là que les trois méthodes diffèrent. Pour la moyenne de Polyak, yy est zz ; chaque gradient compte entièrement, et en fin d'entraînement, les gradients récents pèsent bien plus que sous une planification. Pour le primal averaging, yy est xx ; les gradients récents sont fortement écrasés, et la convergence est lente au début. Schedule-Free se situe entre les deux et renforce un peu le poids des gradients récents.

L'annexe B traduit cela en algèbre. Notons Δt=zt+1−zt\Delta_t = z_{t+1} - z_t un pas de l'optimiseur de base et mt=xt+1−xtm_t = x_{t+1} - x_t ; avec une moyenne à poids égaux et β\beta fixe, le déplacement effectif de yy à chaque étape est :

yt+1−yt=β mt+(1−β) Δty_{t+1} - y_t = \beta\, m_t + (1 - \beta)\,\Delta_t

C'est un terme de momentum, plus (1−β)(1-\beta) fois le pas de base. Si l'on fait varier 1−βt1 - \beta_t dans le temps et qu'on le prend exactement égal à (T−t)/T(T - t)/T, le coefficient du terme de momentum s'annule entièrement, et il ne reste qu'une planification à décroissance linéaire. Schedule-Free choisit un β\beta fixe, et n'a donc pas besoin de TT.

Jusqu'où va la théorie

Le Theorem 1 est en fait un cas particulier du Theorem 2, plus général. Celui-ci admet n'importe quel algorithme d'apprentissage en ligne pour produire zz, des poids de moyenne wtw_t et des coefficients d'interpolation βt\beta_t quelconques, et convertit leur regret en garantie de convergence pour l'optimisation stochastique ; c'est une forme d'online-to-batch conversion. Avec βt=0\beta_t = 0, on retrouve la moyenne de Polyak classique ; avec βt=1\beta_t = 1, le primal averaging (dont des travaux antérieurs de Defazio ont montré l'équivalence avec le momentum heavy-ball) ; avec βt=t/T\beta_t = t/T, la garantie sur le dernier itéré d'une planification à décroissance linéaire. L'annexe C le resserre ensuite en égalité, pour en déduire une vitesse accélérée sur les problèmes lisses.

Il faut aussi préciser les conditions. Toutes ces garanties portent sur des problèmes convexes ; le pas D/(GT)D/(G\sqrt{T}) du Theorem 1 cache encore TT, et le remplacer par D/(Gt)D/(G\sqrt{t}), valable à tout instant, donne de très mauvais résultats en pratique. Dans les faits, on utilise un pas fixe bien plus grand, D/GD/G. Le Theorem 3 montre que, sous une condition vérifiable pendant l'entraînement, un pas aussi grand atteint lui aussi la vitesse optimale ; les auteurs l'ont vérifiée sur tous les problèmes de la section 4.1, où elle est toujours satisfaite, mais ils reconnaissent qu'on ne comprend pas encore entièrement quand un grand pas est utilisable sur les problèmes stochastiques.

Un autre indice vient des fonctions quadratiques. Les auteurs génèrent aléatoirement 10 problèmes quadratiques en dimension 20 et balaient β\beta et γ\gamma. Avec un petit pas, β\beta n'a presque aucun effet ; avec un grand pas, β<1\beta < 1 est la clé de la convergence.

Schedule-Free AdamW

En remplaçant l'optimiseur de base par AdamW, on obtient l'Algorithm 1 :

  1. yt=(1−β1) zt+β1 xty_t = (1 - \beta_1)\,z_t + \beta_1\,x_t, l'interpolation remplace le momentum.
  2. Calculer le gradient gtg_t en yty_t.
  3. vt=β2vt−1+(1−β2) gt2v_t = \beta_2 v_{t-1} + (1 - \beta_2)\,g_t^2.
  4. γt=γ1−β2t min⁡(1,t/Twarmup)\gamma_t = \gamma\sqrt{1 - \beta_2^t}\,\min(1, t/T_{warmup}), qui intègre l'échauffement et la correction du biais au taux d'apprentissage.
  5. zt+1=zt−γt gt/(vt+ϵ)−γtλ ytz_{t+1} = z_t - \gamma_t\, g_t / (\sqrt{v_t} + \epsilon) - \gamma_t \lambda\, y_t.
  6. ct+1=γt2/∑i=1tγi2c_{t+1} = \gamma_t^2 / \sum_{i=1}^{t}\gamma_i^2.
  7. xt+1=(1−ct+1) xt+ct+1 zt+1x_{t+1} = (1 - c_{t+1})\,x_t + c_{t+1}\,z_{t+1}.

Plusieurs points diffèrent d'AdamW.

  • Pas de moment d'ordre un. β1\beta_1 sert à l'interpolation ; il suffit donc de stocker xx, zz et vv, soit autant de mémoire qu'AdamW ; la version SGD consomme elle aussi autant que SGD avec momentum.
  • L'échauffement reste nécessaire. Dans la section 4.4, les auteurs écrivent sans détour que la méthode a encore besoin d'un échauffement du taux d'apprentissage.
  • Les poids de la moyenne suivent le taux d'apprentissage. Avec échauffement, les auteurs utilisent γt2\gamma_t^2 comme poids de moyenne ; les étapes à petit taux d'apprentissage pendant l'échauffement pèsent ainsi moins dans la moyenne, ce qui, d'après eux, améliore fortement les résultats. Une fois l'échauffement terminé, ctc_t décroît de nouveau au rythme de 1/t1/t.
  • La décroissance des poids s'applique en yy. On peut aussi l'appliquer en zz, mais sur des problèmes comme ImageNet et NanoGPT, l'appliquer en yy donne de nettement meilleurs résultats.

Détails d'implémentation

Pendant l'entraînement, le gradient se calcule en yy ; à l'évaluation, il faut xx ; les paramètres du modèle doivent donc basculer de l'un à l'autre. L'implémentation PyTorch officielle ne stocke qu'une copie supplémentaire, zz ; le tampon des paramètres eux-mêmes contient yy pendant l'entraînement et xx pendant l'évaluation. De y=(1−β)z+βxy = (1-\beta)z + \beta x, on tire x=y+(1−1/β)(z−y)x = y + (1 - 1/\beta)(z - y) ; c'est exactement l'interpolation que fait optimizer.eval(), et optimizer.train() revient ensuite à yy.

Il en découle quelques règles d'utilisation. Là où l'on appelle model.train(), il faut aussi appeler optimizer.train(), et là où l'on appelle model.eval(), optimizer.eval() ; avant d'enregistrer un checkpoint, il faut aussi passer en mode eval, sinon c'est yy qui est sauvegardé, et non xx. Si votre code prend en charge les step closures de PyTorch, vous pouvez utiliser la version à closure et vous épargner ces bascules.

BatchNorm est le cas le plus pénible. La running mean et la variance de BN s'accumulent pendant l'entraînement, donc en yy ; une fois passé à xx, les statistiques ne correspondent plus. Le correctif donné par le README officiel consiste à faire passer quelques dizaines de lots d'entraînement avec xx avant l'évaluation, pour réaccumuler les statistiques :

python
model.train()
optimizer.eval()
with torch.no_grad():
    for batch in itertools.islice(train_loader, 50):
        model(batch)
model.eval()

Les couches de normalisation qui ne reposent pas sur des statistiques de lot, comme LayerNorm, n'ont pas ce problème. Le README rappelle aussi que si le framework garde en cache une copie fp16 des paramètres (certains GradScaler le font), il faut la mettre à jour à la main pour que l'évaluation utilise bien xx.

Discussion

Configuration expérimentale

Les auteurs présentent leur étude comme l'une des plus vastes évaluations d'optimiseurs à ce jour, avec 28 problèmes au total, dont 12 régressions logistiques, 9 tâches d'apprentissage profond et 7 tâches d'AlgoPerf. Parmi les tâches d'apprentissage profond, CIFAR-10, CIFAR-100, SVHN et ImageNet utilisent Schedule-Free SGD, tandis qu'IWSLT14, DLRM, fastMRI, l'affinage de MAE et NanoGPT utilisent Schedule-Free AdamW.

Pour la comparaison, les deux camps balaient une grille de taux d'apprentissage et de décroissance des poids, et Schedule-Free choisit en plus son β\beta entre 0.9 et 0.98 ; pour les tâches où l'on utilise habituellement une planification à paliers, celle-ci entre aussi dans la comparaison.

Un seul entraînement pour toute la frontière

Figure 1 de l'article : à gauche, la précision de test d'un ResNet-50 sur ImageNet en fonction des époques ; à droite, la perte de test de GPT-2 124M sur OpenWebText en fonction des étapes. Les fines courbes rouges sont plusieurs planifications cosinus de longueurs différentes, chacune n'atteignant son meilleur niveau qu'à sa propre extrémité ; la courbe noire est un unique entraînement Schedule-Free, qui à chaque instant colle aux extrémités des courbes rouges ou les dépasse.
Figure 1 de l'article de Defazio et al., extraite de la page 2 du PDF, CC BY 4.0.

Les courbes rouges sont des planifications cosinus de longueurs différentes, chacune n'étant à son meilleur qu'à sa propre extrémité ; en reliant ces extrémités, on obtient la frontière « durée d'entraînement contre performance ». La courbe noire, issue d'un seul entraînement, colle pourtant à cette frontière à chaque instant, et côté GPT-2, elle reste même sous les courbes rouges la plupart du temps. Autrement dit, où que l'on arrête l'entraînement, c'est à peu près comme si l'on avait réglé à l'avance une planification cosinus pour cette durée-là.

Neuf tâches d'apprentissage profond

TâcheMétriqueSchedule-FreeMeilleure planification
CIFAR-10Précision96.0395.73
CIFAR-100Précision78.7177.41
SVHNPrécision98.4098.27
ImageNetPrécision76.9076.90
IWSLT14Perte ↓4.184.23
fastMRISSIM0.91120.9110
CriteoPrécision0.79150.7906
Affinage MAEPrécision83.5483.52
GPT-2 124MPerte ↓2.8312.853

D'après les légendes des Figures 2 et 5 de l'article. La colonne « Meilleure planification » correspond à la planification cosinus ou à décroissance linéaire réglée par les auteurs ; ImageNet utilise ResNet-50, et GPT-2 124M correspond à la configuration NanoGPT sur OpenWebText.

Schedule-Free bat la planification réglée sur sept tâches (avec un écart minime pour fastMRI et Criteo), et fait jeu égal sur ImageNet et sur l'affinage de MAE. Le plus grand écart concerne CIFAR-100, avec 1.3 point de plus ; sur ImageNet, les deux obtiennent 76.90 %, contre 76.49 % pour la planification à paliers.

Derrière ces chiffres, quelques réglages méritent qu'on s'y arrête.

  • Des taux d'apprentissage bien plus grands. Sur CIFAR-10, Schedule-Free utilise un taux d'apprentissage de 10, contre 0.2 pour le cosinus ; sur ImageNet, 1.5 contre 0.05 ; sur NanoGPT, 0.005 contre 0.0005. Selon les auteurs, pouvoir utiliser un taux plus grand sans diverger explique peut-être en partie la convergence plus rapide.
  • NanoGPT demande un traitement particulier. Avec β=0.9\beta = 0.9, la perte remonte rapidement en cours d'entraînement ; il faut passer à 0.98 pour stabiliser. L'écrêtage du gradient doit aussi être désactivé, un point que les auteurs jugent crucial.
  • Le gradient ne s'effondre pas. Sur CIFAR-10, avec SGD et une planification cosinus, la perte d'entraînement approche 0 en fin de parcours, et la norme du gradient s'effondre elle aussi vers 0, après quoi le modèle n'apprend presque plus ; Schedule-Free ne présente pas ce phénomène. Les auteurs y voient une raison possible de ses très bons résultats sur CIFAR et SVHN.

L'annexe ajoute les résultats de la moyenne de Polyak et du primal averaging sur les mêmes tâches ; tous deux sont nettement en retrait. Sur ImageNet, ils obtiennent respectivement 72.84 % et 69.78 %, et sur NanoGPT, la perte de la moyenne de Polyak diverge carrément.

AlgoPerf

Les résultats AlgoPerf de l'article sont une comparaison menée par les auteurs eux-mêmes selon les règles de la compétition, face à la référence NAdamW, sur 10 graines aléatoires. La tâche ResNet-50 est exclue, car ni AdamW ni NAdamW n'atteignent la cible. Sur les 7 tâches restantes, Schedule-Free AdamW est plus rapide sur WMT, ViT, fastMRI et OGBG, fait jeu égal sur Conformer et Criteo, et est un peu plus lent sur DeepSpeech. Les auteurs attribuent les résultats de ces deux tâches à BatchNorm ; Conformer et DeepSpeech utilisent BN, et le cadre logiciel de la compétition se prête mal au recalcul des statistiques BN en xx.

L'annexe donne aussi la configuration unique utilisée dans la catégorie auto-réglée : taux d'apprentissage 0.0025, 1−β1=0.11-\beta_1 = 0.1, β2≈0.9955\beta_2 \approx 0.9955, décroissance des poids d'environ 0.081, échauffement de 2 %, et poids de moyenne multipliés en plus par t0.75t^{0.75}.

Les résultats officiels figurent dans l'annonce de MLCommons et dans l'analyse publiée ensuite par les organisateurs à ICLR 2025. Dans la catégorie auto-réglée, Schedule Free AdamW est la seule soumission à battre la référence, avec un temps d'entraînement moyen environ 8 % plus court, et il est le plus rapide sur 4 des 8 tâches de base ; comparé à la référence de la catégorie à réglage externe, il est, sans aucun réglage, environ 10 % plus rapide sur les 7 tâches où les deux ont réussi l'entraînement. La même équipe a aussi engagé une version à 5 configurations dans la catégorie à réglage externe, où elle se classe deuxième (0.7077), derrière les 0.7784 de Distributed Shampoo ; sur les 7 tâches réussies par les deux, Shampoo est environ 24 % plus rapide que Schedule-Free AdamW auto-réglé.

Il y a aussi eu un petit incident. Le prix de la catégorie auto-réglée n'a finalement pas été décerné. Selon l'annonce de MLCommons, les conditions d'attribution n'étaient pas remplies, plusieurs soumissions ayant des affiliations communes avec les présidents du groupe de travail.

Sensibilité au momentum

Figure 9 de l'article : entraînement d'un ResNet-50 sur ImageNet avec Schedule-Free SGD pendant 200 époques, à taux d'apprentissage fixé à 1.5 ; les quatre courbes correspondent à différentes valeurs de momentum. La courbe orange de β = 0.9 est la plus haute et finit à 77.78 % ; 0.95 donne 76.99 %, 0.75 donne 76.60 %, et 0.98, la plus basse, 75.37 %.
Figure 9 de l'article de Defazio et al., extraite de la page 13 du PDF, CC BY 4.0.

Si le β\beta optimal changeait avec la durée d'entraînement, « pas besoin de connaître TT » ne ferait que déplacer le problème de la planification vers le momentum. Les auteurs entraînent sur ImageNet pendant 200 époques, plus longtemps que d'habitude, en balayant quatre valeurs de momentum. Quel que soit le moment où l'on s'arrête pour regarder, le meilleur reste β=0.9\beta = 0.9. La sensibilité au taux d'apprentissage est elle aussi comparable à celle d'une planification cosinus ; ce n'est que pour des entraînements très courts (25 époques au plus) qu'un taux un peu plus grand fait mieux.

Les autres éléments sont toutefois moins optimistes. NanoGPT exige déjà de porter β\beta à 0.98 ; le README officiel indique aussi que pour des entraînements particulièrement longs, il peut falloir monter β\beta à 0.95 ou 0.98. Hägele et al. (NeurIPS 2024) comparent, sur un modèle de langage de 210 millions de paramètres, Schedule-Free AdamW à « un taux d'apprentissage constant suivi d'un refroidissement linéaire final » (proche de WSD). Avec (β1,β2)=(0.9,0.95)(\beta_1, \beta_2) = (0.9, 0.95), il est nettement moins bon, et la perte remonte même en fin d'entraînement ; avec (0.95,0.99)(0.95, 0.99), il se comporte très bien, mais dans les deux configurations, la planification avec refroidissement l'égale ou le dépasse. Ils n'ont pas non plus réglé davantage les hyperparamètres de l'un ou de l'autre.

Limites

Dans leur conclusion, les auteurs indiquent clairement que la principale limite pratique est de devoir refaire le balayage du taux d'apprentissage et de la décroissance des poids, car les valeurs optimales diffèrent de celles utilisées avec une planification. Les autres points de vigilance ont pour la plupart déjà été évoqués.

  • L'échauffement reste nécessaire. La plupart des expériences de l'article le fixent à 5 % de la durée totale d'entraînement, et la configuration AlgoPerf à 2 % ; à strictement parler, la durée d'entraînement intervient donc encore.
  • BN demande de recalculer les statistiques en xx ; il faut basculer de mode entre entraînement et évaluation, et de même avant d'enregistrer un checkpoint.
  • La théorie ne couvre que les problèmes convexes, et il n'existe pas encore de théorie complète sur les conditions d'utilisation d'un grand pas.
  • β\beta est plus sensible pour les longs entraînements de modèles de langage.

Conclusion

Schedule-Free remplace la planification du taux d'apprentissage par trois suites. L'optimiseur de base fait ses pas en zz, xx est la moyenne de zz, et le gradient est calculé en yy, entre les deux. La moyenne contient implicitement une planification à décroissance linéaire dont l'extrémité se déplace en permanence, si bien qu'il n'est pas nécessaire de connaître TT à l'avance ; sur les problèmes convexes, tout β\beta conserve la vitesse optimale dans le pire cas. Sur 9 tâches d'apprentissage profond, il en gagne 7 et fait jeu égal sur 2, et il remporte la première place de la catégorie auto-réglée d'AlgoPerf 2024.

Si vous voulez l'essayer, après avoir changé d'optimiseur, pensez à ajouter les optimizer.train() et optimizer.eval() correspondants à côté de model.train() et model.eval(), et à passer en mode eval avant d'enregistrer un checkpoint ; pour un modèle avec BN, recalculez les statistiques en xx avant l'évaluation. Commencez avec un taux d'apprentissage 1 à 10 fois (AdamW) ou 10 à 50 fois (SGD) plus grand que celui de la version avec planification, prenez d'abord β\beta à 0.9, montez vers 0.95 ou 0.98 pour les entraînements très longs, et gardez l'échauffement.

Le nom a beau être Schedule-Free, la ligne 8 de l'Algorithm 1 contient toujours min⁡(1,t/Twarmup)\min(1, t/T_{warmup}).