Komórki LSTM i GRU

Głębokie uczenie z PyTorch – poziom średnio zaawansowany

Michal Oleszak

Machine Learning Engineer

Problem pamięci krótkoterminowej

Komórki RNN przechowują pamięć w stanie ukrytym
Ta pamięć jest bardzo krótkoterminowa
Dwa silniejsze typy komórek rozwiązują ten problem:
- Komórka LSTM (Long Short-Term Memory)
- Komórka GRU (Gated Recurrent Unit)

Schemat neuronu rekurencyjnego. W kroku czasowym 2 otrzymuje wejścia h2 i x2 oraz produkuje wyjścia y2 i h3.

Komórka RNN

Schemat komórki RNN.

Dwa wejścia:
- bieżące dane wejściowe x
- poprzedni stan ukryty h
Dwa wyjścia:
- bieżące wyjście y
- następny stan ukryty h

Komórka LSTM

Schemat komórki LSTM.

Wyjścia h i y są identyczne

Trzy wejścia i wyjścia (dwa stany ukryte):
- h: stan krótkoterminowy
- c: stan długoterminowy
Trzy bramki:
- Bramka zapominania: co usunąć z pamięci długoterminowej
- Bramka wejściowa: co zapisać w pamięci długoterminowej
- Bramka wyjściowa: co zwrócić w bieżącym kroku

LSTM w 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__():
- Zastąp nn.RNN przez nn.LSTM
forward():
- Dodaj drugi stan ukryty c
- Zainicjalizuj c i h zerami
- Przekaż oba stany ukryte do warstwy lstm

Komórka GRU

Schemat komórki GRU.

Uproszczona wersja komórki LSTM
Tylko jeden stan ukryty
Brak bramki wyjściowej

GRU w 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__():
- Zastąp nn.RNN przez nn.GRU
forward():
- Użyj warstwy gru

RNN, LSTM czy GRU?

RNN rzadko stosowane współcześnie
GRU prostsze niż LSTM = mniejsze obliczenia
Wydajność zależy od zastosowania
Warto przetestować oba i porównać

Schematy komórek LSTM i GRU.

Czas na ćwiczenia!

Głębokie uczenie z PyTorch – poziom średnio zaawansowany