Un réseau récurrent simple peine à transporter l'information sur de nombreux pas de temps, car la multiplication répétée par la même matrice de poids fait s'évanouir ou exploser les gradients. Les cellules récurrentes à portes corrigent cela en ajoutant un état qui circule dans le temps par des mises à jour essentiellement additives, contrôlées par des portes apprises. Ce module construit la cellule à mémoire à long et court terme (LSTM) et l'unité récurrente à porte (GRU), plus légère, et compare les situations où privilégier l'une ou l'autre.

Une couche récurrente classique met à jour son état caché par $h_t = g(W_h h_{t-1} + W_x x_t + b)$. La rétropropagation de la perte à travers $T$ pas multiplie de nombreuses jacobiennes de cette application entre elles, de sorte que l'amplitude du gradient croît à peu près comme la puissance $T$-ième du rayon spectral du poids récurrent. En dessous de un elle s'évanouit, au-dessus de un elle explose, et dans les deux cas le réseau ne peut pas apprendre des dépendances qui s'étalent sur de nombreux pas.

L'idée des portes introduit un **état de cellule** distinct $c_t$ qui est mis à jour principalement par addition plutôt que par une multiplication matricielle complète. Lorsque la mise à jour laisse l'état de cellule précédent intact, le gradient de $c_t$ par rapport à $c_{t-1}$ est proche de l'identité, si bien que les signaux d'erreur remontent sur de longues portées sans diminuer. Ce chemin proche de l'identité est le **carrousel d'erreur constant**.

*Remarque :* le mot clé est additif. La récurrence multiplicative compose un facteur à chaque pas, tandis qu'un chemin additif laisse l'état persister par défaut et ne changer que lorsqu'une porte s'ouvre.

Tout au long, $[h_{t-1}, x_t]$ désigne la concaténation de l'état caché précédent et de l'entrée courante en un seul vecteur. Chaque porte est un vecteur dans $(0, 1)$ produit par une sigmoïde $\sigma$ appliquée à une application affine de cette concaténation, de sorte qu'une valeur de porte proche de $1$ laisse passer l'information et une valeur proche de $0$ la bloque.

La porte d'**oubli** $f_t$ décide de la part de l'ancien état de cellule à conserver, la porte d'**entrée** $i_t$ décide de la part du nouveau candidat à écrire, et la porte de **sortie** $o_t$ décide de la part de l'état de cellule à exposer comme état caché :

$$\boxed{ f_t = \sigma\!\left(W_f\,[h_{t-1}, x_t] + b_f\right), \quad i_t = \sigma\!\left(W_i\,[h_{t-1}, x_t] + b_i\right), \quad o_t = \sigma\!\left(W_o\,[h_{t-1}, x_t] + b_o\right) }$$

*Remarque :* les portes partagent la même forme fonctionnelle et ne diffèrent que par leurs paramètres appris. Le biais est explicite ici, exactement comme pour les couches à propagation avant des modules précédents, et n'est jamais intégré à la matrice de poids.

Une couche $\tanh$ propose une mise à jour **candidate** $\tilde{c}_t$, le nouveau contenu que la cellule pourrait stocker :

$$\boxed{ \tilde{c}_t = \tanh\!\left(W_c\,[h_{t-1}, x_t] + b_c\right) }$$

L'état de cellule est alors mis à jour en conservant une fraction contrôlée par une porte du passé et en ajoutant une fraction contrôlée par une porte du candidat, où $\odot$ est le produit élément par élément (de Hadamard) :

$$\boxed{ c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t }$$

Lorsque $f_t \approx 1$ et $i_t \approx 0$, la cellule copie simplement $c_{t-1}$, ce qui constitue le carrousel d'erreur constant : $\partial c_t / \partial c_{t-1} \approx \mathrm{diag}(f_t)$, de sorte que les gradients passent presque sans atténuation.

L'état caché est l'état de cellule écrasé, contrôlé par la porte de sortie :

$$\boxed{ h_t = o_t \odot \tanh(c_t) }$$

*Remarque :* l'état de cellule $c_t$ est la mémoire à long terme qui circule le long du carrousel, tandis que l'état caché $h_t$ est la vue filtrée exposée à la couche suivante et à la sortie de ce pas. C'est le fait de les garder distincts qui différencie le LSTM du GRU ci-dessous.

La porte de **réinitialisation** $r_t$ contrôle la part de l'état passé qui alimente le candidat, et la porte de **mise à jour** $z_t$ contrôle la part de l'état à rafraîchir :

$$\boxed{ r_t = \sigma\!\left(W_r\,[h_{t-1}, x_t] + b_r\right), \quad z_t = \sigma\!\left(W_z\,[h_{t-1}, x_t] + b_z\right) }$$

Le candidat utilise une version de l'état caché précédent contrôlée par la porte de réinitialisation, et le nouvel état est une interpolation contrôlée par une porte entre l'ancien état et le candidat :

$$\boxed{ \tilde{h}_t = \tanh\!\left(W\,[\,r_t \odot h_{t-1}, \; x_t\,]\right), \quad h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t }$$

*Remarque :* la forme interpolée lie les fractions de conservation et d'écriture par une seule porte : quel que soit le poids $z_t$ attribué au candidat, $1 - z_t$ est laissé au passé. Le LSTM fixe indépendamment sa fraction de conservation $f_t$ et sa fraction d'écriture $i_t$, ce qui représente une porte de plus et une matrice de plus.

Les deux cellules résolvent le problème de l'évanouissement du gradient grâce à un chemin d'état additif. Elles diffèrent par le nombre de portes qui portent ce chemin et par le fait que la mémoire à long terme soit ou non maintenue distincte de l'état exposé.

| Aspect | LSTM | GRU |

| --- | --- | --- |

| Portes | 3 (oubli, entrée, sortie) | 2 (réinitialisation, mise à jour) |

| État de cellule distinct | oui ($c_t$ et $h_t$) | non ($h_t$ unique) |

| Paramètres par unité | plus (quatre applications affines) | moins (trois applications affines) |

| Conservation et écriture | indépendantes ($f_t$, $i_t$) | liées ($z_t$ et $1 - z_t$) |

| À privilégier quand | dépendances longues, données et calcul abondants | données plus petites, entraînement plus rapide, précision similaire |

*Remarque :* en pratique, les deux atteignent souvent une précision comparable. Le GRU s'entraîne plus vite et généralise bien sur des ensembles de données plus petits, tandis que la capacité supplémentaire du LSTM peut aider sur des séquences très longues. Traitez ce choix comme un hyperparamètre à régler plutôt que comme une règle établie.

---