// ==========================================
// _ojs_bridge.qmd — OJS Global Namespace Bridge
//
// Include ONCE at the top of each chapter index.qmd:
// {{< include ../../assets/_ojs_bridge.qmd >}}
//
// window.aptitek is set by an async `<script type="module">` in the page
// header (_quarto.yml include-in-header). That import may resolve AFTER
// OJS starts executing, causing `aptitek` to be undefined.
//
// Fix: return a Promise from this cell. OJS suspends all downstream cells
// until the promise resolves — the built-in, idiomatic solution for async
// dependencies in Observable JS.
//
// ✅ Zero-maintenance: adding a new export to index.js barrel is
// instantly available — no edits to this file ever needed.
// ✅ Race-condition-safe: downstream cells never see undefined.
// ✅ Anti-double-definition: only ONE OJS name (`aptitek`) is defined.
// ==========================================
aptitek = {
if (window.aptitek) return window.aptitek;
return new Promise(resolve => {
const check = () =>
window.aptitek
? resolve(window.aptitek)
: requestAnimationFrame(check);
check();
});
}3 🔁 Réseaux de Neurones Récurrents (RNN)
3.1 Mémoire et Récurrence
Un RNN (réseau de neurones récurrent) est un réseau qui possède une mémoire : au lieu de traiter chaque donnée de manière isolée, il conserve un résumé de ce qu’il a vu avant pour interpréter ce qu’il voit maintenant — comme un lecteur qui relit mentalement le début de la phrase avant d’en comprendre la fin.
Le passage des architectures feedforward (MLP) aux réseaux de neurones récurrents (RNN) représente une rupture paradigmatique nécessaire pour le traitement des dépendances temporelles. Contrairement aux modèles statiques qui postulent l’indépendance de chaque observation, les RNN intègrent une dimension séquentielle où l’ordre des données est constitutif de leur signification. Un mot n’a de sens que dans son contexte phrastique ; une valeur boursière n’est informative que par rapport à sa trajectoire passée (Franck 2024; AWS 2024; DATAROCKSTARS 2025).
3.1.1 La limite de l’hypothèse markovienne
Un modèle sans mémoire suppose que chaque instant n’a besoin que de l’instant juste précédent pour prévoir le suivant — mais en réalité, prédire la fin d’une série temporelle complexe exige souvent de remonter loin dans l’historique.
Dans les systèmes dynamiques réels, l’hypothèse markovienne de premier ordre — selon laquelle l’état futur ne dépend que de l’état immédiatement précédent — s’avère structurellement insuffisante. Prédire la prochaine occurrence d’une séquence exige de prendre en compte tout l’historique des données passées.
Un MLP standard traite chaque élément de façon indépendante, ignorant l’historique et le rendant aveugle aux dépendances temporelles. À l’inverse, l’état caché d’un RNN agit comme un filtre temporel : il moyenne et stabilise l’information utile contre le bruit à travers les pas de temps (Franck 2024; Inconnu 2024).
🔢 Loi de probabilité conditionnelle d’une séquence
Pour modéliser une séquence temporelle, le modèle doit estimer la distribution conditionnelle suivante pour chaque pas de temps t :
P(\mathbf{x}_t \mid \mathbf{x}_1, \dots, \mathbf{x}_{t-1})
Où \mathbf{x}_t est l’observation actuelle et (\mathbf{x}_1, \dots, \mathbf{x}_{t-1}) représente l’historique complet de la séquence.
3.1.2 Le vecteur d’état caché \mathbf{h}_t
L’état caché est le carnet de notes du réseau : à chaque pas de temps, il résume tout l’historique pertinent vu jusqu’ici dans un vecteur de taille fixe, qui sera relu au pas suivant.
Le pivot de l’architecture RNN est le vecteur latent \mathbf{h}_t (ou état caché), qui compresse l’historique des entrées passées. Il permet de mapper une séquence d’entrée de taille variable vers un état de taille fixe, mis à jour à chaque pas de temps (Wang 2023; Grosse 2017).
🔢 Formules de mise à jour de l’état caché et de sortie
À chaque pas de temps t, l’état caché \mathbf{h}_t et la sortie \mathbf{y}_t sont calculés par récurrence :
Mise à jour de l’état caché : \mathbf{h}_t = \tanh\!\left(\mathbf{W}_h \mathbf{h}_{t-1} + \mathbf{W}_x \mathbf{x}_t + \mathbf{b}\right)
Calcul de la sortie : \mathbf{y}_t = f_\theta(\mathbf{x}_t, \mathbf{h}_{t-1})
Où :
- \mathbf{h}_{t-1} est l’état caché précédent (mémoire)
- \mathbf{x}_t est l’entrée au pas de temps actuel
- \mathbf{W}_h est la matrice de récurrence (poids de l’état caché)
- \mathbf{W}_x est la matrice de projection de l’entrée
- \mathbf{b} est le biais
- Le même jeu de paramètres (\mathbf{W}_h, \mathbf{W}_x, \mathbf{b}) est partagé à tous les pas de temps t.
🔄 Cellule RNN
Les entrées Zone A, Zone B, les Piétons, et la Trésorerie de la veille (h_{t-1}) sont sommées (Σ), puis filtrées par ReLU. La trésorerie boucle vers l’entrée.
L’erreur de fin de journée remonte à l’envers : elle distribue la responsabilité aux routes, aux piétons, et à la gestion de la trésorerie.
Le “Budget Travaux” corrige proportionnellement les poids des routes (w_1, w_2) et le poids de la trésorerie (w_h).
3.1.3 Topologies Elman et Jordan
Il existe deux façons de “boucler” la mémoire : soit on réutilise l’état interne du réseau (Elman, la plus courante), soit on réutilise sa dernière sortie (Jordan, utile pour les robots qui doivent savoir ce qu’ils viennent de faire).
Deux architectures définissent le comportement de la récurrence (Inconnu 2024; Franck 2024) :
- Réseau d’Elman (Standard) : L’état caché \mathbf{h}_t dépend de l’entrée actuelle \mathbf{x}_t et de l’état caché précédent \mathbf{h}_{t-1}, privilégiant la dynamique interne.
- Réseau de Jordan : L’état caché \mathbf{h}_t s’appuie sur la sortie précédente \mathbf{y}_{t-1} au lieu de l’état caché (ex. : commande de robot).
🔁 RNN Déroulé
3.1.4 Modes d’Entrée-Sortie
Les RNN s’adaptent à quatre configurations selon la relation entre la séquence d’entrée et de sortie (maurock 2020) :
| Mode | Description | Application |
|---|---|---|
| Un-à-Un | Pas de récurrence | MLP classique, classification d’image |
| Un-à-Plusieurs | Une entrée, séquence de sortie | Légende d’image, génération de texte |
| Plusieurs-à-Un | Séquence d’entrée, une sortie | Classification de sentiment |
| Plusieurs-à-Plusieurs | Séquences d’entrée et de sortie | Traduction automatique |
Cette flexibilité explique la domination passée des RNN en NLP avant l’avènement des Transformers.
3.2 Instabilité du Gradient dans les RNN
Quand on entraîne un RNN sur de longues séquences, le même problème de gradient évanescent ou explosif du chapitre 2 se réapparaît mais de façon encore plus sévère : chaque pas de temps rajouté équivaut à ajouter une couche supplémentaire au réseau.
La robustesse d’un RNN ne se mesure pas à sa profondeur structurelle, mais à sa capacité à propager l’information sans distorsion sur de longs horizons temporels. L’apprentissage par rétropropagation à travers le temps (Backpropagation Through Time, BPTT) expose les limites intrinsèques de l’architecture récurrente basique lorsque les séquences deviennent longues (Pascanu, Mikolov, and Bengio 2013; Grosse 2017; wabbit 2019).
3.2.1 Backpropagation Through Time (BPTT)
Pour entraîner un RNN, on “déplie” le réseau dans le temps comme si chaque pas de temps était une couche supplémentaire d’un réseau profond, puis on applique la rétropropagation standard sur ce réseau étiré.
Le BPTT est la généralisation de la rétropropagation au cas séquentiel. On “déplie” (unroll) le RNN sur T pas de temps pour obtenir un réseau profond de T couches partageant les mêmes poids. Le gradient de la perte totale \mathcal{L} = \sum_t \mathcal{L}_t par rapport aux poids \mathbf{W}_h nécessite de calculer, pour chaque pas t (voir le Glossaire) :
\frac{\partial \mathcal{L}_t}{\partial \mathbf{W}_h} = \sum_{i=1}^{t} \frac{\partial \mathcal{L}_t}{\partial \mathbf{h}_t} \cdot \frac{\partial \mathbf{h}_t}{\partial \mathbf{h}_i} \cdot \frac{\partial \mathbf{h}_i}{\partial \mathbf{W}_h}
- \mathcal{L}_t : la perte (loss) au pas de temps t.
- \mathbf{W}_h : la matrice des poids récurrents.
- \mathbf{h}_t : le vecteur d’état caché au pas de temps t.
- \sum_{i=1}^{t} : la sommation des contributions de tous les pas temporels précédents i jusqu’à t.
Le terme critique est le produit de matrices jacobiennes (qui mesurent la sensibilité de chaque état caché par rapport au précédent) :
\frac{\partial \mathbf{h}_t}{\partial \mathbf{h}_i} = \prod_{j=i}^{t-1} \frac{\partial \mathbf{h}_{j+1}}{\partial \mathbf{h}_j} = \prod_{j=i}^{t-1} \operatorname{diag}\!\left(\sigma'(\mathbf{z}^{j+1})\right) \mathbf{W}_h
- \prod_{j=i}^{t-1} : le produit multiplicatif successif (calculé du pas i au pas t-1).
- \operatorname{diag}(\cdot) : l’opérateur créant une matrice diagonale à partir d’un vecteur.
- \sigma' : la dérivée de la fonction d’activation.
- \mathbf{z}^{j+1} : le vecteur des pré-activations à l’étape j+1.
La stabilité de ce produit est dictée par son rayon spectral (la valeur propre dominante de la matrice de poids récurrents \mathbf{W}_h, notée \rho(\mathbf{W}_h) où \rho est la lettre grecque rho) (Pascanu, Mikolov, and Bengio 2013; Franck 2024).
3.2.2 Disparition et explosion du gradient (version temporelle)
Ici, c’est la longueur de la séquence — et non la profondeur du réseau — qui multiplie les gradients : une phrase de 50 mots équivaut à remonter dans 50 couches successives. Si les poids sont légèrement inférieurs à 1, le signal d’erreur s’efface complètement avant d’atteindre les premiers mots.
Le problème de la disparition et de l’explosion du gradient — introduit au chapitre 2 sous l’angle de la profondeur spatiale — prend ici une forme temporelle particulièrement sévère.
Alors que dans un réseau feedforward standard le gradient est multiplié à travers les différentes couches physiques du modèle, dans un RNN, la rétropropagation à travers le temps (BPTT) force la multiplication répétée du gradient par la matrice de récurrence \mathbf{W}_h à chaque pas de temps (SuperDataScience Team 2018; Grosse 2017; Weber 2017). La longueur de la séquence T agit ainsi comme une profondeur virtuelle extrême.
L’évolution de la norme du gradient est directement gouvernée par la valeur propre dominante (le rayon spectral \rho(\mathbf{W}_h)) de cette matrice :
\left\|\frac{\partial \mathbf{h}_t}{\partial \mathbf{h}_i}\right\| \approx \begin{cases} \to 0 & \text{si } \rho(\mathbf{W}_h) < 1 \text{ (disparition dans les dépendances lointaines)} \\ \to \infty & \text{si } \rho(\mathbf{W}_h) > 1 \text{ (explosion chaotique des poids)} \end{cases}
\|\cdot\| : la norme matricielle (mesurant la magnitude de la matrice jacobienne).
\approx : l’opérateur d’approximation (approximativement égal à).
\to : la notation “tend vers” (indique une limite).
La grande accolade \begin{cases} : décrit une alternative par cas selon les conditions à droite.
La disparition : Si \rho(\mathbf{W}_h) < 1, ou si l’activation sature (dérivée \sigma' < 1), le gradient s’évanouit exponentiellement en remontant le temps. Le réseau perd toute mémoire à long terme.
L’explosion : Si \rho(\mathbf{W}_h) > 1, le gradient croît exponentiellement vers l’infini, provoquant des sauts de paramètres incontrôlés qui déstabilisent complètement l’entraînement.
📉 Magnitude du Gradient selon la Longueur de la Séquence
3.2.3 Remèdes pratiques
En attendant des architectures mieux conçues (LSTM, GRU), deux rustines existent : limiter l’amplitude des gradients quand ils s’emballent, et raccourcir la fenêtre de mémoire pour ne pas remonter trop loin dans le temps.
Deux stratégies palliatives existent pour les RNN simples, avant d’adopter des architectures à portes (Pascanu, Mikolov, and Bengio 2013; Xu 2024) :
Écrêtage du gradient (Gradient Clipping) : Lorsque la norme du gradient global dépasse un seuil \tau (lettre grecque tau), on le remet à l’échelle : \mathbf{g} \leftarrow \tau \cdot \mathbf{g} / \|\mathbf{g}\| (où \mathbf{g} désigne le gradient, \leftarrow l’affectation, et \|\mathbf{g}\| sa norme Euclidienne, voir le Glossaire). Cette technique règle le problème d’explosion mais ne résout pas la disparition.
Troncature du BPTT (Truncated BPTT) : On ne propage le gradient que sur une fenêtre de k pas de temps au lieu de la séquence complète. Compromis entre efficacité computationnelle et capacité de mémoire à long terme.
Ces remèdes sont des rustines. La solution structurelle réside dans les architectures à portes (gated architectures) — LSTM et GRU — qui remplacent la dynamique multiplicative instable par une dynamique additive contrôlée.
3.3 La Cellule LSTM
La LSTM résout le problème de mémoire du RNN basique en ajoutant une autoroute de l’information (état de cellule) qui traverse le temps sans être multipliée à chaque étape, accompagnée de trois valves (portes) qui contrôlent ce qu’on laisse passer, mémoriser ou oublier.
La cellule LSTM (Long Short-Term Memory), introduite par Hochreiter et Schmidhuber en 1997, constitue la réponse architecturale au problème de disparition du gradient. Son innovation fondamentale est l’introduction d’un état de cellule \mathbf{c}_t, distinct de l’état caché \mathbf{h}_t, qui fonctionne comme une autoroute de l’information à travers le temps (DATAROCKSTARS 2025; Habbou 2022; Xu 2024).
3.3.1 Dynamique Additive
Dans un RNN simple, chaque pas de temps multiplie l’information passée, ce qui créé des instabilités. La LSTM remplace cette multiplication par une addition contrôlée : on ajoute de nouvelles informations au lieu de tout recalculer à zéro.
Dans un RNN simple, la mise à jour de l’état caché est entièrement multiplicative : \mathbf{h}_t = \tanh(\mathbf{W}_h \mathbf{h}_{t-1} + \mathbf{W}_x \mathbf{x}_t). Lors de la rétropropagation, cette multiplicativité engendre des produits de dérivées exponentiellement instables.
L’état de cellule \mathbf{c}_t de la LSTM subit des mises à jour principalement additives :
\mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t
Cette addition garantit que le gradient peut remonter le temps sans être multiplié par de nombreux petits coefficients : \frac{\partial \mathbf{c}_t}{\partial \mathbf{c}_{t-1}} = \mathbf{f}_t, qui est directement contrôlé par la porte d’oubli (zosoyyz 2016; TheWalkingCube 2015; Weber 2017).
3.3.2 Les trois portes et leurs équations
Trois portes (gates), chacune implémentée comme une couche sigmoïde, régulent sélectivement le flux d’information (Zhang et al. 2021; LDS Team 2025) :
Porte d’oubli \mathbf{f}_t — Que faut-il effacer de la mémoire passée ? \mathbf{f}_t = \sigma(\mathbf{W}_f \mathbf{h}_{t-1} + \mathbf{U}_f \mathbf{x}_t + \mathbf{b}_f)
Porte d’entrée \mathbf{i}_t — Quelle nouvelle information mérite d’être stockée ? \mathbf{i}_t = \sigma(\mathbf{W}_i \mathbf{h}_{t-1} + \mathbf{U}_i \mathbf{x}_t + \mathbf{b}_i)
Candidat \tilde{\mathbf{c}}_t — Quelle information proposée ajouter à la cellule ? \tilde{\mathbf{c}}_t = \tanh(\mathbf{W}_c \mathbf{h}_{t-1} + \mathbf{U}_c \mathbf{x}_t + \mathbf{b}_c)
Mise à jour de la cellule : \mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t
- \odot (produit de Hadamard) : représente la multiplication élément par élément de deux vecteurs ou matrices de même taille (voir le Glossaire).
Porte de sortie \mathbf{o}_t — Quelle partie de la cellule expose-t-on en état caché ? \mathbf{o}_t = \sigma(\mathbf{W}_o \mathbf{h}_{t-1} + \mathbf{U}_o \mathbf{x}_t + \mathbf{b}_o) \qquad \mathbf{h}_t = \mathbf{o}_t \odot \tanh(\mathbf{c}_t)
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(--accent-warning),stroke-width:2px,color:var(--accent-warning);
classDef cell fill:var(--sol-base03),stroke:var(--accent-success),stroke-width:2px,color:var(--accent-success);
classDef output fill:var(--sol-base03),stroke:var(--sol-cyan),stroke-width:2px,color:var(--sol-cyan);
Xt["xₜ"]:::input
Hprev["hₜ₋₁"]:::input
Cprev["cₜ₋₁\n(Autoroute)"]:::cell
Xt & Hprev --> Forget["Porte d'Oubli\nfₜ = σ(...)"]:::gate
Xt & Hprev --> Input["Porte d'Entrée\niₜ = σ(...)"]:::gate
Xt & Hprev --> Cand["Candidat\nc̃ₜ = tanh(...)"]:::gate
Xt & Hprev --> Out["Porte de Sortie\noₜ = σ(...)"]:::gate
Forget --> Update(["cₜ = fₜ⊙cₜ₋₁ + iₜ⊙c̃ₜ"]):::cell
Input --> Update
Cand --> Update
Cprev --> Update
Update --> Ct["cₜ\n(nouvelle cellule)"]:::cell
Ct & Out --> Ht["hₜ = oₜ⊙tanh(cₜ)"]:::output
3.3.3 Nombre de paramètres de la LSTM
La puissance de la LSTM a un coût : ses 4 portes rendent le nombre de paramètres environ 4 fois plus élevé qu’un RNN simple de même dimension.
Pour une LSTM avec une dimension d’entrée d_x et une dimension d’état caché d_h, chaque porte requiert d_h \times (d_h + d_x) + d_h paramètres. Avec quatre sous-réseaux (f, i, c, o), le total est (Arsenal Fanatic 2016; Karakaya 2020; wabbit 2016) :
N_{\text{LSTM}} = 4 \times \left[d_h (d_h + d_x) + d_h\right] = 4 d_h (d_h + d_x + 1)
À titre d’exemple, pour d_h = 128 et d_x = 64, la LSTM possède 4 \times 128 \times 193 = 98\,816 paramètres.
🔢 Calculateur de Paramètres — LSTM vs RNN Simple
3.4 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é (Zhang et al. 2021; Articsledge 2024; Pluralsight 2024).
3.4.1 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).
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).
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
3.4.2 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 (Sycorax 2018; Orucov 2019) :
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.
3.4.3 Comparaison LSTM vs GRU
⚖️ LSTM vs GRU
Le tableau de décision pratique (Articsledge 2024; Sonawane 2016; Pluralsight 2024) :
| 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.
3.5 Applications Modernes et Rigueur Méthodologique
Même le moteur le plus puissant devient inutile si on lui met du mauvais carburant : les RNN avancés (Bi-LSTM, multi-tâches) peuvent performer remarquablement, à condition de ne pas contaminer les données de test avec des informations venues du futur.
L’évolution des RNN vers des modèles hybrides permet d’atteindre une précision remarquable dans des domaines critiques. Deux directions de recherche marquent l’état de l’art : l’extension bidirectionnelle des architectures récurrentes, et l’intégration dans des frameworks multi-tâches. Mais leur puissance computationnelle est vaine sans une rigueur méthodologique absolue sur les données (Zhu et al. 2024; Ji, Cao, and Li 2023; Albelali and Ahmed 2025).
3.5.1 Contexte Bidirectionnel
Une Bi-LSTM lit la séquence deux fois : une fois dans l’ordre normal et une fois à l’envers, puis combine les deux lectures — comme un correcteur qui relit un texte dans les deux sens pour détecter des incohérences.
L’architecture Bi-LSTM (Bidirectional LSTM) traite la séquence simultanément dans les deux directions temporelles : une LSTM avance de t=1 vers t=T, une autre recule de t=T vers t=1. Les états cachés des deux passes sont concaténés à chaque pas de temps :
\mathbf{h}_t^{\text{Bi}} = \left[\overrightarrow{\mathbf{h}}_t \;\|\; \overleftarrow{\mathbf{h}}_t\right]
Cette architecture capture des dépendances contextuelles que les modèles unidirectionnels manquent : pour la reconstruction de données de capteurs manquantes, la Bi-LSTM peut utiliser à la fois les mesures antérieures et les mesures postérieures d’une lacune pour l’interpoler avec précision (Zhu et al. 2024).
Application : surveillance de santé structurelle (SHM) — Le framework VMD-SSA-Bi-LSTM illustre la puissance de cette approche (Zhu et al. 2024) :
- La Décomposition en Modes Variationnels (VMD) segmente les signaux périodiques irréguliers en fonctions de modes intrinsèques (IMF), séparant les composantes fréquentielles.
- L’algorithme SSA (Sparrow Search Algorithm) optimise automatiquement les hyperparamètres (unités cachées, taux d’apprentissage).
- La Bi-LSTM modélise les corrélations spatio-temporelles avec une fidélité bien supérieure aux méthodes d’interpolation classiques.
3.5.2 Apprentissage multi-tâches et Temporal Fusion Transformer
L’apprentissage multi-tâches (Multi-Task Learning, MTL) impose au modèle de prédire simultanément plusieurs horizons temporels (court, moyen, long terme). Cette contrainte agit comme un puissant régularisateur en forçant l’extraction de caractéristiques robustes et généralisables (Ji, Cao, and Li 2023; Arik and Pfister 2021).
Le modèle MTLTFT (Multi-Task Learning + Temporal Fusion Transformer) pousse cette logique plus loin : le Transformer gère l’attention globale sur la séquence, tandis que le MTL optimise conjointement des têtes de prédiction sur plusieurs horizons. La génération multi-tâches force le modèle à extraire des représentations partagées invariantes à l’horizon temporel, ce qui améliore significativement les performances en situation de pénurie de données (Ji, Cao, and Li 2023).
3.5.3 Danger du Data Leakage
Le Data Leakage est l’erreur la plus insidieuse sur les séries temporelles : si on mélange les données d’entraînement et de test avant de construire les fenêtres d’observation, le modèle “voit le futur” pendant son entraînement et semble perfomer à tort très bien — avant de échouer complètement en production.
La puissance de calcul de ces architectures est vaine si elle repose sur un protocole d’évaluation biaisé. Le Data Leakage (fuite de données) constitue la faille méthodologique la plus insidieuse en séries temporelles (Albelali and Ahmed 2025; PMC 2024).
Le mécanisme du leakage : Si les fenêtres glissantes (sliding windows) sont générées avant la séparation entraînement/test (pre-split), des informations temporellement futures peuvent s’infiltrer dans l’ensemble d’entraînement via les chevauchements entre fenêtres adjacentes. Une fenêtre centrée sur un point de la zone de test peut inclure des données antérieures issues du futur relatif à l’entraînement.
\text{RMSE Gain} = \frac{\text{RMSE}_{\text{leaky}} - \text{RMSE}_{\text{clean}}}{\text{RMSE}_{\text{clean}}} \times 100\%
Les preuves empiriques de (Albelali and Ahmed 2025) sont sans appel :
⚠️ Data Leakage
Règle d’or : la séparation temporelle (train/val/test) doit précéder toute construction de séquence ou de fenêtre glissante. La validation croisée k-fold standard, bien que universelle en apprentissage statique, est structurellement inadaptée aux séries temporelles car elle mélange passé et futur (Albelali and Ahmed 2025; Lazy Programmer 2025).
graph TD
classDef good fill:var(--sol-base03),stroke:var(--accent-success),stroke-width:2px,color:var(--accent-success);
classDef bad fill:var(--sol-base03),stroke:var(--accent-danger),stroke-width:2px,color:var(--accent-danger);
classDef step fill:var(--sol-base03),stroke:var(--sol-base01),stroke-width:1px,color:var(--sol-base0);
A["Données temporelles brutes"]:::step
B1["❌ Pre-split : fenêtres d'abord"]:::bad
B2["✅ Post-split : séparation d'abord"]:::good
C1["→ Leakage possible (fuite future)"]:::bad
C2["→ Protocole propre (causalité préservée)"]:::good
A --> B1 --> C1
A --> B2 --> C2