Deep Learning 2 · les RNN

📐 L'essentiel à connaître

Tout ce qu'il faut savoir par cœur pour les exos RNN des annales (dimensionnement, calcul de paramètres, code Keras). Encadrés dans l'ordre où on en a besoin le jour J.

1 · Les 2 équations fondamentales

État caché (récurrence) $$H^t = \tanh\!\left( U \cdot X^t + V \cdot H^{t-1} + B^h \right)$$ $\sigma_h = \tanh$ (valeurs dans $[-1, 1]$). $H^t$ dépend de l'entrée courante $X^t$ et de l'état précédent $H^{t-1}$ — c'est la mémoire.

Sortie $$Y^t = \mathrm{softmax}\!\left( W \cdot H^t + B^o \right)$$ $\sigma_o = \mathrm{softmax}$ pour la classification multi-classe : $0 \le Y_i \le 1$ et $\sum_i Y_i = 1$.

2 · Dimensions des matrices et biais

Élément	Rôle	Dimensions	Nb de valeurs
$U$	entrée $\to$ caché	$m \times n$	$m\,n$
$V$	caché $\to$ caché	$m \times m$	$m^2$
$B^h$	biais caché	$m \times 1$	$m$
$W$	caché $\to$ sortie	$p \times m$	$p\,m$
$B^o$	biais sortie	$p \times 1$	$p$

$n$: taille du vecteur d'un élément de la séquence (features)
$m$: taille de la couche cachée (donnée de l'énoncé)
$p$: nombre de classes $\to$ neurones de sortie (softmax)
$T$: longueur de la séquence (nombre de pas de temps / timesteps)

3 · Nombre de paramètres (LA question des annales)

Couche SimpleRNN (la récurrence seule) $$N_{\text{RNN}} = \underbrace{m\,n}_{U} + \underbrace{m^2}_{V} + \underbrace{m}_{B^h} = m\,n + m^2 + m$$ Couche Dense de sortie $$N_{\text{Dense}} = (m + 1)\,p \;=\; \underbrace{p\,m}_{W} + \underbrace{p}_{B^o}$$

Piège — le SimpleRNN de Keras ne contient que $U$, $V$ et $B^h$ ($= mn + m^2 + m$). Les poids $W$ et le biais $B^o$ qui mènent à la sortie sont dans la couche Dense séparée. On les compte donc à part.

Exo type — Analyse de sentiment (annale MI FI 25-26)
3 classes, mots = vecteur 50, $T = 40$, couche cachée 64.
$\Rightarrow n=50,\ m=64,\ p=3,\ T=40$

$U = m\,n = 64 \times 50 = 3\,200$
$V = m^2 = 64 \times 64 = 4\,096$
$B^h = m = 64$
$W = p\,m = 3 \times 64 = 192$
$B^o = p = 3$
Total $= 3200 + 4096 + 64 + 192 + 3 = 7\,555$

Exo type — Prédiction de température (annale GI FI 25-26)
5 classes, 3 mesures/jour, fenêtre de 4 jours, couche cachée 32.
$\Rightarrow n=3,\ m=32,\ p=5,\ T=4$

SimpleRNN $= mn + m^2 + m$
$= 32{\cdot}3 + 32{\cdot}32 + 32$
$= 96 + 1024 + 32 = \mathbf{1\,152}$
Dense $= (m+1)\,p = 33 \times 5 = \mathbf{165}$

4 · Dimensionner un problème à partir de l'énoncé

Méthode en 4 réflexes

$n$ = features : taille du vecteur décrivant un pas de la séquence (ex : 3 températures/jour $\to n=3$ ; mot encodé sur 50 $\to n=50$).
$p$ = nombre de classes de la cible $\to$ couche de sortie de $p$ neurones + softmax.
$m$ est donné (taille de la couche cachée, hyperparamètre).
$T$ = timesteps : longueur de la fenêtre d'entrée (ex : 4 jours $\to T=4$).

Formes des données (notation TD : samples × timesteps × features)

Fenêtre glissante : avec $N$ observations et une fenêtre de longueur $L$ (entrée + cible), on obtient $\mathbf{N - L + 1}$ exemples.
Ex température : 4 jours d'entrée + 1 jour cible $\Rightarrow L = 5$, donc $10\,000 - 5 + 1 = 9\,996$ exemples.
$X_{train}$ : $\text{samples} \times T \times n$ (ex : $7000 \times 4 \times 3$).
$y_{train}$ : $\text{samples}$ (un label par exemple, avant encodage).
One-hot des labels : $y$ de taille $N$ sur $K$ classes devient $\mathbf{N \times K}$ (ex : $7000 \times 5$). Sert pour la categorical cross-entropy.

5 · Code Keras à savoir lire (et compléter)

Exo type GI FI : on donne le squelette avec des ? à remplir — input_shape, nombre de neurones de sortie, activation.

from keras.models import Sequential
from keras.layers import SimpleRNN, Dense

model = Sequential()
# 1.?  -> input_shape = (timesteps, features) = (T, n)
model.add(SimpleRNN(m, input_shape=(T, n)))   # ex : SimpleRNN(32, input_shape=(4, 3))
# 2.?  -> nb de neurones de sortie = nb de classes p
# 3.?  -> activation = 'softmax' (classification multi-classe)
model.add(Dense(p, activation='softmax'))      # ex : Dense(5, activation='softmax')

model.compile(loss='categorical_crossentropy',
              optimizer='adam', metrics=['accuracy'])
model.summary()   # vérifie : params RNN = m*n + m*m + m ; Dense = (m+1)*p

Les 3 trous classiques

1.? $\to$ input_shape=(T, n) (timesteps, features) — ex (4, 3).
2.? $\to$ Dense(p, …) avec $p$ = nombre de classes — ex Dense(5, …).
3.? $\to$ activation='softmax'.

6 · Notions clés à dégainer

Many-to-one (classification de séquence) : on lit toute la séquence et on ne garde que $H^T$ (dernier pas de temps) pour produire le label. C'est le cas du sentiment et de la prédiction de température.
Softmax $\Leftrightarrow$ classification multi-classe ($p \ge 2$ classes) ; cible en one-hot + categorical cross-entropy.
BPTT (Backpropagation Through Time) : on déplie le RNN dans le temps, puis rétropropagation classique sur le graphe étendu. Mêmes paramètres $U, V, W, B^h, B^o$ réutilisés à chaque pas.
RNN vs LSTM : le RNN simple souffre du vanishing / exploding gradient (mémoire courte sur longues dépendances). Le LSTM ajoute un état de cellule $c_t$ et 3 portes (forget $f_t$, input $i_t$, output $o_t$, sigmoïdes $\in[0,1]$) : $$c_t = f_t \cdot c_{t-1} + i_t \cdot \tilde{c}_t \qquad h_t = o_t \cdot \tanh(c_t)$$

$H^t = \tanh(U X^t + V H^{t-1} + B^h)$
$Y^t = \mathrm{softmax}(W H^t + B^o)$
$U : m{\times}n$ · $V : m{\times}m$ · $W : p{\times}m$
$B^h : m$ · $B^o : p$
Params SimpleRNN $= mn + m^2 + m$
Params Dense sortie $= (m+1)\,p$
$n$ = features · $m$ = caché · $p$ = classes · $T$ = timesteps
Forme $X$ = (samples, timesteps, features) $= (\cdot, T, n)$
Fenêtre glissante : $N$ obs → $N - L + 1$ exemples
One-hot : $y$ de taille $N$ → $N \times K$ classes
SimpleRNN(m, input_shape=(T, n))
Dense(p, activation='softmax')
Many-to-one : on garde $H^T$ seul
LSTM = $c_t$ + 3 portes (forget/input/output) vs vanishing gradient

📄 Ressources du cours

📥 Télécharger les slides · 🔗 Ouvrir dans un nouvel onglet · 📝 Ouvrir le TD/TP

🎥 Vidéos recommandées

🇫🇷 Comprendre les réseaux de neurones récurrents (RNN)
Thibault Neveu · 22:42 · 47k vues — Patreon : https://www.patreon.com/ThibaultNeveu/membershipLes réseaux de neurones récurrents sont utilisés dans des millions de téléphones, dans la reconnais
🇫🇷 Implémentation des Réseaux RNN, LSTM et GRU en Python sur Colab
Prof. Sabri · 22:50 · 472 vues — Dans cette vidéo, je vous présente en détail l'implémentation de trois types de réseaux récurrents avec Python : RNN, LSTM, et GRU. Vous allez découvrir comm...
🇬🇧 Long Short-Term Memory (LSTM), Clearly Explained
StatQuest with Josh Starmer · 20:45 · 556k vues — Basic recurrent neural networks are great, because they can handle different amounts of sequential data, but even relatively small sequences of data can make...

1. Pourquoi utiliser des RNN ?

Les réseaux de neurones classiques (Dense, CNN) fonctionnent bien quand l'entrée est de taille fixe. Mais certains problèmes utilisent des données sous forme de séquences :

Phrase = séquence de mots
Texte = séquence de caractères
Vidéo = séquence d'images

Le passé est une séquence — l'ordre est important.

Exemple « Le chien mord l'homme » ≠ « L'homme mord le chien ».
Un réseau classique ne garde pas naturellement en mémoire ce qui est arrivé avant. Les RNN sont faits pour traiter ce type de données séquentielles.

2. Définition d'un RNN

Un RNN est un réseau de neurones qui contient une boucle. Cela signifie qu'une information produite à un instant précédent peut être réutilisée à l'instant suivant.

RN feedforward classique
entrée → couche cachée → sortie

Dans un RNN
Entrée $X^t$ + état précédent $H^{t-1}$ → état courant $H^t$ → sortie $Y^t$

Pour une phrase : $X^1$ = 1er mot, $X^2$ = 2e mot, …, $X^T$ = dernier mot. À chaque étape $t$, le réseau reçoit $X^t$ et utilise aussi ce qu'il a retenu des étapes précédentes.

3. Notations importantes

$n$ = taille de la couche d'entrée (taille du vecteur représentant une entrée)
$m$ = taille de la couche cachée (nombre de neurones cachés)
$p$ = taille de la couche de sortie (nombre de neurones de sortie)
$T$ = longueur de la séquence

📌 Hyperparamètres vs paramètres
$n, m, p, T$ sont des hyperparamètres — choisis avant l'entraînement.
Les matrices $U, V, W, B^h, B^o$ sont les paramètres — appris pendant l'entraînement.

Pour chaque instant $t$ :

$X^t$ = vecteur d'entrée à $t$, $X^t \in \mathbb{R}^n$
$H^t$ = état caché à $t$, $H^t \in \mathbb{R}^m$
$Y^t$ = sortie du réseau à $t$, $Y^t \in \mathbb{R}^p$

Exemple concret $n=4$ : chaque élément d'entrée représenté par un vecteur de taille 4.
$m=5$ : la couche cachée contient 5 neurones.
$p=10$ : la sortie contient 10 neurones.
$T=15$ : la séquence contient 15 éléments.

4. Paramètres d'un RNN

Un RNN possède plusieurs matrices de poids et vecteurs de biais. Les principales matrices sont :

Symbole	Rôle	Dimensions
$U$	Poids entre $X^t$ et la couche cachée $H^t$	$m \times n$
$V$	Poids entre ancien état caché $H^{t-1}$ et état caché courant $H^t$	$m \times m$
$W$	Poids entre état caché $H^t$ et sortie $Y^t$	$p \times m$
$B^h$	Biais de la couche cachée	$m \times 1$
$B^o$	Biais de sortie	$p \times 1$

5. Calcul de l'état caché

L'état $H^t$ est la mémoire du RNN à l'instant $t$.

Formule $$H^t = \sigma_h\!\left( U \cdot X^t + V \cdot H^{t-1} + B^h \right)$$ avec $\sigma_h = \tanh$ (activation de la couche cachée).

$\tanh$ donne des valeurs entre $-1$ et $1$. Cela permet de construire un état caché qui dépend du présent $X^t$ mais aussi de $H^{t-1}$. C'est ce qui donne au RNN sa capacité à traiter une séquence.

6. Calcul de la sortie

La sortie du RNN est calculée à partir de l'état caché :

$$Y^t = \sigma_o\!\left( W \cdot H^t + B^o \right)$$ avec $\sigma_o = \text{Softmax}$ pour une classification multi-classe.

Softmax transforme les valeurs de sortie en probabilités :

$$0 \le Y_i \le 1 \quad \text{et} \quad \sum_i Y_i = 1$$

Exemple $Y_0 = 0{,}015$, $Y_1 = 0{,}005$, …, $Y_5 = 0{,}44$ → le mot prédit le plus probable est celui d'indice 5.

7. RNN et prédiction du mot suivant

On a une séquence de mots $X^1, X^2, \ldots, X^t$. Le RNN doit prédire le mot suivant $X^{t+1}$.

Exemple Entrée : « Je vais à la » → sortie attendue : « maison ».

Si le vocabulaire contient $|A|$ mots, la couche de sortie contient $|A|$ neurones. Chaque neurone correspond à un mot possible du vocabulaire. La sortie Softmax donne la probabilité de chaque mot du vocabulaire.

8. Types de problèmes séquentiels

Type	Description	Exemple
Many-to-one	1 séquence en entrée, 1 seule sortie	Sentiment d'une phrase : positif / négatif. On lit toute la phrase, puis on produit 1 seul label.
One-to-many	1 seule entrée, 1 séquence en sortie	Image → description en mots (image captioning).
Many-to-many	1 séquence en entrée, 1 séquence en sortie	Phrase EN → phrase FR (traduction automatique).

9. Dérouler un RNN dans le temps

Un RNN est représenté par une boucle, mais pour comprendre l'apprentissage, on le déroule dans le temps.

Au lieu de voir 1 cellule avec une boucle, on voit plusieurs copies du même réseau :

$X^1$→ $H^1$→ $Y^1$ · $X^2$→ $H^2$→ $Y^2$ … $X^T$→ $H^T$→ $Y^T$

⚠️ Attention Ce ne sont pas des réseaux différents. C'est le même réseau avec les mêmes paramètres $U, V, W, B^h, B^o$, réutilisés à chaque étape.

Deux formes de rétropropagation

Rétropropagation classique — pour les couches non récurrentes
Rétropropagation à travers le temps (BPTT, Backpropagation Through Time) — pour les couches récurrentes : on déplie le RNN puis on applique la rétropropagation classique sur le graphe étendu

10. Apprentissage dans un RNN

Comme pour les autres réseaux, apprendre signifie trouver les bons paramètres.

L'erreur dépend des paramètres : $E(U, V, W, B^h, B^o)$. L'objectif est de minimiser l'erreur avec une descente de gradient. On note $P$ l'ensemble des paramètres.

L'erreur totale est la somme des erreurs à chaque instant :

$$E(P) = \sum_t E^t(P), \quad \text{avec} \quad E^t(P) = \mathrm{loss}\!\left(Y^t, \hat{Y}^t\right)$$

11. LSTM — idée générale

Pour corriger le problème de mémoire courte (inconvénient majeur des RNN classiques), on introduit une variante appelée :

LSTM = Long Short Term Memory

C'est un RNN amélioré, capable de mieux gérer ce qu'il doit garder, oublier, faire passer en sortie.

Il contient une mémoire interne appelée :

$c_t$ = état de la cellule (à l'échelle du temps)

Évolution historique DL → RNN → LSTM → Encodeur-Décodeur → Attention → Transformers

12. Les portes du LSTM

Un LSTM utilise des portes (aussi appelées gates). Il y a 3 portes principales :

Porte	Nom	Rôle
$f_t$	Forget gate	Porte d'oubli — décide ce qu'on oublie
$i_t$	Input gate	Porte d'entrée — décide ce qu'on ajoute
$o_t$	Output gate	Porte de sortie — décide ce qui sort

Elles prennent des valeurs entre 0 et 1.

📌 Interprétation

Valeur proche de 0 → on bloque / oublie
Valeur proche de 1 → on laisse passer / on garde

Ces portes permettent à la cellule de décider quelle partie de l'information doit être conservée, ajoutée ou sortie.

Mémoire du LSTM

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

1er terme $f_t \cdot c_{t-1}$ : ancienne mémoire conservée (filtrée par la forget gate)
2e terme $i_t \cdot \tilde{c}_t$ : nouvelle information candidate ajoutée

Sortie du LSTM

$$h_t = o_t \cdot \tanh(c_t)$$

Calcul des portes (sigmoïdes)

$$i_t = \sigma\!\left(W_{xi}\,X_t + W_{hi}\,h_{t-1} + B_i\right)$$ $$f_t = \sigma\!\left(W_{xf}\,X_t + W_{hf}\,h_{t-1} + B_f\right)$$ $$o_t = \sigma\!\left(W_{xo}\,X_t + W_{ho}\,h_{t-1} + B_o\right)$$

À retenir LSTM = RNN avec mémoire + portes de contrôle.

13. Encodeur-Décodeur

Architecture utilisée pour les problèmes séquence-à-séquence. Exemple : traduction (phrase FR → phrase EN).

Principe

Encodeur : lit la séquence d'entrée
Vecteur contexte : résumé de la séquence d'entrée
Décodeur : produit la séquence de sortie

Schéma
Seq1 → [RNN encodeur] → vecteur contexte → [RNN décodeur] → Seq2

Le décodeur s'arrête quand il rencontre un token spécial <end of token>.

14. Mécanisme d'attention

Le problème de l'encodeur-décodeur classique : il résume toute la séquence dans un seul vecteur contexte. Pour une phrase longue, ce résumé peut être insuffisant.

Mécanisme d'attention Permet au modèle de se concentrer sur les parties importantes de la séquence d'entrée au moment de produire chaque élément de sortie.

L'attention donne donc des poids différents aux éléments de la séquence d'entrée. L'idée est que le réseau apprenne automatiquement où regarder.

[RNN] → "Mécanisme d'attention" → sortie

★ Réviser le chapitre

Pour vérifier ta compréhension

Pourquoi un RN classique n'est-il pas adapté aux séquences ?

Un RN feedforward classique traite chaque entrée indépendamment — il ne garde pas en mémoire ce qui est arrivé avant. Or pour une phrase (« Le chien mord l'homme » ≠ « L'homme mord le chien »), l'ordre et le contexte précédent sont essentiels. Les RNN introduisent une boucle : l'état $H^{t-1}$ est réinjecté à l'étape $t$, ce qui constitue une mémoire interne.

Quelle est la différence entre paramètres et hyperparamètres d'un RNN ?

Hyperparamètres (choisis avant l'entraînement) : $n$ (taille couche d'entrée), $m$ (taille couche cachée), $p$ (taille sortie), $T$ (longueur séquence). Paramètres (appris pendant l'entraînement) : les matrices $U$ (entrée→cachée, $m \times n$), $V$ (cachée→cachée, $m \times m$), $W$ (cachée→sortie, $p \times m$), et les biais $B^h$ ($m \times 1$) et $B^o$ ($p \times 1$).

Comment se calcule l'état caché à un instant $t$ ?

Formule : $H^t = \tanh(U \cdot X^t + V \cdot H^{t-1} + B^h)$. L'activation $\tanh$ produit des valeurs entre $-1$ et $1$. L'état caché dépend à la fois de l'entrée courante $X^t$ et de l'état précédent $H^{t-1}$ — c'est ce qui donne au RNN sa capacité à traiter une séquence.

Qu'est-ce que la BPTT (rétropropagation à travers le temps) ?

Pour calculer le gradient dans un RNN, on déroule le réseau dans le temps (on voit plusieurs copies du même réseau, une par instant $t$), puis on applique la rétropropagation classique sur ce graphe étendu. Attention : ce ne sont pas des réseaux différents — les mêmes paramètres $U, V, W, B^h, B^o$ sont réutilisés à chaque étape, donc leurs mises à jour s'accumulent.

Pourquoi le LSTM résout-il le problème du RNN classique ?

Le RNN classique souffre de mémoire courte (gradients qui disparaissent ou explosent sur longues séquences). Le LSTM introduit une mémoire interne $c_t$ (état de la cellule) et 3 portes (forget $f_t$, input $i_t$, output $o_t$) qui décident ce qu'il faut garder, ajouter, sortir. Les portes sont des sigmoïdes — proche de 0 = on bloque, proche de 1 = on laisse passer.

Quelle est la formule de la mémoire $c_t$ du LSTM ?

$c_t = f_t \cdot c_{t-1} + i_t \cdot \tilde{c}_t$. Le 1er terme = ancienne mémoire conservée (filtrée par la forget gate). Le 2e terme = nouvelle information candidate ajoutée (filtrée par la input gate). La sortie du LSTM est ensuite $h_t = o_t \cdot \tanh(c_t)$.

À quoi sert le mécanisme d'attention ?

L'encodeur-décodeur classique résume toute la séquence d'entrée dans un seul vecteur contexte. Pour une phrase longue, ce résumé devient insuffisant. Le mécanisme d'attention donne des poids différents aux éléments de la séquence d'entrée au moment de produire chaque élément de sortie — le réseau apprend automatiquement où regarder.

🃏 Flashcards éclair

Clique pour retourner.

Définition RNN

1 caractéristique clé.

tourne →

RN qui contient une boucle : l'info d'un instant précédent peut être réutilisée au suivant.

Matrice U

Rôle et dimensions.

$U : m \times n$
Poids entre $X^t$ et $H^t$

Matrice V

Rôle et dimensions.

$V : m \times m$
Poids entre $H^{t-1}$ et $H^t$

Matrice W

Rôle et dimensions.

$W : p \times m$
Poids entre $H^t$ et $Y^t$

État caché

Formule.

$H^t = \tanh(U X^t + V H^{t-1} + B^h)$

Many-to-one

Cas d'usage.

1 séquence → 1 sortie. Ex : sentiment d'une phrase (positif/négatif).

One-to-many

Cas d'usage.

1 entrée → 1 séquence. Ex : image captioning (image → description).

Many-to-many

Cas d'usage.

1 séquence → 1 séquence. Ex : traduction (FR → EN).

3 portes LSTM

Lesquelles ?

$f_t$ forget · $i_t$ input · $o_t$ output. Sigmoïdes, valeurs $\in [0, 1]$.

Mémoire LSTM

Formule de $c_t$.

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

Attention

Idée centrale.

Donner des poids différents aux éléments de la séquence d'entrée → le réseau apprend où regarder.

🎯 Quiz QCM

1.Qu'est-ce qui distingue un RNN d'un RN classique ?

Le nombre de couches
L'utilisation de Softmax
La présence d'une boucle réutilisant l'état précédent
L'utilisation de ReLU

Le RNN a une boucle qui réinjecte $H^{t-1}$ à l'étape $t$ — c'est sa mémoire interne.

2.Quelle est la fonction d'activation utilisée pour l'état caché d'un RNN ?

ReLU
tanh
Softmax
Identité

$H^t = \tanh(U X^t + V H^{t-1} + B^h)$. tanh donne des valeurs entre $-1$ et $1$.

3.Pour traduire une phrase EN en FR, on a un problème :

many-to-one
one-to-many
many-to-many
one-to-one

Séquence de mots en entrée → séquence de mots en sortie = many-to-many.

4.Quel est le problème principal du RNN classique que résout le LSTM ?

Trop de paramètres à apprendre
Mémoire courte (gradients qui disparaissent/explosent)
Difficulté à traiter les images
Sur-apprentissage systématique

Les LSTM ajoutent une mémoire interne $c_t$ et 3 portes pour gérer le flot d'information sur de longues séquences.

5.Que représente une valeur de porte LSTM proche de 1 ?

On désactive 100 % des neurones
On bloque / oublie l'information
On laisse passer / on garde l'information
On amplifie l'information par 10

Les portes sont des sigmoïdes ∈ [0, 1]. Proche de 0 = bloque/oublie. Proche de 1 = laisse passer/garde.

6.Quel est l'apport principal du mécanisme d'attention ?

Accélérer l'apprentissage
Réduire le nombre de paramètres
Permettre l'utilisation de CNN à la place de RNN
Donner des poids différents aux éléments de la séquence d'entrée selon l'élément de sortie produit

L'attention résout la limitation du vecteur contexte unique de l'encodeur-décodeur classique.

📋 Anti-sèche du chapitre

Pourquoi RNN : séquences (phrase, texte, vidéo)
Définition : RN avec boucle, réutilise info précédente
$H^t$ = mémoire à l'instant t
$n, m, p, T$ = hyperparamètres (avant entraînement)
$U, V, W, B^h, B^o$ = paramètres (appris)
$U : m \times n$, $V : m \times m$, $W : p \times m$
État caché : $H^t = \tanh(U X^t + V H^{t-1} + B^h)$
Sortie : $Y^t = \mathrm{Softmax}(W H^t + B^o)$
Softmax : probas de chaque mot du vocabulaire
Many-to-one : sentiment d'une phrase
One-to-many : image captioning
Many-to-many : traduction
BPTT = backpropagation through time
Erreur : $E = \sum_t E^t$
LSTM = RNN + mémoire + portes
3 portes : forget $f_t$, input $i_t$, output $o_t$
Portes $\in [0, 1]$ via sigmoïde
Mémoire LSTM : $c_t = f_t c_{t-1} + i_t \tilde{c}_t$
Sortie LSTM : $h_t = o_t \tanh(c_t)$
Encodeur-Décodeur : seq-à-seq (traduction)
Attention : poids différents par élément de la séquence