Vanishing Gradient

Le problème du gradient évanescent survient lorsque les gradients que la rétropropagation transmet depuis la perte vers les premières couches d’un réseau neuronal profond diminuent de façon géométrique avec la profondeur, si bien que les premières couches reçoivent des mises à jour trop faibles pour apprendre quoi que ce soit. Comme le gradient d’une couche est le produit des dérivées locales de toutes les couches situées au-dessus, un réseau dont chaque couche réduit le gradient à moins de 1 peut perdre plusieurs ordres de grandeur entre la sortie et l’entrée. Sepp Hochreiter a analysé cet effet dans son mémoire de maîtrise de 1991, et le problème a rendu difficiles à entraîner les réseaux profonds à propagation avant et les réseaux neuronaux récurrents (RNN) jusqu’à l’apparition de meilleures fonctions d’activation, initialisations et architectures.

Pourquoi les gradients s’évanouissent#

La rétropropagation applique la règle de la chaîne : le gradient qui atteint une couche correspond donc au gradient amont multiplié par la matrice de poids et la dérivée de la fonction d’activation de chaque couche suivante. La dérivée de la sigmoïde ne dépasse jamais 0.25, sa valeur pour une entrée de 0, et tend vers 0 lorsque l’unité sature avec des entrées fortement positives ou négatives. La dérivée de la tangente hyperbolique atteint un maximum de 1 et tend elle aussi vers 0 en cas de saturation. Vingt couches sigmoïdes multiplient donc le gradient par un facteur d’au plus 0.25²⁰, inférieur à 10⁻¹², avant même de tenir compte des poids. L’échelle des poids compte autant que la fonction d’activation : Glorot et Bengio ont attribué une grande partie de la difficulté à l’initialisation et proposé des variances de poids mises à l’échelle en fonction du nombre d’entrées et de sorties de chaque couche, afin que les variances des activations et des gradients restent à peu près constantes d’une couche à l’autre.

Il est facile de mesurer cet effet en comparant l’amplitude des gradients des poids au sommet et à la base d’un réseau sigmoïde de 20 couches, avec et sans connexions résiduelles :

import torch

torch.manual_seed(0)
x = torch.randn(64, 32)

# The same 20-layer sigmoid network, without and with residual shortcuts
for residual in (False, True):
    layers = [torch.nn.Linear(32, 32) for _ in range(20)]
    h = x
    for layer in layers:
        out = torch.sigmoid(layer(h))
        h = h + out if residual else out
    h.sum().backward()

    # Compare the weight-gradient size at the last layer and the first layer
    last, first = layers[-1].weight.grad.norm(), layers[0].weight.grad.norm()
    print(f"residual={residual}: layer 20 gradient {last:.1e}, layer 1 gradient {first:.1e}")

Sans raccourcis, la norme du gradient de la dernière couche est de 2.5e+02 et celle de la première couche de 4.2e-15, soit environ 17 ordres de grandeur de moins : les poids de la première couche ne changent donc pratiquement jamais. Avec des raccourcis résiduels, le gradient de la première couche est de 5.6e+01, soit environ 38 fois moins que celui de la dernière couche, qui est de 2.1e+03.

Gradients évanescents et gradients explosifs#

Les deux problèmes proviennent de la même multiplication répétée. Les gradients évanescents bloquent silencieusement l’apprentissage : la perte continue de diminuer grâce aux dernières couches, tandis que les premières restent proches de leur initialisation aléatoire. Les gradients explosifs augmentent au contraire de façon géométrique et se manifestent par des pics de perte et des valeurs NaN. L’écrêtage du gradient plafonne la norme d’un gradient explosif avant chaque mise à jour et n’a aucun effet sur un gradient déjà évanoui. Le problème des ReLU mortes est une défaillance connexe : l’entrée d’une unité ReLU reste négative, son gradient est donc exactement égal à 0 et l’unité cesse d’apprendre.

Comment éviter les gradients évanescents#

La solution la plus utilisée est la connexion résiduelle, le raccourci identité au cœur des réseaux résiduels (ResNets). Un bloc résiduel produit x + F(x) ; son gradient par rapport à x vaut donc 1 plus la dérivée de F, et le chemin de raccourci transmet le gradient amont sans le modifier.

Les raccourcis résiduels permettent aux ResNets de s’entraîner avec plus de 100 couches, et on les retrouve dans presque toutes les architectures profondes modernes, des transformeurs à YOLO26, dont les blocs C3k2 enveloppent des goulots d’étranglement résiduels, tandis que ses blocs convolutifs standard associent la normalisation par lots aux fonctions d’activation SiLU.

D’autres solutions fonctionnent en complément des connexions résiduelles :

• Fonctions d’activation non saturantes : ReLU a une dérivée exactement égale à 1 pour les entrées positives, et Leaky ReLU ainsi que SiLU conservent également un gradient non nul pour les entrées négatives.
• Initialisation mise à l’échelle : l’initialisation Xavier (Glorot) convient aux couches tanh et sigmoïdes, et l’initialisation He double la variance des poids pour compenser la mise à zéro de la moitié des entrées par ReLU.
• Couches de normalisation : la normalisation par lots et la normalisation par couche maintiennent les préactivations près d’une moyenne nulle et d’une variance unitaire, à l’écart des zones plates des fonctions d’activation saturantes.
• Architectures récurrentes à portes : les réseaux à mémoire à long et court terme (LSTM) et les unités récurrentes à portes (GRU) transmettent leur état par des mises à jour additives contrôlées par des portes plutôt que par des multiplications répétées. Le LSTM d’origine pouvait ainsi franchir des intervalles de plus de 1 000 pas temporels.