Cellules LSTM et GRU

Deep learning intermédiaire avec PyTorch

Michal Oleszak

Machine Learning Engineer

Problème de mémoire court terme

Les cellules RNN gardent une mémoire via l’état caché
Cette mémoire est très court terme
Deux cellules plus puissantes résolvent le problème :
- LSTM (Long Short-Term Memory)
- GRU (Gated Recurrent Unit)

Schéma du neurone récurrent. Au pas de temps 2, il reçoit en entrée h2 et x2, et produit en sortie y2 et h3.

Cellule RNN

Schéma de la cellule RNN.

Deux entrées :
- donnée courante x
- état caché précédent h
Deux sorties :
- sortie courante y
- état caché suivant h

Cellule LSTM

Schéma de la cellule LSTM.

Les sorties h et y sont identiques

Trois entrées et sorties (deux états cachés) :
- h : état court terme
- c : état long terme
Trois « portes » :
- Porte d’oubli : quoi retirer de la mémoire long terme
- Porte d’entrée : quoi enregistrer en mémoire long terme
- Porte de sortie : quoi retourner au pas de temps courant

LSTM dans PyTorch

class Net(nn.Module):
    def __init__(self, input_size):
        super().__init__()

        self.lstm = nn.LSTM(
            input_size=1,
            hidden_size=32,
            num_layers=2,
            batch_first=True,
        )
        self.fc = nn.Linear(32, 1)


    def forward(self, x):
        h0 = torch.zeros(2, x.size(0), 32)
        c0 = torch.zeros(2, x.size(0), 32)

        out, _ = self.lstm(x, (h0, c0))

        out = self.fc(out[:, -1, :])
        return out

__init__():
- Remplacez nn.RNN par nn.LSTM
forward():
- Ajoutez un autre état caché c
- Initialisez c et h à zéro
- Passez les deux états cachés à la couche lstm

Cellule GRU

Schéma de la cellule GRU.

Version simplifiée de la cellule LSTM
Un seul état caché
Pas de porte de sortie

GRU dans PyTorch

class Net(nn.Module):
    def __init__(self, input_size):
        super().__init__()

        self.gru = nn.GRU(
            input_size=1,
            hidden_size=32,
            num_layers=2,
            batch_first=True,
        )
        self.fc = nn.Linear(32, 1)


    def forward(self, x):
        h0 = torch.zeros(2, x.size(0), 32)
        out, _ = self.gru(x, h0)
        out = self.fc(out[:, -1, :])
        return out

__init__():
- Remplacez nn.RNN par nn.GRU
forward():
- Utilisez la couche gru

Faut-il utiliser RNN, LSTM ou GRU ?

RNN est peu utilisé désormais
GRU est plus simple que LSTM = moins de calcul
Les performances relatives varient selon le cas d’usage
Testez les deux et comparez

Schémas des cellules LSTM et GRU.

Passons à la pratique !

Deep learning intermédiaire avec PyTorch