Adam Optimizer

L’optimiseur Adam, abréviation d’Adaptive Moment Estimation, est un algorithme d’optimisation pour l’entraînement des réseaux de neurones, qui attribue à chaque paramètre une taille de pas adaptative. Présenté par Kingma et Ba dans Adam: A Method for Stochastic Optimization, il étend la descente de gradient stochastique (SGD) grâce aux moyennes mobiles des gradients passés et de leurs carrés. Les progrès rapides au début de l’entraînement et des paramètres par défaut faciles à utiliser ont fait d’Adam l’optimiseur de départ le plus courant en apprentissage profond, et sa variante AdamW est le choix standard pour entraîner les transformers et les grands modèles de langage.

Fonctionnement d’Adam#

L’entraînement minimise une fonction de perte en ajustant répétitivement chaque poids dans le sens opposé à son gradient. La SGD simple multiplie chaque gradient par le même taux d’apprentissage. Adam conserve deux valeurs supplémentaires par paramètre et les met à jour à chaque étape t à partir du gradient courant g :

1. Premier moment (momentum) : m = β1·m + (1 − β1)·g, une moyenne des gradients à décroissance exponentielle qui maintient la mise à jour dans une direction cohérente.
2. Second moment : v = β2·v + (1 − β2)·g², une moyenne décroissante des gradients au carré qui suit l’amplitude habituelle des gradients de chaque paramètre.
3. Correction du biais : m̂ = m / (1 − β1^t) et v̂ = v / (1 − β2^t), qui compensent le fait que les deux moyennes commencent à zéro.
4. Mise à jour : θ = θ − lr · m̂ / (√v̂ + ε).

Les valeurs par défaut de l’article, également utilisées par torch.optim.Adam de PyTorch, sont lr = 0.001, β1 = 0.9, β2 = 0.999 et ε = 1e-8. La division par √v̂ normalise chaque étape par l’amplitude habituelle du gradient du paramètre : les étapes restent donc proches du taux d’apprentissage, que les gradients soient minuscules ou énormes, et diminuent dans les directions bruitées où les gradients positifs et négatifs s’annulent à l’intérieur de m̂. L’extrait ci-dessous compare la première étape de SGD et d’Adam sur deux paramètres dont les gradients diffèrent d’un facteur de 1 000 :

import torch

# Two parameters whose gradients differ in scale by 1,000x
scale = torch.tensor([1000.0, 1.0])

for name, optimizer_cls in [("SGD", torch.optim.SGD), ("Adam", torch.optim.Adam)]:
    w = torch.zeros(2, requires_grad=True)
    optimizer = optimizer_cls([w], lr=0.001)

    loss = (scale * w).sum()  # gradient is [1000, 1]
    loss.backward()
    optimizer.step()
    print(f"{name} first step: {[round(v, 4) for v in w.tolist()]}")

La SGD déplace le premier paramètre à -1.0 et le second à -0.001, soit un écart d’un facteur de 1 000 qui suit celui des gradients. Adam déplace les deux paramètres exactement du taux d’apprentissage, soit -0.001, car son étape normalisée dépend de la direction et de la régularité du gradient plutôt que de son amplitude brute.

Adam et AdamW#

Adam, dans ses implémentations courantes, applique une décroissance des poids, une forme de régularisation, sous la forme d’une pénalité L2 ajoutée au gradient. Cette pénalité est ensuite divisée par √v̂ comme le reste, si bien que les poids associés à des gradients élevés sont à peine régularisés. La décroissance des poids découplée de Loshchilov et Hutter résout ce problème en réduisant directement les poids à chaque étape, indépendamment de la mise à jour adaptative. Dans les expériences de l’article, AdamW a ainsi amélioré la capacité de généralisation d’Adam en classification d’images et est disponible sous la forme de torch.optim.AdamW.

Adam et SGD#

La SGD avec momentum utilise un taux d’apprentissage global et stocke un tampon par paramètre, tandis qu’Adam en stocke deux, soit 8 octets par paramètre en précision 32 bits et 56 Go d’état d’optimiseur pour un modèle de 7 milliards de paramètres. Adam progresse généralement plus vite au début, est moins sensible au taux d’apprentissage et entraîne les transformers de manière bien plus fiable que la SGD. Une SGD bien réglée atteint souvent une exactitude finale équivalente ou supérieure sur les modèles d’images convolutifs, et Wilson et al. ont constaté que les méthodes adaptatives généralisaient souvent moins bien que la SGD sur les tâches de classification d’images et les tâches de traitement du langage qu’ils ont évaluées.

L’entraînement Ultralytics YOLO reflète ce compromis : l’argument par défaut optimizer="auto" choisit AdamW, avec un taux d’apprentissage initial adapté au nombre de classes, pour les entraînements allant jusqu’à 10 000 itérations, puis passe à MuSGD, un hybride de SGD et de Muon, pour les entraînements plus longs. Définir explicitement l’optimiseur exige aussi de définir le taux d’apprentissage, car la valeur par défaut lr0=0.01 convient à la SGD et représente dix fois le taux habituel d’Adam.

from ultralytics import YOLO

# Charger un modèle YOLO26n préentraîné
model = YOLO("yolo26n.pt")

# Entraîne avec AdamW et un taux d’apprentissage initial adapté à Adam
results = model.train(data="coco8.yaml", epochs=5, optimizer="AdamW", lr0=0.001)

Lorsque YOLO26 s’entraîne avec un optimiseur de la famille Adam, l’argument momentum (valeur par défaut : 0.937) définit β1, tandis que β2 reste fixé à 0.999.

Adam et les optimiseurs associés#

• AdaGrad : Divise chaque étape par la racine de la somme de tous les gradients passés au carré. La taille des étapes ne fait donc que diminuer, ce qui convient aux caractéristiques éparses, mais ralentit les longues phases d’entraînement.
• RMSProp : Remplace la somme cumulée d’AdaGrad par une moyenne à décroissance exponentielle des gradients au carré. Adam est essentiellement RMSProp auquel s’ajoutent le momentum et la correction du biais.
• Muon : Un optimiseur destiné aux matrices de poids 2D des couches cachées, qui orthogonalise chaque mise à jour du momentum à l’aide d’itérations de Newton–Schulz et conserve un seul tampon d’état par paramètre, soit la moitié de l’état d’optimiseur d’Adam.