Les réseaux à propagation avant et les réseaux convolutifs transforment une entrée de taille fixe en une sortie en une seule passe, mais de nombreux problèmes se présentent sous forme de séquences dont la longueur varie et dont l'ordre importe (texte, audio, séries temporelles). Un réseau de neurones récurrent (RNN) traite une séquence pas à pas et propage un état caché vers l'avant, de sorte que les entrées passées influencent la sortie courante. Ce module introduit la récurrence, la cellule RNN de base, la façon dont elle est entraînée par rétropropagation à travers le temps, et pourquoi les gradients à longue portée ont tendance à s'évanouir ou à exploser.

- Expliquer pourquoi les données séquentielles ont besoin de mémoire et de partage de poids entre les pas de temps.

- Écrire la récurrence du RNN de base pour l'état caché et la sortie.

- Dérouler une cellule récurrente dans le temps et en lire les paramètres partagés.

- Dériver comment la rétropropagation à travers le temps (BPTT) accumule le gradient sur tous les pas.

- Diagnostiquer l'évanouissement et l'explosion des gradients à partir du produit des jacobiennes au fil du temps.

Une séquence est une liste ordonnée d'entrées $x_1, x_2, \dots, x_T$, où $T$ peut différer d'un exemple à l'autre. Un réseau à propagation avant du type vu dans les leçons précédentes attend un unique vecteur de taille fixe $a^{[0]} = x$, de sorte qu'il n'a aucun moyen naturel de consommer une entrée de longueur variable ni de se souvenir de ce qui précédait l'élément courant.

Deux idées corrigent cela. Premièrement, le réseau conserve un **état caché** (ou mémoire) $h_t$ qui résume tout ce qui est pertinent jusqu'au pas $t$. Deuxièmement, le réseau **partage** un unique jeu de paramètres à chaque pas, de sorte que la même transformation s'applique que la séquence ait 5 éléments ou 500. Le partage garde le nombre de paramètres indépendant de $T$ et permet à un motif appris à une position de généraliser à n'importe quelle autre.

*Remarque :* le partage de poids dans le temps est l'analogue séquentiel du partage de poids dans l'espace dans un réseau convolutif. Tous deux encodent l'a priori qu'une même caractéristique peut apparaître n'importe où.

| Configuration | Entrée | Sortie | Exemple |

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

| Plusieurs vers un | séquence | vecteur unique | sentiment d'une phrase |

| Plusieurs vers plusieurs (aligné) | séquence | séquence, même longueur | étiquetage morphosyntaxique |

| Plusieurs vers plusieurs (seq2seq) | séquence | séquence, autre longueur | traduction automatique |

| Un vers plusieurs | vecteur unique | séquence | légendage d'image |

Au pas $t$ la cellule lit l'entrée courante $x_t$ et l'état caché précédent $h_{t-1}$, puis produit un nouvel état caché via une activation $g$ (habituellement $\tanh$) :

$$\boxed{ h_t = g\left(W_{hh}\, h_{t-1} + W_{xh}\, x_t + b_h\right) }$$

L'état caché est initialisé à $h_0 = \mathbf{0}$ (ou à un vecteur appris). La sortie par pas est une lecture linéaire de l'état caché :

$$\boxed{ \hat{y}_t = W_{hy}\, h_t + b_y }$$

Ici $W_{hh}$ transforme l'état en état, $W_{xh}$ transforme l'entrée en état, et $W_{hy}$ transforme l'état en sortie. Si la taille cachée est $n_h$ et la taille d'entrée est $n_x$, alors $W_{hh}$ est de taille $(n_h \times n_h)$, $W_{xh}$ est de taille $(n_h \times n_x)$, et $b_h$ a pour forme $n_h$.

Le point crucial est que $W_{hh}$, $W_{xh}$, $W_{hy}$, $b_h$ et $b_y$ ne dépendent **pas** de $t$. Les cinq mêmes paramètres sont réutilisés à chaque pas :

Un RNN n'est donc pas un réseau très profond avec des couches distinctes, c'est une petite cellule appliquée de façon répétée, réinjectant sa propre sortie en entrée.

Comme la même cellule est réutilisée, on peut **dérouler** la récurrence en une chaîne : on dessine une copie de la cellule par pas de temps et on connecte l'état caché de chaque copie à la suivante. La vue déroulée est un graphe à propagation avant ordinaire (à poids liés), ce qui est exactement ce qui rend possible le calcul du gradient.

*Remarque :* les flèches horizontales entre états cachés sont le seul chemin par lequel l'information du passé atteint le présent. Chacune d'elles multiplie par la même matrice $W_{hh}$, ce qui est à la fois la source de la puissance du modèle et de sa difficulté d'entraînement.

L'entraînement minimise un coût total qui somme la perte par pas sur la séquence. Avec une perte par pas $L_t$ comparant $\hat{y}_t$ à la cible $y_t$, le coût pour une séquence est :

$$\boxed{ J = \sum_{t=1}^{T} L_t\left(\hat{y}_t, y_t\right) }$$

La rétropropagation à travers le temps (BPTT) est une rétropropagation ordinaire exécutée sur le graphe déroulé. Comme $W_{hh}$ est réutilisée à chaque pas, son gradient est la **somme** des contributions de tous les pas :

$$\boxed{ \frac{\partial J}{\partial W_{hh}} = \sum_{t=1}^{T} \frac{\partial L_t}{\partial W_{hh}} }$$

Pour un pas unique $t$, la perte dépend de $W_{hh}$ à la fois directement (via $h_t$) et indirectement via chaque état caché antérieur $h_k$ avec $k \le t$, puisque chacun d'eux a lui-même été produit avec $W_{hh}$. En appliquant la règle de dérivation en chaîne à travers la chaîne d'états, on obtient :

$$\boxed{ \frac{\partial L_t}{\partial W_{hh}} = \sum_{k=1}^{t} \frac{\partial L_t}{\partial h_t}\left(\prod_{i=k+1}^{t} \frac{\partial h_i}{\partial h_{i-1}}\right)\frac{\partial h_k}{\partial W_{hh}} }$$

*Remarque :* en pratique la somme sur $k$ est tronquée après une fenêtre fixe, ce qu'on appelle la BPTT tronquée. Elle borne la mémoire et le calcul par mise à jour au prix d'ignorer les dépendances plus longues que la fenêtre.

Le produit interne $\prod_{i=k+1}^{t} \frac{\partial h_i}{\partial h_{i-1}}$ est ce qui transporte l'information de gradient du pas $t$ jusqu'au pas $k$. À partir de la récurrence $h_i = g(W_{hh} h_{i-1} + W_{xh} x_i + b_h)$, chaque facteur vaut :

$$\boxed{ \frac{\partial h_i}{\partial h_{i-1}} = \operatorname{diag}\!\left(g'(z_i)\right) W_{hh} }$$

où $z_i = W_{hh} h_{i-1} + W_{xh} x_i + b_h$ est la pré-activation au pas $i$. En composant sur tout l'écart de $k$ à $t$, on obtient un produit de $t - k$ matrices de ce type :

$$\boxed{ \prod_{i=k+1}^{t} \frac{\partial h_i}{\partial h_{i-1}} = \prod_{i=k+1}^{t} \operatorname{diag}\!\left(g'(z_i)\right) W_{hh} }$$

Ce produit de $t - k$ facteurs quasi identiques se comporte à peu près comme une matrice élevée à la puissance $t - k$. Si la magnitude pertinente (informellement, la plus grande valeur singulière de $\operatorname{diag}(g'(z_i)) W_{hh}$) est inférieure à $1$, le produit rétrécit géométriquement vers zéro à mesure que l'écart grandit, de sorte que les gradients lointains **s'évanouissent**. Si elle est supérieure à $1$, le produit explose et les gradients **explosent**.

| Régime | Produit dans le temps | Effet sur l'entraînement |

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

| Magnitude du facteur $< 1$ | décroît vers $0$ | les gradients à longue portée s'évanouissent, aucune mémoire longue apprise |

| Magnitude du facteur $\approx 1$ | reste bornée | stable, le cas idéal |

| Magnitude du facteur $> 1$ | croît sans borne | les gradients explosent, les mises à jour divergent |

*Remarque :* les gradients qui explosent sont habituellement maîtrisés par **écrêtage du gradient** (rééchelonner le gradient quand sa norme dépasse un seuil). Les gradients qui s'évanouissent sont plus difficiles à traiter, car le signal est perdu plutôt que simplement grand, et aucun rééchelonnement simple ne le récupère.

Comme une activation saturante telle que $\tanh$ a $g' \le 1$ partout, le facteur diagonal tend à tirer le produit vers l'évanouissement, ce qui rend difficile pour un RNN de base l'apprentissage de dépendances distantes de plus de quelques dizaines de pas. Cette limitation est précisément ce qui motive les cellules à portes, qui ajoutent un chemin quasi linéaire le long duquel l'état peut circuler sans écrasement répété.

---