【PyTorch學習筆記】23：nn.LSTM和nn.LSTMCell的使用

1 nn.LSTM

該模塊一次構造完若干層的LSTM。

1.1 構造方法

使用nn.LSTM可以直接構建若干層的LSTM，構造時傳入的三個參數和nn.RNN一樣，依次是：
$[feature\_len,hidden\_len,num\_layers]$

其中hidden_len既用於隱藏狀態$h_t$的尺寸，也用於記憶單元$C_t$的尺寸。實際上，兩者的shape是一樣的，都是$[num\_layers,batch,hidden\_len]$。

1.2 forward方法

回顧一下nn.RNN的forward方法，它是：
$out,h_t = rnn(x,h_0)$

而對於nn.LSTM也是類似的，無非是要多提供初始的$C_0$，並在最終多得到一個$C_t$：
$out, (h_t, C_t) = lstm(x,(h_0,C_0))$

其中，$x$仍然是一次性將當前batch所有seq_len個時刻的樣本都輸入，其shape是$[seq\_len,batch,feature\_len]$。

在任意$t$時刻的$h_t$和$C_t$兩類Memory其shape都是$[num\_layers,batch,hidden\_len]$。

最終的輸出$out$同樣是在所有時刻最後一層上的輸出（特別注意，LSTM中的輸出是$h$不是$C$），因此是將feature_len規約成了hidden_len那麼長，所以其shape是$[seq\_len,batch,hidden\_len]$。

1.3 例子

import torch
from torch import nn

# 如可以解釋成:4層的LSTM,輸入的每個詞用100維向量表示,隱藏單元和記憶單元的尺寸是20
lstm = nn.LSTM(input_size=100, hidden_size=20, num_layers=4)

# 輸入的x:其中batch是3可表示有三句話,seq_len=10表示每句話10個單詞,feature_len=100表示每個單詞表示爲長100的向量
x = torch.randn(10, 3, 100)

# 前向計算過程,這裏不傳入h_0和C_0則會默認初始化
out, (h, c) = lstm(x)
print(out.shape)  # torch.Size([10, 3, 20]) 最後一層10個時刻的輸出
print(h.shape)  # torch.Size([4, 3, 20]) 隱藏單元
print(c.shape)  # torch.Size([4, 3, 20]) 記憶單元

2 nn.LSTMCell

該模塊構建LSTM中的一個Cell，同一層會共享這一個Cell，但要手動處理每個時刻的迭代計算過程。如果要建立多層的LSTM，就要建立多個nn.LSTMCell。

2.1 構造方法

構造方法和nn.LSTM類似，依次傳入feature_len和hidden_len，因爲這只是一個計算單元，所以不涉及層數。

2.2 forward方法

回顧一下nn.RNNCell的forward方法，它是：
$h_t = rnncell(x,h_{t-1})$

即上一時刻的輸出$h_{t-1}$經nn.RNNCell前向計算得到這一時刻的$h_t$。

對於nn.LSTMCell也是類似，但因爲LSTM計算單元中還涉及對上一時刻的記憶$C_{t-1}$的使用，所以是：
$h_t,C_t = lstmcell(x_t,(h_{t-1},C_{t-1}))$

因爲輸入$x_t$只是t時刻的輸入，不涉及seq_len，所以其shape是$[batch,feature\_len]$。

而$h_t$和$C_t$在這裏只是t時刻本層的隱藏單元和記憶單元，不涉及num_layers，所以其shape是$[batch,hidden\_len]$。

2.3 一層的例子

每個時刻傳入新的輸入$x_t$和上一時刻的隱藏單元$h_{t-1}$和記憶單元$C_{t-1}$，並把這兩個單元更新。

import torch
from torch import nn

# 一層的LSTM計算單元,輸入的feature_len=100,隱藏單元和記憶單元hidden_len=20
cell = nn.LSTMCell(input_size=100, hidden_size=20)

# 初始化隱藏單元h和記憶單元C,取batch=3
h = torch.zeros(3, 20)
C = torch.zeros(3, 20)

# 這裏是seq_len=10個時刻的輸入,每個時刻shape都是[batch,feature_len]
xs = [torch.randn(3, 100) for _ in range(10)]

# 對每個時刻,傳入輸入x_t和上個時刻的h_{t-1}和C_{t-1}
for xt in xs:
    h, C = cell(xt, (h, C))

print(h.shape)  # torch.Size([3, 20])
print(C.shape)  # torch.Size([3, 20])

2.4 兩層的例子

在最底下一層l0層和上面的例子一樣，上層還需要接受下層的輸出$h_t$作爲當前輸入，然後同樣是依賴本層上一時刻的$h$和$C$更新本層的$h$和$C$。

特別要注意DL學習筆記4中學習的LSTM單元的輸入輸出結構，向上層傳遞的是$h$而不是$C$。

import torch
from torch import nn

# 輸入的feature_len=100,變到該層隱藏單元和記憶單元hidden_len=30
cell_l0 = nn.LSTMCell(input_size=100, hidden_size=30)
# hidden_len從l0層的30變到這一層的20
cell_l1 = nn.LSTMCell(input_size=30, hidden_size=20)

# 分別初始化l0層和l1層的隱藏單元h和記憶單元C,取batch=3
# 注意l0層的hidden_len=30
h_l0 = torch.zeros(3, 30)
C_l0 = torch.zeros(3, 30)
# 而到l1層之後hidden_len=20
h_l1 = torch.zeros(3, 20)
C_l1 = torch.zeros(3, 20)

# 這裏是seq_len=10個時刻的輸入,每個時刻shape都是[batch,feature_len]
xs = [torch.randn(3, 100) for _ in range(10)]

# 對每個時刻,從下到上計算本時刻的所有層
for xt in xs:
    h_l0, C_l0 = cell_l0(xt, (h_l0, C_l0))  # l0層直接接受xt輸入
    h_l1, C_l1 = cell_l1(h_l0, (h_l1, C_l1))  # l1層接受l0層的輸出h爲輸入

# 最後shape是不變的
print(h_l0.shape)  # torch.Size([3, 30])
print(C_l0.shape)  # torch.Size([3, 30])
print(h_l1.shape)  # torch.Size([3, 20])
print(C_l1.shape)  # torch.Size([3, 20])