Cellules LSTM et GRU

Apprentissage profond 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èglent le problème :
- cellule LSTM (Long Short-Term Memory)
- cellule GRU (Gated Recurrent Unit)

Schéma du neurone récurrent. À l'instant 2, il reçoit les entrées h2 et x2, et produit les sorties y2 et h3.

Cellule RNN

Schéma de la cellule RNN.

Deux entrées :
- donnée d'entrée courante x
- état caché précédent h
Deux sorties :
- sortie courante y
- prochain état caché 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 conserver en mémoire à long terme
- Porte de sortie : quoi retourner à l'instant 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__() :
- Remplacer nn.RNN par nn.LSTM
forward() :
- Ajouter un autre état caché c
- Initialiser c et h à zéro
- Transmettre 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é
Aucune 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__() :
- Remplacer nn.RNN par nn.GRU
forward() :
- Utiliser la couche gru

Dois-je utiliser RNN, LSTM ou GRU ?

RNN est peu utilisé désormais
GRU est plus simple que LSTM = moins de calcul
Le rendement relatif varie selon le cas d'usage
Essayez les deux et comparez

Schémas des cellules LSTM et GRU.

Passons à la pratique !

Apprentissage profond intermédiaire avec PyTorch