LSTM- och GRU-celler

Fördjupad djupinlärning med PyTorch

Michal Oleszak

Machine Learning Engineer

Problem med korttidsminne

RNN-celler lagrar minne via dolt tillstånd
Det här minnet är väldigt kortsiktigt
Två kraftfullare celler löser problemet:
- LSTM-cell (Long Short-Term Memory)
- GRU-cell (Gated Recurrent Unit)

Schema över den rekurrenta neuronen. Vid tidssteg 2 tar den emot indata h2 och x2, och producerar utdata y2 och h3.

RNN-cell

Schema över RNN-cellen.

Två indata:
- aktuella indata x
- föregående dolt tillstånd h
Två utdata:
- aktuellt utdata y
- nästa dolda tillstånd h

LSTM-cell

Schema över LSTM-cellen.

Utdata h och y är desamma

Tre indata och utdata (två dolda tillstånd):
- h: kortsiktigt tillstånd
- c: långsiktigt tillstånd
Tre "grindar":
- Glömgrind: vad som tas bort från långtidsminnet
- Ingrind: vad som sparas till långtidsminnet
- Utgrind: vad som returneras vid aktuellt tidssteg

LSTM i 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__():
- Ersätt nn.RNN med nn.LSTM
forward():
- Lägg till ett dolt tillstånd c
- Initiera c och h med nollor
- Skicka båda dolda tillstånden till lstm-lagret

GRU-cell

Schema över GRU-cellen.

Förenklad version av LSTM-cellen
Bara ett dolt tillstånd
Ingen utgrind

GRU i 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__():
- Ersätt nn.RNN med nn.GRU
forward():
- Använd gru-lagret

Ska jag använda RNN, LSTM eller GRU?

RNN används sällan längre
GRU är enklare än LSTM = mindre beräkning
Relativ prestanda varierar beroende på användningsfall
Prova båda och jämför

Scheman över LSTM- och GRU-cellerna.

Nu kör vi en övning!

Fördjupad djupinlärning med PyTorch