Gradient qui disparaît (Vanishing Gradient) : Pourquoi le deep learning souffre de « amnésie à court terme »
1. Introduction : "Chef, je n’entends pas votre voix !"
La semaine dernière, nous avons vu comment l’apprentissage se fait en transmettant l’erreur (Loss) de la couche de sortie jusqu’à la couche d’entrée grâce à la rétropropagation (Backpropagation). En théorie, plus la couche est profonde (Deep), plus le réseau devrait être capable de résoudre des problèmes complexes.
Cependant, jusqu’au début des années 2000, le deep learning était dans l’ombre. Empiler 10, 20 couches entraînait souvent une performance qui chute ou un apprentissage qui ne démarre même pas.
Voici la situation :
- PDG (couche de sortie) : "Hé ! Pourquoi la qualité du produit est si mauvaise ! (Loss)"
- Directeur → Chef de service → Responsable… : Le signal doit descendre vers le bas,
- Nouvel employé (couche d’entrée) : "...? Que disait le PDG ? Je n’ai rien entendu."
Les paramètres de la couche d’entrée, qui gèrent les fondations, ne sont pas mis à jour. C’est exactement le problème de gradient qui disparaît (Vanishing Gradient).
2. Analyse des causes : le coupable est « Sigmoid » et la multiplication
Pourquoi le signal disparaît-il ? Le coupable est la fonction d’activation Sigmoid que nous avons longtemps considéré comme la norme, ainsi que la règle de la chaîne (Chain Rule) et ses propriétés mathématiques inévitables.
(1) Trahison de Sigmoid : "Un filtre trop serré"
Les premiers chercheurs en deep learning adoraient le Sigmoid. Il ne produisait que des valeurs entre 0 et 1, semblable à la probabilité d’activation d’un neurone. Mais du point de vue du développeur, le Sigmoid est un compressor qui étouffe les entrées.
- Problème 1 : borne maximale du gradient (Max Gradient = 0.25)
- En dérivant la fonction Sigmoid, on découvre que la valeur maximale du gradient est seulement 0,25 (et seulement à x = 0).
- Si l’entrée x est légèrement plus grande ou plus petite, le gradient tend vers 0.
- C’est comme avoir le volume du micro à son minimum : peu importe le bruit, on ne transmet que des chuchotements.
(2) Tragédie de la règle de la chaîne : "0,25 à la puissance N"
Le cœur de l’apprentissage est : poids = poids – (taux d’apprentissage × gradient). Le gradient doit exister pour que les poids changent.
La rétropropagation multiplie les dérivées de chaque couche, de la sortie vers l’entrée.
Supposons 30 couches. Même si chaque couche donne le maximum (0,25), le résultat est catastrophique.
$$0.25 \times 0.25 \times \dots \times 0.25 \,(30\,fois) \approx 0.0000000000000000008$$
- Résultat : le gradient près de la couche d’entrée devient plus petit que la précision numérique, donc 0 (Underflow).
- Conséquence : l’équation de mise à jour des poids devient
w = w - 0. L’apprentissage s’arrête. - En termes de développeur, c’est comme un réseau avec un taux de perte de paquets de 99,99 %.
3. Solution 1 : ReLU – "Passer de l’analogique au numérique"
Le héros de ce problème est une simple fonction : ReLU (Rectified Linear Unit).
Lorsque le professeur Geoffrey Hinton l’a introduit, tout le monde s’est demandé : "C’est vraiment si simple ?"
(1) Révolution de la dérivée : "1 ou 0"
Le code ReLU est :
def relu(x):
return max(0, x)
Sa dérivée est claire.
- x > 0 (actif) : gradient = 1.
- x ≤ 0 (inactif) : gradient = 0.
Pourquoi c’est important ? Dans la partie positive, le signal ne diminue jamais, même après multiplication.
$$1 \times 1 \times 1 \times \dots \times 1 = 1$$
Le Sigmoid qui réduisait le signal à 0,25, ReLU le laisse sans perte. Le cri du PDG atteint le nouvel employé vivement (Gradient = 1).
(2) Optimisation des performances : exp() vs if
Du point de vue du développeur, le Sigmoid utilise exp(x), une opération exponentielle coûteuse en CPU/GPU. ReLU ne fait qu’une comparaison simple (if x > 0). C’est incomparablement plus rapide.
(3) Attention : Dying ReLU
Il y a un inconvénient : si l’entrée est négative, le gradient devient 0 et le neurone « meurt » (Dying ReLU). Des variantes comme Leaky ReLU donnent un petit gradient même pour les négatifs.
4. Solution 2 : ResNet (Réseau Résiduel) – "Ouvrir une hotline dédiée"
Grâce à ReLU, on peut empiler 20‑30 couches. Mais l’envie humaine est sans limite : 100, 1000 couches. L’apprentissage s’arrête alors. C’est là qu’intervient le sauveur : ResNet (Residual Network).
(1) Idée : "Apprendre uniquement la différence"
Un réseau traditionnel essaie de transformer l’entrée x en une sortie H(x). ResNet introduit un Skip Connection qui modifie l’équation :
$$Output = F(x) + x$$
Ce n’est pas une demande de « créez tout à partir de zéro ». C’est plutôt : "Je garderai l’original x, vous ne faites que calculer la différence (résiduel) !"
(2) Autoroute de la rétropropagation (Gradient Superhighway)
En dérivant, l’addition a une propriété agréable :
$$\frac{\partial Output}{\partial x} = \frac{\partial F(x)}{\partial x} + 1$$
Le +1 est crucial. Même si le gradient de F(x) disparaît, on conserve au moins 1 qui passe à l’entrée.
- Avant : si le gradient se bloque, c’est fini.
- ResNet : un « shortcut » permet au gradient de traverser rapidement.
Cette architecture permet d’entraîner des réseaux de 152 couches (ResNet‑152) voire 1000 couches.
5. Conclusion : La victoire de l’ingénierie qui a mis fin à l’hiver du deep learning
Le problème du gradient qui disparaît semblait être une limite théorique. Mais en le décortiquant, on voit qu’il ne s’agissait pas d’une nouvelle formule mathématique, mais d’une approche ingénierie.
- ReLU : abandonner les opérations complexes, aller simple (linéaire).
- ResNet : ouvrir un raccourci quand le chemin principal est bloqué.
C’est une approche purement ingénierie.
Aujourd’hui, toutes les architectures modernes (Transformers, CNN, etc.) reposent sur ces deux piliers (fonctions ReLU et Skip Connections).
Lorsque vous concevez un modèle PyTorch et voyez return x + layer(x) dans la fonction forward, pensez à ceci :
"Ah, j’ai installé un garde-fou (Shortcut) pour que le gradient ne disparaisse pas. Je peux maintenant empiler des couches sans crainte !"
Aucun commentaire.