Accueil › Glossaire › Gradient Descent

Gradient Descent (Descente de Gradient)

La descente de gradient (gradient descent) est un algorithme d’optimisation itératif qui ajuste les paramètres d’un modèle en se déplaçant dans la direction opposée au gradient de la fonction de perte, afin d’en trouver le minimum.

C’est l’algorithme qui permet aux modèles de machine learning d’apprendre. De la régression linéaire la plus simple au plus grand LLM, tous partagent le même mécanisme fondamental : calculer dans quelle direction ajuster les poids pour réduire l’erreur, puis faire un pas dans cette direction. Gradient descent est ce mécanisme. Historiquement attribué à Augustin-Louis Cauchy (1847), l’algorithme a pris une importance capitale avec l’essor du deep learning et la rétropropagation dans les années 1980.

L’intuition : descendre une montagne les yeux bandés

L’analogie la plus classique reste la plus parlante. Imaginez que vous êtes au sommet d’une montagne brumeuse, sans carte, et que vous voulez atteindre le point le plus bas (la vallée). Vous ne voyez pas le paysage, mais vous sentez l’inclinaison du terrain sous vos pieds. Votre stratégie : à chaque pas, évaluer la pente locale et avancer dans la direction de la descente la plus raide.

La descente de gradient fonctionne exactement de cette façon :

La montagne = le paysage de la fonction de perte. Chaque point correspond à un jeu de paramètres (poids) du modèle, et l’altitude représente l’erreur du modèle pour ces paramètres.

Votre position = les valeurs actuelles des paramètres du modèle.

La pente = le gradient, le vecteur qui indique la direction de la montée la plus raide. En prenant la direction opposée (le gradient négatif), on descend.

La taille de vos pas = le learning rate (taux d’apprentissage). Trop grand : vous sautez par-dessus la vallée. Trop petit : vous mettez des heures à arriver en bas.

La vallée (minimum) = l’ensemble de paramètres qui minimise l’erreur du modèle.

La formule fondamentale

L’algorithme tient en une seule équation de mise à jour :

θ_{t+1} = θ_t - α · ∇θ L(θ_t)

Où :

θ représente l’ensemble des paramètres (poids et biais) du modèle. Pour un réseau de neurones profond, ce vecteur peut contenir des milliards de valeurs.

α est le learning rate (typiquement entre 0.0001 et 0.1). Il contrôle l’amplitude de chaque mise à jour.

∇θ L(θ_t) est le gradient de la fonction de perte L par rapport aux paramètres θ. C’est un vecteur de la même dimension que θ, où chaque composante indique dans quelle direction et avec quelle intensité ce paramètre spécifique devrait changer pour augmenter la perte. En soustrayant ce gradient (multiplié par α), on va dans la direction qui réduit la perte.

Le signe « moins » est crucial : le gradient pointe vers la montée la plus raide, et on veut descendre.

Les trois variantes de la descente de gradient

La différence entre les variantes tient à la quantité de données utilisée pour estimer le gradient à chaque itération.

Batch Gradient Descent (descente de gradient complète)

Le gradient est calculé sur l’intégralité du dataset :

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

Avantages : le gradient est une estimation exacte (pas d’approximation), la trajectoire d’optimisation est lisse et prévisible, la convergence est stable.

Inconvénients : chaque mise à jour nécessite de traiter tout le dataset, ce qui est prohibitif pour les datasets modernes (des millions d’exemples). La mémoire nécessaire pour stocker les gradients de tout le dataset peut dépasser la capacité du GPU. Inutilisable pour l’apprentissage en ligne (données arrivant en flux).

Usage : petit datasets, fonctions convexes simples, cas théoriques. Rarement utilisé en deep learning.

Stochastic Gradient Descent (SGD)

Le gradient est calculé sur un seul exemple tiré aléatoirement :

θ = θ - α · ∇θ L(θ, xᵢ, yᵢ)    # i tiré aléatoirement

Avantages : chaque itération est très rapide. Le bruit stochastique peut aider à échapper aux minima locaux et aux points-selle. Compatible avec l’apprentissage en ligne.

Inconvénients : le gradient estimé sur un seul exemple a une forte variance, ce qui produit une trajectoire très bruitée. La convergence est erratique et peut nécessiter un grand nombre d’itérations.

Usage : rarement utilisé sous sa forme pure. Le terme « SGD » dans les frameworks désigne en réalité le mini-batch SGD.

Mini-batch Gradient Descent (le standard)

Le gradient est calculé sur un petit lot (mini-batch) de B exemples :

θ = θ - α · (1/B) · Σⱼ₌₁ᴮ ∇θ L(θ, xⱼ, yⱼ)    # B exemples du mini-batch

Avantages : compromis optimal entre la stabilité du batch complet et la vitesse du SGD pur. Les opérations matricielles sur un batch sont hautement parallélisables sur GPU, ce qui exploite pleinement le matériel moderne. La variance du gradient est réduite par rapport au SGD pur (moyennage sur B exemples).

Inconvénients : introduit un hyperparamètre supplémentaire (la taille du batch). Le choix du batch size influence la qualité de la convergence et la généralisation.

Usage : c’est le standard universel en deep learning. Tailles courantes : 32, 64, 128, 256, jusqu’à 8192+ pour l’entraînement distribué.

Le learning rate : l’hyperparamètre clé

Le learning rate α est le paramètre le plus critique de la descente de gradient. Il contrôle la taille des pas vers le minimum.

Learning rate trop élevé : les mises à jour sont trop grandes. Le modèle saute par-dessus le minimum, oscillant sans converger. Dans les cas extrêmes, la perte diverge vers l’infini (explosion des gradients).

Learning rate trop faible : la convergence est extrêmement lente. Le modèle peut rester bloqué dans un minimum local ou un point-selle, incapable de progresser avec des pas si petits.

Learning rate optimal : le modèle converge rapidement vers un bon minimum. En pratique, cet optimum n’est pas fixe : il change au cours de l’entraînement. C’est pourquoi les learning rate schedules (décroissance progressive du LR) sont essentiels.

Les défis de la descente de gradient

Minima locaux et points-selle

Pour les fonctions non convexes (comme les paysages de perte des réseaux de neurones profonds), gradient descent ne garantit pas de trouver le minimum global. L’algorithme peut se retrouver piégé dans un minimum local (un creux qui n’est pas le plus profond) ou un point-selle (un point où le gradient est nul mais qui n’est ni un minimum ni un maximum).

En pratique, le problème des minima locaux est moins grave qu’on ne le pensait. La recherche récente montre que dans les espaces de très haute dimension (des milliards de paramètres), les minima locaux tendent à avoir des valeurs de perte similaires au minimum global. Les points-selle sont un problème plus courant, mais le momentum et les optimiseurs adaptatifs comme Adam les traversent efficacement.

Gradients évanescents et explosifs

Dans les réseaux profonds, la rétropropagation propage le gradient à travers de nombreuses couches en le multipliant successivement par les dérivées de chaque couche.

Gradients évanescents : si ces dérivées sont systématiquement inférieures à 1, le gradient diminue exponentiellement en traversant les couches. Les premières couches du réseau ne reçoivent pratiquement plus de signal de mise à jour. Elles cessent d’apprendre. C’est le problème historique qui a freiné l’entraînement des réseaux profonds pendant des années. Des solutions architecturales comme les connexions résiduelles (ResNet) et des fonctions d’activation comme ReLU l’atténuent considérablement.

Gradients explosifs : inversement, si les dérivées sont supérieures à 1, le gradient croît exponentiellement. Les mises à jour deviennent énormes, produisant des valeurs NaN dans les poids. Le gradient clipping (limiter la norme du gradient à une valeur maximale, typiquement 1.0) est la solution standard.

Ravins et surfaces mal conditionnées

Le paysage de perte d’un réseau de neurones contient souvent des « ravins » : des régions étroites et allongées où la courbure est très différente selon les directions. Le gradient descent vanille oscille perpendiculairement au fond du ravin au lieu de le descendre, ce qui ralentit considérablement la convergence. Le momentum et les optimiseurs adaptatifs résolvent ce problème en accumulant l’inertie dans la direction du fond du ravin.

Sensibilité à l’échelle des features

Si les features d’entrée ont des échelles très différentes (par exemple, l’âge en années et le revenu en milliers d’euros), les gradients par rapport aux différents paramètres auront des magnitudes très différentes. Un learning rate unique sera trop grand pour certains paramètres et trop petit pour d’autres. La normalisation des features (standardisation, batch normalization) et les optimiseurs adaptatifs (Adam, qui adapte le LR par paramètre) adressent ce problème.

Des variantes de base aux optimiseurs modernes

La descente de gradient a engendré une famille entière d’optimiseurs, chacun résolvant un défaut spécifique.

Tous ces optimiseurs sont des variantes de la descente de gradient. Ils ajoutent de l’intelligence à la mise à jour de base (θ = θ – α·∇L) en mémorisant les gradients passés (momentum), en adaptant le learning rate par paramètre (AdaGrad, RMSProp), ou en combinant les deux (Adam).

Comment le gradient est-il calculé ?

En machine learning, le gradient de la fonction de perte par rapport aux paramètres est calculé par rétropropagation (backpropagation). C’est l’application de la règle de la chaîne du calcul différentiel, couche par couche, en partant de la sortie vers l’entrée du réseau.

Les frameworks modernes (PyTorch, TensorFlow/Keras, JAX) implémentent la différentiation automatique (autograd). Vous définissez le réseau et la loss, vous appelez loss.backward() (PyTorch) ou tape.gradient() (TensorFlow), et le framework calcule automatiquement tous les gradients.

# PyTorch : le gradient est calculé automatiquement
loss = criterion(model(x), y)    # forward pass + calcul de la loss
loss.backward()                   # backward pass = calcul des gradients
optimizer.step()                  # mise à jour des poids (descente de gradient)

Vous n’avez jamais besoin de calculer les gradients à la main. Mais comprendre ce qui se passe « sous le capot » est essentiel pour diagnostiquer les problèmes d’entraînement (gradients évanescents, NaN, convergence lente).

Implémentation depuis zéro en Python

Pour bien comprendre le mécanisme, voici une implémentation minimaliste de la descente de gradient sur une régression linéaire :

import numpy as np

# Données synthétiques : y = 3x + 2 + bruit
np.random.seed(42)
X = np.random.randn(100, 1)
y = 3 * X + 2 + 0.5 * np.random.randn(100, 1)

# Paramètres initiaux (aléatoires)
w = np.random.randn(1, 1)   # poids
b = np.zeros((1, 1))         # biais
lr = 0.1                     # learning rate
epochs = 100

for epoch in range(epochs):
    # Forward pass : prédiction
    y_pred = X @ w + b

    # Calcul de la loss (MSE)
    loss = np.mean((y_pred - y) ** 2)

    # Calcul des gradients (dérivées partielles)
    dw = (2 / len(X)) * (X.T @ (y_pred - y))   # dL/dw
    db = (2 / len(X)) * np.sum(y_pred - y)       # dL/db

    # Mise à jour des paramètres (descente de gradient)
    w = w - lr * dw
    b = b - lr * db

    if epoch % 20 == 0:
        print(f"Epoch {epoch}: loss={loss:.4f}, w={w[0,0]:.4f}, b={b[0,0]:.4f}")

# Résultat attendu : w ≈ 3.0, b ≈ 2.0

Ce code montre le cycle fondamental : forward pass → loss → gradient → mise à jour. Tout le deep learning est une version plus complexe de cette boucle.

La descente de gradient en pratique

Normaliser les données d’entrée

La descente de gradient converge beaucoup plus vite quand les features sont sur des échelles similaires. Standardisez les données (moyenne 0, écart-type 1) ou normalisez-les dans un intervalle [0, 1] avant l’entraînement. Dans les réseaux profonds, la batch normalization remplit un rôle similaire entre les couches.

Choisir le bon optimiseur

Pour un nouveau projet, commencez avec AdamW (learning rate = 3e-4, weight decay = 0.01). Si vous travaillez sur de la vision par ordinateur et cherchez les meilleurs résultats en accuracy, testez SGD + Momentum + Nesterov (learning rate = 0.1, momentum = 0.9) avec un cosine annealing schedule.

Diagnostiquer les problèmes

La loss ne diminue pas : le learning rate est probablement trop élevé (les mises à jour dépassent le minimum) ou trop faible (pas assez de progrès par itération). Essayez des valeurs de 0.001, 0.01, 0.1.

La loss explose (NaN) : gradients explosifs. Réduisez le learning rate et/ou activez le gradient clipping.

La loss stagne après une baisse initiale : vous êtes peut-être dans un plateau ou un point-selle. Augmentez le momentum, essayez un optimiseur adaptatif (Adam), ou vérifiez que votre learning rate schedule décroît correctement.

Bon train loss, mauvais test loss : c’est de l’overfitting, pas un problème d’optimisation. Ajoutez de la régularisation (dropout, weight decay, data augmentation).

Applications de la descente de gradient

La descente de gradient est utilisée dans pratiquement toutes les branches du machine learning :

Réseaux de neurones et deep learning : c’est le seul mécanisme d’optimisation viable pour entraîner des modèles avec des milliards de paramètres. Les LLMs comme GPT, Claude ou Gemini sont tous entraînés par descente de gradient (via AdamW et rétropropagation).

Régression linéaire et logistique : bien qu’une solution analytique existe pour la régression linéaire (équation normale), la descente de gradient est préférable dès que le dataset est grand ou que les features sont nombreuses.

Classification : les SVM avec noyaux linéaires, les régresseurs logistiques, et les classificateurs multiclasses sont tous optimisés par descente de gradient.

Apprentissage par renforcement : les méthodes de policy gradient et les DQN utilisent des variantes de la descente de gradient pour optimiser les réseaux de neurones sous-jacents.

Systèmes de recommandation : les modèles de factorisation matricielle et les réseaux de neurones collaboratifs utilisent SGD pour ajuster les embeddings d’utilisateurs et d’items.

Au-delà du premier ordre : méthodes avancées

La descente de gradient classique est un algorithme de « premier ordre » : elle n’utilise que le gradient (les dérivées premières). Des méthodes plus avancées utilisent aussi la courbure de la fonction (les dérivées secondes, via la matrice Hessienne).

Méthodes de Newton : utilisent la Hessienne pour prendre des pas plus intelligents. Convergent en très peu d’itérations, mais chaque itération est extrêmement coûteuse (la Hessienne d’un modèle à N paramètres est une matrice N×N).

L-BFGS (Limited-memory BFGS) : approxime la Hessienne sans la stocker explicitement. Utilisé pour les problèmes d’optimisation de taille modérée (quelques milliers de paramètres). PyTorch l’implémente via torch.optim.LBFGS.

Méthodes de quasi-Newton : approximent la Hessienne à partir de l’historique des gradients. Plus efficaces que le gradient descent pur, mais difficilement parallélisables sur GPU pour les grands modèles.

En pratique, pour le deep learning, les méthodes de premier ordre (SGD, Adam) dominent. Le coût de calcul de la Hessienne (même approximée) est trop élevé pour des modèles de millions ou milliards de paramètres, et les optimiseurs adaptatifs capturent une partie de l’information de courbure via leur estimation du second moment.

Conditions de convergence

Pour les fonctions convexes (un seul minimum global, comme en régression linéaire), gradient descent converge vers l’optimum global si le learning rate est suffisamment petit et décroît selon certaines conditions (conditions de Robbins-Monro).

Pour les fonctions non convexes (le cas de tous les réseaux de neurones profonds), gradient descent converge vers un point stationnaire (gradient ≈ 0), qui peut être un minimum local, un maximum local, ou un point-selle. Aucune garantie de trouver le minimum global n’existe en théorie. En pratique, cela fonctionne remarquablement bien pour plusieurs raisons :

Les espaces de haute dimension contiennent très peu de « mauvais » minima locaux. La plupart des minima locaux ont des valeurs de perte proches du minimum global.

Le bruit du mini-batch SGD aide à échapper aux points-selle et aux minima locaux peu profonds.

Les architectures modernes (connexions résiduelles, normalisation) lissent le paysage de perte et facilitent l’optimisation.