Accueil › Glossaire › Optimizer

Optimizer (Optimiseur)

Un optimizer (ou optimiseur) est l’algorithme qui met à jour les poids d’un modèle de machine learning pendant l’entraînement, en utilisant les gradients calculés par la rétropropagation pour minimiser la fonction de loss.

L’optimizer est le moteur de l’apprentissage. Il détermine comment le modèle ajuste ses poids à chaque itération pour réduire son erreur. Le choix de l’optimizer influence la vitesse de convergence, la stabilité de l’entraînement et la qualité de la solution finale. Deux modèles identiques entraînés avec des optimizers différents peuvent donner des résultats très différents. En pratique, Adam (ou sa variante AdamW) est le choix par défaut dans la majorité des projets de deep learning, mais SGD avec momentum reste compétitif dans certains domaines, en particulier la vision par ordinateur.

Le principe : descente de gradient

Tous les optimizers majeurs en deep learning sont basés sur la descente de gradient. Le principe : calculer le gradient de la loss par rapport à chaque poids (via la rétropropagation), puis déplacer les poids dans la direction opposée au gradient (la direction qui réduit la loss). L’ampleur du déplacement est contrôlée par le learning rate.

La formule de base (SGD pur) : w = w – η × ∇L(w), où w sont les poids, η le learning rate, et ∇L(w) le gradient de la loss.

Les optimizers modernes ajoutent des mécanismes au-dessus de cette formule de base pour accélérer la convergence, stabiliser l’entraînement et s’adapter aux spécificités de chaque paramètre. Deux grandes familles se distinguent : les optimizers à momentum (qui utilisent l’historique des gradients) et les optimizers adaptatifs (qui ajustent le learning rate par paramètre).

SGD et SGD + Momentum

SGD (Stochastic Gradient Descent)

L’optimizer le plus simple : à chaque mini-batch, il calcule le gradient et met à jour les poids proportionnellement au gradient et au learning rate. C’est direct, peu coûteux en mémoire, mais lent à converger sur des surfaces de loss complexes (il oscille dans les « ravines » du paysage d’optimisation au lieu de descendre directement).

SGD + Momentum

Le momentum ajoute de l' »inertie » aux mises à jour : au lieu de suivre uniquement le gradient actuel, le modèle accumule une moyenne mobile des gradients passés. Cela lisse les oscillations et accélère la convergence dans les directions cohérentes. L’analogie : une bille qui roule sur une surface accumule de la vitesse dans la direction de la pente, traversant les petites bosses au lieu de s’y arrêter.

Le paramètre de momentum (typiquement 0,9) contrôle l’importance relative du gradient actuel vs l’historique. La variante Nesterov (NAG) « regarde en avant » en calculant le gradient au point où le momentum emmènerait les poids, plutôt qu’au point actuel. Cela améliore la convergence dans certains cas.

# PyTorch : SGD avec momentum
optimizer = torch.optim.SGD(
    model.parameters(),
    lr=0.1,
    momentum=0.9,         # Momentum standard
    nesterov=True,        # Variante Nesterov (recommandée)
    weight_decay=1e-4     # Régularisation L2
)

Adam et AdamW

Adam (Adaptive Moment Estimation)

Adam est l’optimizer le plus utilisé en deep learning. Il combine deux idées : le momentum (moyenne mobile du premier moment, les gradients) et l’adaptation par paramètre (moyenne mobile du second moment, les gradients au carré). Chaque paramètre reçoit un learning rate effectif ajusté en fonction de la magnitude historique de ses gradients.

Concrètement, Adam maintient deux statistiques par paramètre : m (estimation du premier moment, analogue au momentum) et v (estimation du second moment, analogue à RMSprop). Il applique aussi une correction de biais pour les premières itérations (quand les moyennes mobiles sont encore imprécises).

Avantages d’Adam : convergence rapide, peu sensible au choix initial du learning rate, fonctionne bien « out of the box » avec les hyperparamètres par défaut (lr=1e-3, β₁=0,9, β₂=0,999, ε=1e-8). C’est le choix par défaut dans la plupart des frameworks (PyTorch, TensorFlow, JAX).

AdamW (Adam avec weight decay découplé)

AdamW, proposé par Loshchilov et Hutter en 2019, corrige un problème fondamental d’Adam. Dans Adam standard, la régularisation L2 (weight decay) est mélangée avec l’adaptation du learning rate, ce qui réduit son efficacité. AdamW découple les deux : le weight decay est appliqué directement sur les poids, indépendamment du mécanisme adaptatif.

Le résultat : une régularisation plus efficace et une meilleure généralisation. AdamW est le standard pour l’entraînement des Transformers et des LLM. Si vous utilisez Adam avec du weight decay, passez à AdamW.

# PyTorch : AdamW (recommandé pour Transformers/LLM)
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=3e-4,
    betas=(0.9, 0.999),    # β₁ (momentum), β₂ (adaptation)
    eps=1e-8,               # Stabilité numérique
    weight_decay=0.01       # Weight decay découplé
)

Autres optimizers notables

RMSprop

RMSprop (proposé par Hinton) utilise une moyenne mobile exponentielle des gradients au carré pour adapter le learning rate par paramètre. C’est l’un des « ancêtres » d’Adam (qui combine RMSprop + momentum). RMSprop est rarement utilisé seul aujourd’hui, mais il reste pertinent pour les RNN et certaines applications où Adam est instable.

Adagrad

Adagrad accumule la somme de tous les gradients au carré passés et utilise cette somme pour réduire le learning rate des paramètres fréquemment mis à jour. Idéal pour les données éparses (NLP avec des vocabulaires larges). Inconvénient majeur : le learning rate effectif décroît continuellement et finit par atteindre zéro, stoppant l’apprentissage. RMSprop et Adam corrigent ce problème.

Lion (EvoLved Sign Momentum)

Lion, développé par Google Brain en 2023, est un optimizer découvert automatiquement par recherche d’architecture. Il utilise uniquement le signe du gradient (pas sa magnitude) avec du momentum, ce qui le rend plus économe en mémoire qu’Adam (pas besoin de stocker le second moment). Des études récentes sur l’entraînement de LLM montrent que Lion atteint des performances similaires à Adam avec une empreinte mémoire réduite d’environ 50%.

Adafactor

Adafactor réduit la mémoire nécessaire par rapport à Adam en factorisant la matrice du second moment. Au lieu de stocker un vecteur v de la taille du paramètre, il stocke des facteurs de rang inférieur. C’est un choix populaire pour les très grands modèles où la mémoire GPU est le facteur limitant. Des recherches de l’université de Harvard montrent qu’Adafactor (avec momentum) atteint des performances similaires à Adam sur les LLM tout en réduisant la consommation mémoire.

Comparaison des principaux optimizers

Comment choisir son optimizer

Cas par défaut : AdamW. Pour la majorité des projets de deep learning (NLP, vision, multimodal, génératif), AdamW avec les hyperparamètres par défaut (lr=1e-3 ou 3e-4, β₁=0,9, β₂=0,999, weight_decay=0,01) est le point de départ le plus sûr. C’est le standard pour tous les Transformers et LLM.

Vision classique avec SGD. Pour les tâches de classification d’images bien établies (ImageNet, CIFAR), SGD + momentum (0,9) avec Nesterov et un scheduler cosine annealing reste compétitif et peut même surpasser Adam en termes de généralisation finale. Il nécessite cependant plus de tuning du learning rate.

Contraintes mémoire. Si la mémoire GPU est le facteur limitant (modèles de plusieurs milliards de paramètres), considérez Lion ou Adafactor qui réduisent l’empreinte mémoire d’environ 30 à 50% par rapport à Adam/AdamW.

Recherche récente. Une étude de Harvard (Kempner Institute) a montré que pour l’entraînement de LLM, Adam, Lion, Adafactor (avec momentum) et Signum (SGD signé) atteignent des performances similaires, tandis que SGD standard est systématiquement moins bon. Le message : le choix entre les optimizers adaptatifs importe peu ; ce qui compte, c’est d’utiliser un optimizer adaptatif plutôt que SGD pur pour les LLM.

Les hyperparamètres des optimizers

En pratique, le learning rate et le weight decay sont les deux seuls hyperparamètres à tuner dans la majorité des cas. Les valeurs par défaut de β₁, β₂ et ε fonctionnent bien pour la quasi-totalité des projets. L’exception : pour le pré-entraînement de très grands LLM, β₂ est parfois réduit à 0,95 pour mieux gérer les gradients instables des premiers steps.

Erreurs fréquentes

Utiliser Adam au lieu d’AdamW avec du weight decay. C’est l’erreur la plus courante. Adam avec weight_decay mélange la régularisation avec l’adaptation du learning rate, réduisant son efficacité. Utilisez toujours AdamW si vous avez besoin de weight decay (et vous en avez presque toujours besoin).

Même learning rate pour SGD et Adam. SGD nécessite un LR 10 à 100× plus élevé qu’Adam. Un LR de 0,1 est standard pour SGD mais fait diverger Adam. Respectez les plages recommandées de chaque optimizer.

Ne pas utiliser de scheduler. Un LR fixe est sous-optimal avec n’importe quel optimizer. Au minimum, utilisez un cosine annealing ou un reduce on plateau. Pour les Transformers, le warmup + cosine decay est obligatoire.

Ignorer le coût mémoire de l’optimizer. Adam stocke deux états par paramètre (m et v), doublant la mémoire nécessaire par rapport à SGD. Pour un modèle de 7 milliards de paramètres en FP32, les états d’Adam consomment environ 56 Go de mémoire GPU. C’est souvent le facteur limitant pour l’entraînement de grands modèles. Lion et Adafactor réduisent significativement cette empreinte.

Changer d’optimizer en cours d’entraînement sans précaution. Chaque optimizer accumule des états internes (momentum, variance). Passer de SGD à Adam en plein entraînement sans réinitialiser ces états peut produire des comportements imprévisibles. Si vous devez changer, réinitialisez l’optimizer et ajustez le learning rate.