Accueil › Glossaire › SGD (Stochastic Gradient Descent)

SGD (Stochastic Gradient Descent)

SGD (Stochastic Gradient Descent, ou descente de gradient stochastique) est un algorithme d’optimisation qui met à jour les paramètres d’un modèle en calculant le gradient sur un seul exemple (ou un petit lot) de données à chaque itération, plutôt que sur l’ensemble du dataset.

C’est l’algorithme fondateur de l’entraînement des réseaux de neurones. Toutes les méthodes modernes d’optimisation en deep learning, y compris Adam, RMSProp ou AdaGrad, sont des extensions de SGD. L’idée remonte aux travaux de Robbins et Monro dans les années 1950, mais c’est l’association avec la rétropropagation en 1986 qui a fait de SGD la pierre angulaire du machine learning moderne.

En pratique, le terme « SGD » désigne presque toujours la version mini-batch : on calcule le gradient sur un petit lot (batch) de données plutôt que sur un seul exemple. C’est cette version que PyTorch et TensorFlow implémentent sous le nom SGD. Le SGD pur (un seul exemple par itération) est rarement utilisé tel quel.

Les trois formes de la descente de gradient

Avant de plonger dans SGD, il faut comprendre les trois variantes de la descente de gradient. Elles partagent le même objectif (minimiser une fonction de perte) mais diffèrent par la quantité de données utilisée à chaque mise à jour.

Batch Gradient Descent (descente de gradient complète)

La version originale calcule le gradient sur la totalité du dataset avant chaque mise à jour des poids :

θ = θ - α · (1/N) · Σᵢ ∇θ L(θ, xᵢ, yᵢ)

C’est mathématiquement élégant : chaque pas va exactement dans la direction de la plus forte descente. Mais en pratique, c’est inutilisable pour les datasets modernes. Avec des millions d’images ou de documents, calculer un seul gradient sur tout le dataset prend un temps prohibitif et nécessite de stocker l’intégralité des données en mémoire.

SGD pur (un seul exemple)

À l’opposé, le SGD pur ne calcule le gradient que sur un seul exemple tiré aléatoirement :

θ = θ - α · ∇θ L(θ, xᵢ, yᵢ)

Chaque mise à jour est extrêmement rapide, mais le gradient estimé à partir d’un seul exemple est bruité. La trajectoire d’optimisation zigzague de façon erratique au lieu de suivre une descente régulière. Ce bruit peut paradoxalement être bénéfique : il aide le modèle à échapper aux minima locaux et aux points-selle, menant parfois à de meilleures solutions.

Mini-batch SGD (le standard actuel)

Le compromis utilisé en pratique : on calcule le gradient sur un petit lot (mini-batch) de B exemples :

θ = θ - α · (1/B) · Σⱼ ∇θ L(θ, xⱼ, yⱼ)    # j ∈ mini-batch de taille B

Le mini-batch réduit la variance du gradient (plus stable que le SGD pur) tout en restant bien plus rapide que le batch complet. De plus, les opérations matricielles sur un batch sont hautement optimisées sur GPU. Les tailles de batch courantes vont de 32 à 8192 selon la tâche et le matériel disponible.

Fonctionnement de SGD pas à pas

L’algorithme SGD (version mini-batch) suit un cycle répétitif à chaque itération d’entraînement :

1. Échantillonnage. Un mini-batch de B exemples est tiré aléatoirement du dataset d’entraînement.

2. Forward pass. Le mini-batch traverse le réseau pour produire des prédictions.

3. Calcul de la perte. La fonction de perte mesure l’écart entre les prédictions et les valeurs cibles.

4. Backward pass. La rétropropagation calcule le gradient de la perte par rapport à chaque paramètre du réseau.

5. Mise à jour des poids. Chaque paramètre est ajusté dans la direction opposée au gradient, proportionnellement au learning rate α :

θ_{t+1} = θ_t - α · g_t    # g_t = gradient moyenné sur le mini-batch

6. Répétition. On recommence avec un nouveau mini-batch. Un passage complet sur l’ensemble du dataset constitue une epoch.

Le learning rate α est l’hyperparamètre le plus critique de SGD. Il détermine l’amplitude de chaque mise à jour. Un learning rate trop élevé fait diverger l’entraînement (les poids oscillent sans converger). Un learning rate trop faible ralentit la convergence au point de rendre l’entraînement impraticable.

SGD avec Momentum : accélérer la convergence

Le SGD vanille a un problème majeur : dans les zones du paysage de perte qui forment des ravins étroits (gradient fort dans une direction, faible dans l’autre), les mises à jour oscillent perpendiculairement au fond du ravin au lieu de le descendre. La convergence devient extrêmement lente.

Le momentum, introduit par Polyak en 1964 et appliqué aux réseaux de neurones en 1986, résout ce problème en ajoutant une « inertie » aux mises à jour. L’analogie physique est celle d’une bille roulant sur une surface : elle accumule de la vitesse dans les directions cohérentes et amortit les oscillations.

Les formules du momentum

v_t = μ · v_{t-1} + g_t          # accumulation de la vélocité
θ_{t+1} = θ_t - α · v_t          # mise à jour des poids

Le paramètre μ (typiquement 0.9) est le coefficient de momentum. Avec μ = 0.9, la vélocité à l’instant t inclut 90 % de la vélocité précédente plus le gradient actuel. Le résultat : les gradients dans une direction cohérente s’accumulent (accélération), tandis que les gradients oscillants s’annulent (amortissement).

Momentum de Nesterov (NAG)

Le momentum de Nesterov (Nesterov Accelerated Gradient, ou NAG), popularisé pour le deep learning par Ilya Sutskever en 2013, apporte une amélioration subtile mais efficace. Au lieu de calculer le gradient à la position actuelle puis d’ajouter le momentum, NAG fait un « pas en avant » dans la direction du momentum d’abord, puis calcule le gradient à cette position anticipée.

# Momentum classique :
v_t = μ · v_{t-1} + ∇L(θ_t)           # gradient à la position actuelle
θ_{t+1} = θ_t - α · v_t

# Nesterov Momentum :
θ̃ = θ_t + μ · v_{t-1}                 # position anticipée ("lookahead")
v_t = μ · v_{t-1} + ∇L(θ̃)             # gradient à la position anticipée
θ_{t+1} = θ_t - α · v_t

L’intuition : si le momentum vous emmène dans une mauvaise direction, le gradient corrigé à la position anticipée le détecte plus tôt et corrige la trajectoire. NAG offre souvent une convergence légèrement plus rapide que le momentum classique, avec les mêmes hyperparamètres.

En pratique, utilisez toujours le momentum de Nesterov. Dans PyTorch, il suffit d’ajouter nesterov=True à torch.optim.SGD.

Learning rate schedules : la clé du SGD performant

Contrairement à Adam qui adapte le learning rate automatiquement pour chaque paramètre, SGD utilise un learning rate global identique pour tous les poids. Pour obtenir de bonnes performances avec SGD, il est indispensable d’utiliser un planning de learning rate (learning rate schedule) qui réduit progressivement le learning rate au cours de l’entraînement.

Les schedules les plus courants

Le setup le plus fiable pour SGD en vision par ordinateur : un learning rate initial de 0.1, un momentum de 0.9, un weight decay de 1e-4, et un cosine annealing sur 90 à 300 epochs. C’est la « recette » utilisée pour entraîner ResNet sur ImageNet, et elle reste la référence pour la majorité des architectures convolutionnelles.

Hyperparamètres de SGD

SGD vs Adam : le grand débat

Le choix entre SGD et Adam est l’une des décisions les plus débattues en deep learning. Voici la comparaison factuelle.

Le verdict est nuancé. Pour la classification d’images avec des CNNs (ResNet, EfficientNet, ConvNeXt), SGD avec momentum de Nesterov et un cosine schedule reste le choix qui maximise l’accuracy en test. Certaines équipes démarrent l’entraînement avec Adam pour la convergence rapide, puis passent à SGD pour la phase finale de fine-tuning.

Pour le NLP, les Transformers, et la plupart des autres tâches, AdamW est le choix évident. SGD converge trop lentement sur ces architectures et nécessite un réglage trop minutieux du learning rate.

Pourquoi SGD généralise-t-il mieux en vision ?

Plusieurs hypothèses expliquent cet avantage :

Le bruit implicite de SGD agit comme un régulariseur. Le gradient estimé sur un mini-batch n’est qu’une approximation du vrai gradient. Ce bruit empêche le modèle de sur-apprendre les détails spécifiques du dataset d’entraînement.

SGD trouve des minima plus plats. La recherche suggère que SGD converge vers des minima « plats » (flat minima) du paysage de perte, qui correspondent à des régions de l’espace des paramètres robustes aux perturbations. Ces minima généralisent mieux. Adam, en adaptant finement le learning rate par paramètre, peut converger vers des minima plus « pointus » qui performent bien sur l’entraînement mais moins bien en test.

Le learning rate uniforme force une exploration plus large. En appliquant le même learning rate à tous les paramètres, SGD explore l’espace des paramètres de façon plus homogène, ce qui peut aider à trouver de meilleures solutions globales.

Implémentation pratique

SGD avec PyTorch

import torch
import torch.optim as optim

model = MonModele()

# SGD basique (rarement optimal)
optimizer = optim.SGD(model.parameters(), lr=0.01)

# SGD avec Momentum de Nesterov (recommandé)
optimizer = optim.SGD(
    model.parameters(),
    lr=0.1,
    momentum=0.9,
    nesterov=True,
    weight_decay=1e-4
)

# Cosine Annealing Schedule
scheduler = optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=200,         # nombre total d'epochs
    eta_min=1e-6       # learning rate minimum
)

# Boucle d'entraînement
for epoch in range(200):
    for batch in dataloader:
        optimizer.zero_grad()
        loss = criterion(model(batch.x), batch.y)
        loss.backward()
        optimizer.step()
    scheduler.step()   # ajuster le LR à chaque epoch

SGD avec Keras

import keras

# SGD avec Momentum de Nesterov
optimizer = keras.optimizers.SGD(
    learning_rate=0.1,
    momentum=0.9,
    nesterov=True
)

model.compile(
    optimizer=optimizer,
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Avec cosine decay schedule
lr_schedule = keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=0.1,
    decay_steps=total_steps,
    alpha=1e-6    # learning rate minimum (fraction du LR initial)
)
optimizer = keras.optimizers.SGD(
    learning_rate=lr_schedule,
    momentum=0.9,
    nesterov=True
)

La recette ImageNet (ResNet-50)

Voici la configuration standard qui atteint environ 76-77 % de top-1 accuracy sur ImageNet avec ResNet-50, et qui sert de baseline reproductible :

# Configuration standard ResNet-50 / ImageNet
optimizer = optim.SGD(
    model.parameters(),
    lr=0.1,              # learning rate initial
    momentum=0.9,
    weight_decay=1e-4,
    nesterov=True
)

# Step decay : diviser le LR par 10 aux epochs 30, 60, 90
scheduler = optim.lr_scheduler.MultiStepLR(
    optimizer,
    milestones=[30, 60, 90],
    gamma=0.1
)

# Entraînement sur 90 epochs
# Batch size : 256 (ou plus avec warmup et scaling linéaire)

Les recettes plus modernes (comme celle de PyTorch pour les « training recipes » de TorchVision) utilisent un cosine annealing, un warmup de 5 epochs, un weight decay de 0.05 avec AdamW ou SGD, et atteignent plus de 80 % de top-1 accuracy avec le même ResNet-50.

SGD à grande échelle : entraînement distribué

SGD est naturellement adapté à l’entraînement distribué. Le gradient calculé sur chaque GPU peut être moyenné (all-reduce) avant la mise à jour, ce qui équivaut mathématiquement à entraîner avec un batch size plus grand.

La règle de scaling linéaire

Quand vous multipliez le batch size par k (en ajoutant k GPU), multipliez le learning rate par k. Cette règle simple, validée empiriquement par Goyal et al. (2017), fonctionne jusqu’à des batch sizes d’environ 8192 sur ImageNet.

Au-delà de 8192, le scaling linéaire ne suffit plus. Des techniques comme LARS (Layer-wise Adaptive Rate Scaling) ou LAMB (Layer-wise Adaptive Moments-based optimizer for Batch training) ajustent le learning rate par couche pour permettre des batch sizes encore plus grands (32k, 64k).

Gradient accumulation

Si vous n’avez pas assez de GPU pour un grand batch size, l’accumulation de gradient simule un batch plus grand : on accumule les gradients sur N itérations avant de faire une mise à jour. Le résultat est mathématiquement équivalent à un batch N fois plus grand.

accumulation_steps = 4  # simule batch_size * 4

for i, batch in enumerate(dataloader):
    loss = criterion(model(batch.x), batch.y)
    loss = loss / accumulation_steps  # normaliser la loss
    loss.backward()                    # accumuler les gradients

    if (i + 1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

Forces et limites de SGD

Les forces de SGD

Meilleure généralisation en vision. Sur les benchmarks de classification d’images (ImageNet, CIFAR-10/100), SGD avec momentum reste compétitif voire supérieur à Adam, même avec des architectures modernes comme ConvNeXt. C’est toujours l’optimiseur utilisé dans de nombreux papiers de vision qui rapportent des résultats state-of-the-art.

Faible consommation mémoire. SGD ne stocke qu’un seul vecteur d’état par paramètre (la vélocité du momentum). Pour un modèle de 7 milliards de paramètres, c’est 28 Go de mémoire en FP32 pour les états de l’optimiseur, contre 56 Go pour Adam.

Comportement bien compris théoriquement. SGD est l’un des algorithmes d’optimisation les plus étudiés. Ses propriétés de convergence sont bien connues pour les fonctions convexes, et son comportement en deep learning est largement documenté.

Simplicité d’implémentation. L’algorithme tient en quelques lignes. Il n’y a pas de mécanisme adaptatif complexe, pas de correction de biais, pas d’estimation de moments d’ordre deux.

Le bruit est une feature. Le caractère stochastique de SGD (le gradient est une estimation bruitée) agit comme un régulariseur implicite qui aide à la généralisation. Ce bruit est directement contrôlable via le batch size.

Les limites de SGD

Sensibilité au learning rate. C’est le problème principal. Un learning rate mal choisi (et mal schedulé) peut rendre SGD inutilisable. Contrairement à Adam où le défaut de 0.001 « marche souvent », SGD exige un réglage empirique du LR initial et du schedule de décroissance.

Convergence lente sur certaines architectures. Sur les Transformers et les grands modèles de langage, SGD converge beaucoup plus lentement qu’Adam. Le learning rate uniforme ne s’adapte pas bien aux gradients de magnitudes très différentes entre les couches d’attention et les couches feed-forward.

Inefficace avec les gradients épars. En NLP, beaucoup de paramètres (notamment les embeddings) ne reçoivent des gradients que pour une fraction des exemples. SGD met à jour ces paramètres avec le même learning rate que les autres, ce qui est sous-optimal.

Le réglage du schedule ajoute de la complexité. Choisir le bon schedule (step decay, cosine, one-cycle), les bonnes milestones, et le bon LR minimum est un art en soi. C’est du temps que vous ne passez pas sur l’architecture ou les données.

Quand utiliser SGD

Utilisez SGD + Momentum + Nesterov quand :

Vous entraînez un CNN sur un dataset d’images (classification, détection, segmentation). Vous cherchez la meilleure accuracy en test possible et vous êtes prêt à investir du temps dans le réglage des hyperparamètres. Vous reproduisez des résultats publiés dans des papiers de vision qui utilisent SGD. Votre modèle est très grand et la mémoire GPU est un facteur limitant (SGD utilise 50 % moins de mémoire qu’Adam pour les états de l’optimiseur).

Ne pas utiliser SGD quand :

Vous entraînez un Transformer, un LLM, ou un modèle NLP (utilisez AdamW). Vous voulez itérer rapidement et ne pouvez pas passer du temps sur le réglage du learning rate (utilisez Adam). Vos données produisent des gradients très épars. Vous faites du fine-tuning d’un modèle pré-entraîné en NLP (AdamW est le standard).

Variantes avancées de SGD

Erreurs courantes avec SGD

Utiliser SGD sans momentum. Le SGD vanille (momentum=0) est presque toujours inférieur à SGD + Momentum. Activez le momentum à 0.9 et le Nesterov systématiquement.

Démarrer avec un learning rate trop faible. Avec SGD + Momentum, un LR initial de 0.1 est courant pour les CNNs. Ne pas confondre avec Adam où 0.001 est le défaut. Si vous venez d’Adam, multipliez votre intuition du LR par 100.

Oublier le learning rate schedule. Sans schedule, SGD ne converge jamais proprement. Le LR constant peut fonctionner en début d’entraînement, mais la phase de fine-tuning exige un LR réduit pour atteindre un bon minimum.

Ne pas shuffler les données. Si les données sont présentées dans un ordre significatif (par classe, par date, par difficulté), le gradient sera biaisé. Activez toujours le shuffle dans votre DataLoader (shuffle=True).

Ignorer le warmup pour les grands batchs. Avec un batch size > 256, les premières itérations sans warmup produisent des mises à jour instables. Le warmup linéaire (5 epochs) est une protection indispensable.

Négliger le weight decay. Avec SGD, un weight decay de 1e-4 à 5e-4 est standard pour les CNNs. Sans régularisation, le modèle risque de sur-apprendre, surtout sur les petits datasets.