Adam (Optimiseur)

Adam, abréviation de Adaptive Moment Estimation, est un algorithme d'optimisation itératif largement utilisé pour l'entraînement des réseaux de neurones et d'autres modèles de Machine learning. Il a été introduit par Diederik P. Kingma et Jimmy Ba dans un article de 2014 intitulé « Adam: A Method for Stochastic Optimization ». Adam combine les avantages de deux autres extensions de la descente de gradient stochastique : les taux d'apprentissage adaptatifs (comme dans AdaGrad) et l'élan (comme dans RMSProp). Il calcule des taux d'apprentissage adaptatifs individuels pour chaque paramètre à partir d'estimations des premier et deuxième moments des gradients, ce qui le rend bien adapté aux problèmes avec de grands ensembles de données et des espaces de paramètres de haute dimension.

L'algorithme est une variante de la descente de gradient stochastique (SGD), qui est elle-même une méthode itérative pour minimiser une fonction objectif en remplaçant le gradient réel par une estimation provenant d'un sous-ensemble de données sélectionné aléatoirement. Adam est devenu un optimiseur par défaut dans les frameworks de Deep learning et est utilisé de manière intensive pour l'entraînement des modèles Transformer (architecture), y compris les grands modèles de langage.

Algorithme

Adam maintient deux moyennes mobiles par paramètre : le premier moment (moyenne) des gradients et le deuxième moment (variance non centrée) des gradients. À chaque itération \(t\), étant donné le gradient \(g_t\) de la perte par rapport aux paramètres, les mises à jour sont calculées comme suit :

1. Mise à jour de l'estimation biaisée du premier moment : \(m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t\)
2. Mise à jour de l'estimation biaisée du deuxième moment : \(v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2\)
3. Calcul des estimations corrigées du biais : \(\hat{m}_t = m_t / (1 - \beta_1^t)\) et \(\hat{v}_t = v_t / (1 - \beta_2^t)\)
4. Mise à jour des paramètres : \(\theta_t = \theta_{t-1} - \alpha \hat{m}_t / (\sqrt{\hat{v}_t} + \epsilon)\)

Ici, \(\alpha\) est le taux d'apprentissage (taille de pas), \(\beta_1\) et \(\beta_2\) sont les taux de décroissance exponentielle pour les estimations des moments (généralement 0,9 et 0,999), et \(\epsilon\) est une petite constante (par exemple, \(10^{-8}\)) pour éviter la division par zéro. L'étape de correction du biais est cruciale dans les premières itérations lorsque les estimations des moments sont initialisées à zéro, car elle contrecarre le biais vers zéro.

Correction du biais

Comme \(m_t\) et \(v_t\) sont tous deux initialisés comme des vecteurs nuls, les premières itérations produisent des estimations biaisées vers zéro. Adam traite cela en divisant les estimations des moments par \((1 - \beta_1^t)\) et \((1 - \beta_2^t)\), respectivement. Cette correction devient moins significative à mesure que \(t\) augmente, car les dénominateurs se rapprochent de 1. La correction du biais est une caractéristique clé qui distingue Adam des méthodes adaptatives antérieures et contribue à son comportement de convergence stable.

Hyperparamètres

Adam introduit plusieurs hyperparamètres au-delà du taux d'apprentissage :

• Taux d'apprentissage (\(\alpha\)) : Contrôle la taille de pas. La valeur par défaut courante est 0,001.
• \(\beta_1\) : Taux de décroissance exponentielle pour l'estimation du premier moment. Défaut 0,9.
• \(\beta_2\) : Taux de décroissance exponentielle pour l'estimation du deuxième moment. Défaut 0,999.
• \(\epsilon\) : Petite constante pour la stabilité numérique. Défaut \(10^{-8}\).

En pratique, les valeurs par défaut fonctionnent bien pour de nombreuses tâches, mais le réglage du taux d'apprentissage est souvent nécessaire. Certaines implémentations prennent également en charge des programmes de taux d'apprentissage, tels que l'échauffement et la décroissance, qui sont courants dans l'entraînement des modèles Transformer (architecture).

Variantes et extensions

Plusieurs variantes d'Adam ont été proposées pour traiter des limitations spécifiques :

• AdamW : Découple la décroissance du poids de la mise à jour du gradient, en l'appliquant directement aux paramètres. Cela améliore la généralisation et est maintenant standard dans de nombreuses bibliothèques de Deep learning.
• Nadam : Combine Adam avec l'élan de Nesterov, ce qui peut accélérer la convergence.
• AMSGrad : Modifie l'estimation du deuxième moment pour garantir que le taux d'apprentissage n'augmente pas, traitant les problèmes de convergence dans certains contextes.
• Adamax : Utilise la norme infinie pour le deuxième moment, le rendant plus robuste aux grands gradients.
• RAdam : Corrige la variance du taux d'apprentissage adaptatif, réduisant le besoin d'échauffement.

Ces variantes sont utilisées dans des contextes spécifiques, mais l'Adam original reste largement utilisé.

Applications

Adam est utilisé dans de nombreux domaines de l'Artificial intelligence et du Machine learning. C'est l'optimiseur par défaut dans de nombreux frameworks, y compris TensorFlow et PyTorch. Il a été appliqué à l'entraînement des réseaux de neurones pour la classification d'images, le traitement du langage naturel, la reconnaissance vocale et l'apprentissage par renforcement. En particulier, Adam est l'optimiseur de choix pour l'entraînement des modèles basés sur Transformer (architecture), tels que les grands modèles de langage développés par des organisations comme OpenAI, Anthropic et Google DeepMind.

La popularité d'Adam provient de sa robustesse aux réglages des hyperparamètres et de sa capacité à gérer les gradients épars et les données bruitées. Il est également efficace en mémoire, ne nécessitant que deux variables supplémentaires par paramètre.

Propriétés théoriques

Adam ne converge pas toujours vers un minimum global, en particulier pour des objectifs non convexes, mais il a été démontré qu'il converge vers un point critique sous certaines conditions. L'analyse de convergence d'Adam est plus complexe que celle de la SGD simple en raison des taux d'apprentissage adaptatifs. Certaines études ont montré qu'Adam peut échouer à converger dans certains contextes convexes, ce qui a motivé le développement d'AMSGrad et d'autres correctifs.

Empiriquement, Adam atteint souvent une convergence plus rapide que la SGD dans les premières étapes de l'entraînement, mais peut généraliser légèrement moins bien que la SGD avec élan dans certaines tâches. Cela a conduit à des approches hybrides, comme le passage d'Adam à la SGD pendant l'entraînement.

Comparaison avec la descente de gradient stochastique

La descente de gradient stochastique (SGD) met à jour les paramètres en utilisant un seul échantillon ou un mini-lot, avec un taux d'apprentissage fixe ou décroissant. Adam adapte le taux d'apprentissage par paramètre en fonction de l'historique des gradients. Cela rend Adam moins sensible au choix du taux d'apprentissage et nécessite souvent moins de réglage. Cependant, la SGD avec élan peut parfois atteindre de meilleures performances finales, surtout avec des programmes de taux d'apprentissage soigneusement réglés.

Adam diffère également de la SGD en ce qu'il normalise le gradient par la racine carrée du deuxième moment, ce qui peut conduire à des mises à jour plus stables en présence de gradients grands ou petits.

Considérations pratiques

Lors de l'utilisation d'Adam, il est courant de définir le taux d'apprentissage à 0,001 et les bêtas à leurs valeurs par défaut. Pour l'entraînement à grande échelle, comme avec les grands modèles de langage, des programmes de taux d'apprentissage avec échauffement sont souvent employés. La décroissance du poids, comme dans AdamW, est recommandée pour la régularisation.

L'utilisation de la mémoire est une considération : Adam stocke deux valeurs supplémentaires par paramètre, ce qui peut être significatif pour les modèles avec des milliards de paramètres. Cela a motivé la recherche sur des optimiseurs efficaces en mémoire, tels qu'Adafactor, qui approxime le deuxième moment avec des facteurs de rang inférieur.

Voir aussi

• stochastic-gradient-descent
• Deep learning
• Neural network
• Transformer (architecture)

Références

• Kingma, D. P., & Ba, J. (2014). Adam: A Method for Stochastic Optimization. arXiv:1412.6980.
• Loshchilov, I., & Hutter, F. (2017). Decoupled Weight Decay Regularization. arXiv:1711.05101.
• Reddi, S. J., Kale, S., & Kumar, S. (2018). On the Convergence of Adam and Beyond. ICLR.