Accueil › Glossaire › Adam (Optimiseur)

Adam (Optimiseur)

Adam (Adaptive Moment Estimation) est un algorithme d’optimisation qui combine les avantages du momentum et de RMSProp pour ajuster automatiquement le learning rate de chaque paramètre d’un réseau de neurones pendant l’entraînement.

Publié en 2014 par Diederik P. Kingma et Jimmy Ba, puis présenté à ICLR 2015, Adam est devenu l’optimiseur par défaut de la plupart des projets de deep learning. Sa popularité tient à trois qualités : il converge rapidement, nécessite peu de réglage manuel, et fonctionne bien sur des problèmes à gradients bruités ou épars. Des architectures comme GPT, BERT ou les modèles de vision par ordinateur s’appuient massivement sur Adam (ou sa variante AdamW) pour leur entraînement.

Pourquoi Adam existe : le problème qu’il résout

Avant Adam, entraîner un réseau de neurones profond posait un dilemme récurrent. La descente de gradient classique (SGD) fonctionne, mais elle exige un réglage minutieux du learning rate. Trop élevé, l’entraînement diverge. Trop faible, il met des heures à converger. Et surtout, un learning rate unique pour tous les paramètres n’est pas optimal : certains poids ont besoin de mises à jour importantes, d’autres de corrections fines.

Deux approches tentaient de résoudre ce problème avant Adam :

Le momentum (utilisé dans le SGD avec momentum) accélère la convergence en accumulant une moyenne mobile des gradients passés. Imaginez une bille qui roule sur une surface : le momentum lui donne de l’inertie, ce qui l’aide à franchir les zones plates et à amortir les oscillations dans les zones abruptes.

RMSProp (proposé par Geoffrey Hinton) adapte le learning rate de chaque paramètre individuellement en divisant par la racine carrée de la moyenne mobile des gradients au carré. Les paramètres dont les gradients varient beaucoup reçoivent un learning rate plus faible, et inversement.

Adam fusionne ces deux idées. Il maintient simultanément une estimation du premier moment (la moyenne des gradients, comme le momentum) et du second moment (la moyenne des gradients au carré, comme RMSProp). Le résultat : un optimiseur qui s’adapte à la géométrie du paysage de perte, avance vite dans les zones plates et ralentit dans les zones bruitées.

Fonctionnement détaillé d’Adam

L’intuition derrière l’algorithme

Adam traite les gradients comme des variables aléatoires et estime leurs deux premiers moments statistiques :

Premier moment (m) : la moyenne mobile exponentielle des gradients. C’est l’équivalent du momentum. Il indique la direction générale dans laquelle les paramètres doivent être mis à jour.

Second moment (v) : la moyenne mobile exponentielle des gradients au carré. C’est l’équivalent de RMSProp. Il mesure la magnitude (la « force ») récente des gradients pour chaque paramètre.

En combinant ces deux informations, Adam peut prendre des pas plus grands dans les zones plates du paysage de perte (où les gradients sont faibles et stables) et des pas plus petits et prudents dans les zones bruitées (où les gradients varient fortement).

Les formules pas à pas

Voici l’algorithme complet à chaque étape t de l’entraînement. On part des gradients g_t calculés via la rétropropagation.

Étape 1 : mise à jour du premier moment (momentum)

m_t = β₁ · m_{t-1} + (1 - β₁) · g_t

Le paramètre β₁ (par défaut 0.9) contrôle la « mémoire » du momentum. Avec β₁ = 0.9, environ 90 % de l’information vient des gradients passés et 10 % du gradient actuel.

Étape 2 : mise à jour du second moment (variance)

v_t = β₂ · v_{t-1} + (1 - β₂) · g_t²

Le paramètre β₂ (par défaut 0.999) contrôle la mémoire de l’estimation de variance. La valeur plus élevée signifie une estimation plus lisse et moins sensible aux fluctuations ponctuelles.

Étape 3 : correction du biais

m̂_t = m_t / (1 - β₁ᵗ)
v̂_t = v_t / (1 - β₂ᵗ)

Ce point est crucial et souvent mal compris. Comme m et v sont initialisés à zéro, ils sont biaisés vers zéro pendant les premières itérations. La correction de biais divise par un facteur qui tend vers 1 au fil du temps, compensant cette sous-estimation initiale. Sans cette correction, les premiers pas d’entraînement seraient trop petits, ralentissant inutilement la convergence.

Étape 4 : mise à jour des poids

θ_{t+1} = θ_t - α · m̂_t / (√v̂_t + ε)

Ici, α est le learning rate global (par défaut 0.001) et ε (par défaut 10⁻⁸ dans PyTorch, 10⁻⁷ dans Keras) est un petit nombre ajouté pour éviter la division par zéro.

Pseudo-code complet

Initialiser θ (paramètres du modèle)
Initialiser m₀ = 0, v₀ = 0, t = 0
Définir α = 0.001, β₁ = 0.9, β₂ = 0.999, ε = 1e-8

Pour chaque batch d'entraînement :
    t = t + 1
    g_t = ∇θ L(θ_{t-1})                    # gradient de la loss
    m_t = β₁ · m_{t-1} + (1 - β₁) · g_t    # premier moment
    v_t = β₂ · v_{t-1} + (1 - β₂) · g_t²   # second moment
    m̂_t = m_t / (1 - β₁ᵗ)                  # correction biais 1
    v̂_t = v_t / (1 - β₂ᵗ)                  # correction biais 2
    θ_t = θ_{t-1} - α · m̂_t / (√v̂_t + ε)  # mise à jour

Hyperparamètres d’Adam : valeurs par défaut et réglage

Adam possède cinq hyperparamètres. La bonne nouvelle : les valeurs par défaut fonctionnent bien dans la majorité des cas. Les voici avec les recommandations d’ajustement.

Adam vs SGD : quel optimiseur choisir ?

Le débat Adam vs SGD revient constamment. Voici la réponse directe : Adam pour le prototypage et les Transformers, SGD pour la vision quand vous voulez les derniers dixièmes de pourcent de performance.

En pratique, le gap de généralisation entre Adam et SGD est souvent dû à un mauvais réglage de la régularisation. Adam nécessite généralement plus de régularisation que SGD. Si vous passez de SGD à Adam, augmentez le weight decay ou le dropout.

AdamW : la variante à connaître absolument

AdamW est la variante d’Adam que vous devriez utiliser par défaut pour les grands modèles. Présenté par Ilya Loshchilov et Frank Hutter en 2017, AdamW corrige un défaut fondamental dans la façon dont Adam gère le weight decay.

Le problème : L2 ≠ weight decay avec Adam

En SGD classique, la régularisation L2 (ajouter λ/2 · ||θ||² à la loss) et le weight decay (soustraire λ · θ à chaque mise à jour) sont mathématiquement équivalents. Avec Adam, cette équivalence est brisée.

Quand vous ajoutez un terme L2 à la loss avec Adam, le gradient de ce terme (proportionnel aux poids) passe par le mécanisme d’adaptation du learning rate. Les paramètres avec de grands gradients reçoivent un learning rate plus petit, ce qui réduit l’effet de la régularisation exactement là où elle devrait agir le plus fort. Le résultat : une régularisation incohérente et une généralisation sous-optimale.

La solution : découpler le weight decay

AdamW applique le weight decay directement sur les poids, après la mise à jour adaptative, au lieu de l’intégrer dans le gradient :

# Adam classique avec L2 (incorrect pour les optimiseurs adaptatifs)
θ_{t+1} = θ_t - α · m̂_t / (√v̂_t + ε)    # le terme L2 est dans g_t

# AdamW (correct)
θ_{t+1} = θ_t - α · (m̂_t / (√v̂_t + ε) + λ · θ_t)

Le weight decay est ainsi appliqué uniformément à tous les paramètres, sans interférence avec le mécanisme adaptatif.

Quand utiliser Adam vs AdamW

Utilisez AdamW si vous entraînez un Transformer, un LLM, un modèle BERT/GPT, ou tout réseau profond où la régularisation compte. C’est le standard pour l’entraînement des grands modèles de langage, y compris ceux de la famille GPT d’OpenAI, Claude d’Anthropic, ou les modèles open-weight comme LLaMA.

Utilisez Adam pour le prototypage rapide, les petits modèles où l’overfitting n’est pas un enjeu, ou les tâches simples où la régularisation n’est pas critique.

Les autres variantes d’Adam

Adam a inspiré de nombreuses variantes. Voici les plus pertinentes :

En pratique, pour la grande majorité des projets, le choix se résume à AdamW pour les Transformers et grands modèles, et Adam classique pour tout le reste. Les variantes exotiques ne s’imposent que dans des scénarios très spécifiques (entraînement distribué massif, contraintes mémoire extrêmes).

Implémentation pratique : PyTorch et Keras

Adam et AdamW avec PyTorch

import torch
import torch.optim as optim

model = MonModele()

# Adam classique (valeurs par défaut)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# AdamW pour Transformers (configuration recommandée)
optimizer = optim.AdamW(
    model.parameters(),
    lr=3e-4,
    betas=(0.9, 0.999),
    eps=1e-8,
    weight_decay=0.01
)

# AdamW avec groupes de paramètres séparés
# (pas de weight decay sur les biais et LayerNorm)
no_decay = ['bias', 'LayerNorm.weight', 'LayerNorm.bias']
param_groups = [
    {
        'params': [p for n, p in model.named_parameters()
                   if not any(nd in n for nd in no_decay)],
        'weight_decay': 0.01
    },
    {
        'params': [p for n, p in model.named_parameters()
                   if any(nd in n for nd in no_decay)],
        'weight_decay': 0.0
    }
]
optimizer = optim.AdamW(param_groups, lr=3e-4)

Adam et AdamW avec Keras

import keras

# Adam classique
model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Adam avec paramètres personnalisés
optimizer = keras.optimizers.Adam(
    learning_rate=0.001,
    beta_1=0.9,
    beta_2=0.999,
    epsilon=1e-7
)
model.compile(optimizer=optimizer, loss='categorical_crossentropy')

# AdamW avec Keras
optimizer = keras.optimizers.AdamW(
    learning_rate=3e-4,
    weight_decay=0.01
)
model.compile(optimizer=optimizer, loss='categorical_crossentropy')

Forces et limites d’Adam

Ce qui rend Adam efficace

Convergence rapide. En combinant momentum et adaptation par paramètre, Adam converge bien plus vite que le SGD classique, surtout en début d’entraînement. Sur des tâches complexes, la différence se mesure en heures de GPU économisées.

Peu de réglage. Les hyperparamètres par défaut (α=0.001, β₁=0.9, β₂=0.999) fonctionnent remarquablement bien dans la majorité des cas. Vous pouvez lancer un entraînement sans passer des heures sur un grid search.

Robustesse aux gradients bruités et épars. Les données NLP produisent souvent des gradients épars (la plupart des tokens du vocabulaire ne sont pas présents dans chaque batch). Adam gère ce cas naturellement grâce à son adaptation par paramètre.

Invariance au rescaling des gradients. Si vous multipliez tous les gradients par un scalaire, la direction de mise à jour d’Adam ne change pas. Cette propriété le rend robuste aux choix d’échelle dans les fonctions de perte.

Faible empreinte mémoire relative. Adam ne stocke que deux vecteurs supplémentaires (m et v) par paramètre, soit 2x la taille des poids. C’est plus que SGD (1x pour le momentum), mais bien moins qu’un optimiseur de second ordre complet qui nécessiterait une matrice Hessienne.

Les limites à connaître

Généralisation parfois inférieure. Sur certaines tâches de vision (ImageNet, CIFAR), SGD avec un learning rate schedule bien réglé peut atteindre une meilleure accuracy en test. Ce gap se réduit avec AdamW et une régularisation adaptée, mais il existe.

Consommation mémoire doublée vs SGD. Pour un modèle avec N paramètres, Adam stocke 2N états supplémentaires (m et v). Pour un modèle de 70B de paramètres en FP32, cela représente environ 560 Go de mémoire pour les seuls états de l’optimiseur. C’est pourquoi les très grands modèles utilisent parfois Adafactor, qui factorise le second moment.

Problèmes de convergence théorique. Le papier AMSGrad (Reddi et al., 2018) a montré que l’Adam original peut ne pas converger vers l’optimum dans certains scénarios théoriques. En pratique, ce problème est rare, mais il explique l’existence de la variante AMSGrad (activable avec amsgrad=True).

Sensibilité à ε en précision mixte. En entraînement FP16/BF16, la valeur par défaut d’ε peut être trop faible, causant des instabilités numériques. Augmentez-la à 1e-6 ou 1e-4 si vous observez des NaN dans les gradients.

Bonnes pratiques pour utiliser Adam

Voici les recommandations concrètes, issues de la pratique des équipes qui entraînent des modèles de production.

1. Commencez par AdamW, pas Adam. Sauf pour les cas triviaux, AdamW est strictement meilleur grâce à sa gestion correcte du weight decay. Tous les frameworks majeurs l’implémentent nativement.

2. Utilisez un warmup. Le warmup (augmentation linéaire du learning rate sur les premiers 1 % à 10 % des steps) stabilise les premières itérations. Sans warmup, la correction de biais peut ne pas suffire, et les premiers pas d’optimisation peuvent être erratiques.

3. Excluez les biais et les normalisations du weight decay. Le weight decay ne doit s’appliquer qu’aux matrices de poids, pas aux biais ni aux paramètres de batch normalization ou de layer normalization. Appliquer le weight decay globalement dégrade les performances.

4. Monitorez les normes des gradients. Si elles explosent, utilisez le gradient clipping (typiquement, clip à une norme maximale de 1.0). C’est standard dans l’entraînement des réseaux de neurones profonds.

5. Ne touchez pas β₁ et β₂ sauf nécessité. Les valeurs par défaut fonctionnent pour la quasi-totalité des cas. Si votre entraînement diverge, cherchez d’abord le problème dans le learning rate, le batch size, ou l’architecture avant de modifier les betas.

6. Ajustez ε pour la précision mixte. En FP16 ou BF16, passez epsilon à 1e-6 ou 1e-5 pour éviter les instabilités.

Adam dans l’entraînement des LLMs

L’entraînement des grands modèles de langage repose presque universellement sur AdamW. La configuration typique pour un LLM suit un pattern bien établi :

Learning rate : entre 1e-4 et 6e-4, selon la taille du modèle. Les modèles plus grands utilisent généralement un learning rate plus faible.

Warmup : montée linéaire sur les 2 000 premiers steps environ, suivie d’un cosine decay jusqu’à environ 10 % du learning rate max.

β₁ = 0.9, β₂ = 0.95 : pour les LLMs, β₂ est souvent réduit par rapport au défaut de 0.999. Cette valeur plus basse rend l’estimation du second moment plus réactive, ce qui aide avec les distributions de gradients non stationnaires typiques de l’entraînement sur de larges corpus textuels.

Weight decay : typiquement 0.1, appliqué uniquement aux matrices de poids (pas aux biais ni aux normalisations).

Gradient clipping : norme maximale de 1.0.

Erreurs courantes à éviter

Utiliser Adam avec L2 au lieu d’AdamW. C’est l’erreur la plus fréquente. Si vous activez weight_decay dans torch.optim.Adam, vous obtenez une régularisation L2 classique (pas un weight decay découplé). Pour un weight decay correct, utilisez explicitement torch.optim.AdamW.

Appliquer le weight decay à tous les paramètres. Le weight decay sur les biais et les paramètres de normalisation réduit la capacité du modèle sans bénéfice de régularisation. Créez toujours des groupes de paramètres séparés.

Oublier le warmup sur les grands modèles. Sans warmup, les premières mises à jour sont souvent trop agressives, ce qui peut déstabiliser l’entraînement et produire des NaN irréversibles.

Confondre learning rate et weight decay. Avec Adam classique, ces deux paramètres sont couplés. Avec AdamW, ils sont indépendants. Ajustez-les séparément en commençant par le learning rate, puis le weight decay.

Négliger le gradient clipping. Adam adapte le learning rate par paramètre, mais il ne protège pas contre les gradients explosifs. Le clipping est une sécurité indispensable pour les architectures profondes.

Verdict : Adam reste incontournable

Plus de dix ans après sa publication, Adam (et surtout AdamW) reste l’optimiseur le plus utilisé en deep learning. Les variantes récentes comme AdamN ou Muon proposent des améliorations marginales dans des contextes spécifiques, mais aucune n’a détrôné AdamW comme standard de l’industrie.

Pour un nouveau projet, la recommandation est claire : commencez avec AdamW, les hyperparamètres par défaut (ou la configuration LLM standard si vous entraînez un modèle de langage), et un cosine learning rate schedule avec warmup. C’est le setup qui vous donnera les résultats les plus fiables avec le moins d’effort de réglage.

Le seul cas où SGD reste compétitif : les architectures convolutionnelles entraînées sur de grands jeux de données de vision (ImageNet), où un SGD avec momentum et un step decay schedule bien réglé peut gagner quelques dixièmes de pourcent en accuracy. Pour tout le reste (NLP, multimodal, audio, RL), AdamW est le choix évident.