## La GRU Efficace

La GRU est une version allégée de la LSTM qui fusionne deux de ses trois portes en une seule, ce qui la rend plus rapide à entraîner tout en conservant l'essentiel de sa capacité à mémoriser le long terme.

La *Gated Recurrent Unit* (GRU), proposée par Cho et al. en 2014, simplifie la cellule LSTM tout en préservant ses propriétés fondamentales de stabilité. Son idée directrice est d'**unifier les portes d'oubli et d'entrée** en une seule porte de mise à jour, et de fusionner l'état de cellule avec l'état caché [@Zhang2021; @Articsledge2024; @Pluralsight2024].

### Architecture simplifiée

Comme un agenda qui se met à jour en écrasant les vieilles entrées plutôt qu'en rajoutant des colonnes, la GRU gère mémoire courte et longue au même endroit, sans état de cellule séparé.

La GRU opère avec seulement deux portes et ne possède pas d'état de cellule séparé — l'état caché $\mathbf{h}_t$ joue simultanément les rôles de mémoire courte et longue terme :

**Porte de mise à jour $\mathbf{z}_t$** — Quel ratio de l'ancien état conserver vs. mettre à jour ?
$$
\mathbf{z}_t = \sigma(\mathbf{W}_z \mathbf{h}_{t-1} + \mathbf{U}_z \mathbf{x}_t + \mathbf{b}_z)
$$

**Porte de remise à zéro $\mathbf{r}_t$** — Quelle partie de l'état passé ignorer pour le candidat ?
$$
\mathbf{r}_t = \sigma(\mathbf{W}_r \mathbf{h}_{t-1} + \mathbf{U}_r \mathbf{x}_t + \mathbf{b}_r)
$$

**État candidat $\tilde{\mathbf{h}}_t$** :
$$
\tilde{\mathbf{h}}_t = \tanh\!\left(\mathbf{W}_h (\mathbf{r}_t \odot \mathbf{h}_{t-1}) + \mathbf{U}_h \mathbf{x}_t + \mathbf{b}_h\right)
$$

**Mise à jour finale de l'état caché** :
$$
\mathbf{h}_t = (1 - \mathbf{z}_t) \odot \mathbf{h}_{t-1} + \mathbf{z}_t \odot \tilde{\mathbf{h}}_t
$$

* **$\odot$ (produit de Hadamard)** : représente le produit élément par élément de deux vecteurs de même taille ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations)).

Cette équation finale révèle l'élégance de la GRU : $\mathbf{z}_t$ interpole linéairement entre l'ancien état $\mathbf{h}_{t-1}$ et le candidat $\tilde{\mathbf{h}}_t$. Lorsque $\mathbf{z}_t \approx 0$, l'état est presque inchangé (mémoire long terme) ; lorsque $\mathbf{z}_t \approx 1$, l'état est entièrement remplacé par le candidat (réactivité court terme).

```{mermaid}
graph LR
    classDef input  fill:var(--sol-base03),stroke:var(--accent-info),stroke-width:2px,color:var(--accent-info);
    classDef gate   fill:var(--sol-base03),stroke:var(--sol-magenta),stroke-width:2px,color:var(--sol-magenta);
    classDef cand   fill:var(--sol-base03),stroke:var(--accent-warning),stroke-width:2px,color:var(--accent-warning);
    classDef output fill:var(--sol-base03),stroke:var(--sol-cyan),stroke-width:2px,color:var(--sol-cyan);

    Xt["xₜ"]:::input
    Hprev["hₜ₋₁"]:::input

    Xt & Hprev --> Zt["Porte de MAJ\nzₜ = σ(...)"]:::gate
    Xt & Hprev --> Rt["Porte de Reset\nrₜ = σ(...)"]:::gate

    Rt & Hprev --> HCand["Candidat\nh̃ₜ = tanh(rₜ⊙hₜ₋₁, xₜ)"]:::cand
    Xt --> HCand

    Zt & HCand & Hprev --> Ht["hₜ = (1-zₜ)⊙hₜ₋₁ + zₜ⊙h̃ₜ"]:::output
```

### Nombre de paramètres de la GRU

Avec seulement 3 portes au lieu de 4, la GRU a environ un quart de paramètres en moins que la LSTM — ce qui se traduit directement par un entraînement plus rapide et moins gourmand en mémoire.

Avec trois sous-réseaux (z, r, h) au lieu de quatre pour la LSTM [@Sycorax2018; @Orucov2019] :

$$
N_{\text{GRU}} = 3 \times \left[d_h (d_h + d_x) + d_h\right] = 3 d_h (d_h + d_x + 1)
$$

* **$d_h$** : la dimension du vecteur d'état caché $\mathbf{h}_t$ (mémoire du réseau).
* **$d_x$** : la dimension du vecteur d'entrée $\mathbf{x}_t$.

Soit environ **25 % de paramètres en moins** que la LSTM pour les mêmes dimensions, avec un temps d'entraînement proportionnellement réduit.

### Comparaison LSTM vs GRU

::: {.card .card-window .mb-4}

:::: {.card-header}
⚖️ LSTM vs GRU
::::

:::: {.card-control-row}
```{ojs}
//| echo: false
viewof gru_dh2 = Inputs.range([8, 512], { value: 128, step: 8, label: "Dimension cachée dₕ" })
viewof gru_dx2 = Inputs.range([4, 256], { value:  64, step: 4, label: "Dimension entrée dₓ" })
```
::::

```{ojs}
//| echo: false
import { renderGruParameterComparison } from "../../assets/js/simulations/recurrent.js"
renderGruParameterComparison({ hiddenDim: gru_dh2, inputDim: gru_dx2 })
```

:::

Le tableau de décision pratique [@Articsledge2024; @Sonawane2016; @Pluralsight2024] :

| Critère                        | LSTM                               | GRU                      |
| :----------------------------- | :--------------------------------- | :----------------------- |
| **Dépendances très longues**   | Supérieure (état de cellule dédié) | Légèrement inférieure    |
| **Données limitées**           | Risque de sur-apprentissage        | Meilleure généralisation |
| **Vitesse d'entraînement**     | Plus lente                         | Plus rapide (~25%)       |
| **Implémentation**             | Plus complexe                      | Plus simple              |
| **Séries temporelles courtes** | Équivalent                         | Équivalent               |

La règle empirique est simple : commencer par la GRU et passer à la LSTM si les performances sont insuffisantes sur des séquences nécessitant une mémoire très longue. Dans la majorité des applications pratiques — séries temporelles financières, prédiction de capteurs, classification de textes courts — les deux architectures offrent des performances comparables.