一. LSTM长短期记忆网络

1. 介绍

长期以来，隐变量模型存在着长期信息保存和短期输入缺失的问题，解决这一问题的最早方法之一是长短期存储器（long short-term memory，LSTM），它有许多与门控循环单元GRU一样的属性，但是长短期记忆网络的设计比门控循环单元稍微复杂一些， 却比门控循环单元早诞生了近20年。

2. 门控记忆单元

长短期记忆网络的设计灵感来自于计算机的逻辑门，长短期记忆网络引入了记忆元（memory cell），或简称为单元（cell）。 有些文献认为记忆元是隐状态的一种特殊类型， 它们与隐状态具有相同的形状，其设计目的是用于记录附加的信息。 为了控制记忆元，我们需要许多门。 其中一个门用来从记忆单元中输出条目，将其称为输出门（output gate）；另外一个门用来决定何时将数据读入记忆单元，将其称为输入门（input gate）；同时还需要一种机制来重置单元的内容，由遗忘门（forget gate）来管理（跟GRU中重置门一样）， 这种设计的动机与门控循环单元相同， 能够通过专用机制决定什么时候记忆或忽略隐状态中的输入。

3.输入门、忘记门和输出门

就如在门控循环单元中一样，当前时间步的输入和前一个时间步的隐状态
作为数据送入长短期记忆网络的门中如下图所示，它们由三个具有sigmoid激活函数的全连接层处理，以计算输入门、遗忘门和输出门的值。因此这三个门的值都在$(0,1)$的范围内。

长短期记忆网络的三个门计算数学表达：
假设有$h$个隐藏单元，批量大小为$n$，输入数为$d$。因此输入为${\mathbf{X}}_t\in {\mathbb{R}}^{n\times d}$，前一时间步的隐状态为${\mathbf{H}}_{t-1}\in {\mathbb{R}}^{n\times h}$。相应地，时间步$t$的门被定义如下：输入门是${\mathbf{I}}_t\in {\mathbb{R}}^{n\times h}$，遗忘门是${\mathbf{F}}_t\in {\mathbb{R}}^{n\times h}$，输出门是${\mathbf{O}}_t\in {\mathbb{R}}^{n\times h}$。它们的计算方法如下：
I t = σ ( X t W x i + H t − 1 W h i + b i ) , F t = σ ( X t W x f + H t − 1 W h f + b f ) , O t = σ ( X t W x o + H t − 1 W h o + b o ) ,

It​Ft​Ot​​=σ(Xt​Wxi​+Ht−1​Whi​+bi​),=σ(Xt​Wxf​+Ht−1​Whf​+bf​),=σ(Xt​Wxo​+Ht−1​Who​+bo​),​
其中${\mathbf{W}}_{xi},{\mathbf{W}}_{xf},{\mathbf{W}}_{xo}\in {\mathbb{R}}^{d\times h}$和${\mathbf{W}}_{hi},{\mathbf{W}}_{hf},{\mathbf{W}}_{ho}\in {\mathbb{R}}^{h\times h}$是权重参数，${\mathbf{b}}_i,{\mathbf{b}}_f,{\mathbf{b}}_o\in {\mathbb{R}}^{1\times h}$是偏置参数。

4. 候选记忆元

候选记忆元（candidate memory cell）${\tilde{\mathbf{C}}}_t\in {\mathbb{R}}^{n\times h}$的计算与上面描述的三个门的计算类似，但是使用$\tanh$函数作为激活函数，函数的值范围为(-1, 1)，下面计算在时间步$t$处的候选记忆元：

$${\tilde{\mathbf{C}}}_t=\text{tanh}({\mathbf{X}}_t{\mathbf{W}}_{xc}+{\mathbf{H}}_{t-1}{\mathbf{W}}_{hc}+{\mathbf{b}}_c),$$

其中${\mathbf{W}}_{xc}\in {\mathbb{R}}^{d\times h}$和${\mathbf{W}}_{hc}\in {\mathbb{R}}^{h\times h}$是权重参数，${\mathbf{b}}_c\in {\mathbb{R}}^{1\times h}$是偏置参数，如下图所示。

5.记忆元

在门控循环单元中，有一种机制来控制输入和遗忘（或跳过）。类似地，在长短期记忆网络中也有两个门用于这样的目的：输入门${\mathbf{I}}_t$控制采用多少来自${\tilde{\mathbf{C}}}_t$的新数据，而遗忘门${\mathbf{F}}_t$控制保留多少过去的记忆元${\mathbf{C}}_{t-1}\in {\mathbb{R}}^{n\times h}$的内容。使用按元素乘法，得出：

$${\mathbf{C}}_t={\mathbf{F}}_t\odot {\mathbf{C}}_{t-1}+{\mathbf{I}}_t\odot {\tilde{\mathbf{C}}}_t.$$

如果遗忘门始终为$1$且输入门始终为$0$，则过去的记忆元${\mathbf{C}}_{t-1}$将随时间被保存并传递到当前时间步，也即是记忆元始终没有改变，引入这种设计是为了缓解梯度消失问题，并更好地捕获序列中的长距离依赖关系。这样我们就得到了计算记忆元的流程图，如下图所示：

6.隐状态

最后定义如何计算隐状态${\mathbf{H}}_t\in {\mathbb{R}}^{n\times h}$，这就是输出门发挥作用的地方。在长短期记忆网络中，它仅仅是记忆元的$\tanh$的门控版本，这就确保了${\mathbf{H}}_t$的值始终在区间$(-1,1)$内：
$${\mathbf{H}}_t={\mathbf{O}}_t\odot \tanh ({\mathbf{C}}_t).$$

只要输出门接近$1$，就能够有效地将所有记忆信息传递给输出层预测输出的输入以及传递到下一个时间步，而对于输出门接近$0$，只保留记忆元内的所有信息，而不需要更新隐状态，隐状态计算流如下图所示。

二.从零实现LSTM

1. 加载时光机器数据集

import torch
import d2l.torch
from torch import nn
batch_size,num_steps = 32,35
train_iter,vocab = d2l.torch.load_data_time_machine(batch_size,num_steps)
1
2
3
4
5

2. 模型参数初始化

接下来定义和初始化模型参数，超参数num_hiddens定义隐藏单元的数量，按照标准差 0.01 的高斯分布初始化权重，并将偏置项设为 0 。

def get_lstm_params(vocab_size,num_hiddens,device):
    input_size = output_size = vocab_size
    def normal(shape):
        return torch.randn(size=shape,device=device)*0.01 #生成均值为0，方差为0.01的权重参数
    def three():
        return (normal((input_size,num_hiddens)),
                normal((num_hiddens,num_hiddens)),
                torch.zeros(num_hiddens,device=device))
    W_xi,W_hi,b_i = three() # 输入门参数
    W_xf,W_hf,b_f = three() # 遗忘门参数
    W_xo,W_ho,b_o = three() # 输出门参数
    W_xc,W_hc,b_c = three() # 候选记忆元参数
    # 输出层参数
    W_hq = normal(shape=(num_hiddens,output_size))
    b_q = torch.zeros(output_size,device=device)
    # 设置模型权重参数梯度为True
    params = [W_xi,W_hi,b_i,W_xf,W_hf,b_f,W_xo,W_ho,b_o,W_xc,W_hc,b_c,W_hq,b_q]
    for param in params:
        param.requires_grad_(True)
    return params
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 模型定义

在初始化函数中长短期记忆网络的隐状态需要返回一个额外的记忆元， 单元的值为0，形状为（批量大小，隐藏单元数），隐藏状态初始化如下：

def init_lstm_state(batch_size,num_hiddens,device):
    return (torch.zeros(size=(batch_size,num_hiddens),device=device),
            torch.zeros(size=(batch_size,num_hiddens),device=device))
1
2
3

模型的定义：定义三个门和一个额外的记忆元以及计算方式， 注意只有隐状态才会传递到输出层， 而记忆元${\mathbf{C}}_t$不直接参与输出计算。

def lstm(inputs,state,params):
    # inputs形状为(num_steps,batch_size,vocab_size)为一个批量样本数据
    [W_xi,W_hi,b_i,W_xf,W_hf,b_f,W_xo,W_ho,b_o,W_xc,W_hc,b_c,W_hq,b_q] = params
    (H,C) = state
    outputs = []
    for X in inputs:
        # X代表每个时间步下的每个批量的数据
        # I表示（决定如何）把到目前为止（到当前时间步）看到的数据序列信息有用的部分选择性提取
        I = torch.sigmoid((X @ W_xi+H @ W_hi+b_i))
        # F表示（决定如何）把到前一个时间步存储的序列数据信息无用的部分选择性遗忘
        F = torch.sigmoid((X @ W_xf+H @ W_hf+b_f))
        # O表示（决定如何）把从头到当前数据有用的信息选择性部分提取出来
        O = torch.sigmoid((X @ W_xo+H @ W_ho+b_o))
        #C_tilda表示根据前一个时间步计算出来的隐状态（存储过去时间步的序列信息）结合当前时间步数据信息得到
        #到目前为止的数据序列整个看到的信息（有哪些联系）（表示把当前时间步的数据信息与过去序列数据结合起来表示存储从头到当前数据的整个信息）
        C_tilda = torch.tanh((X @ W_xc+H @ W_hc+ b_c))
        # F*C表示选择性对过去记忆的信息遗忘（对过去看到的序列数据无用的一部分信息选择性遗忘），I*C_tilda表示把从头到当前数据整个信息有用的一部分选择性提取出来，C表示存储从头到当前序列数据中的有用的信息
        C = I * C_tilda + F * C
        # H表示把从头到当前数据有用信息选择性部分提取出来，用于更新隐状态H，以及作为输入用于预测输出层的输出
        H = O * torch.tanh(C)
        Y = H @ W_hq + b_q
        outputs.append(Y)
    return torch.cat(outputs,dim=0),(H,C)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4. 训练与预测

模型训练与预测结果如下图所示。

vocab_size,num_hiddens,device=len(vocab),256,d2l.torch.try_gpu()
num_epochs,lr = 500,1
model = d2l.torch.RNNModelScratch(vocab_size,num_hiddens,device,get_lstm_params,init_lstm_state,lstm)
d2l.torch.train_ch8(model,train_iter,vocab,lr,num_epochs,device,use_random_iter=False)
1
2
3
4

5. 从零实现LSTM全部代码

import torch
import d2l.torch
from torch import nn

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.torch.load_data_time_machine(batch_size, num_steps)


def get_lstm_params(vocab_size, num_hiddens, device):
    input_size = output_size = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device) * 0.01  #生成均值为0，方差为0.01的权重参数

    def three():
        return (normal((input_size, num_hiddens)),
                normal((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))

    W_xi, W_hi, b_i = three()  # 输入门参数
    W_xf, W_hf, b_f = three()  # 遗忘门参数
    W_xo, W_ho, b_o = three()  # 输出门参数
    W_xc, W_hc, b_c = three()  # 候选记忆元参数
    # 输出层参数
    W_hq = normal(shape=(num_hiddens, output_size))
    b_q = torch.zeros(output_size, device=device)
    # 设置模型权重参数梯度为True
    params = [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params


def init_lstm_state(batch_size, num_hiddens, device):
    return (torch.zeros(size=(batch_size, num_hiddens), device=device),
            torch.zeros(size=(batch_size, num_hiddens), device=device))


def lstm(inputs, state, params):
    # inputs形状为(num_steps,batch_size,vocab_size)为一个批量样本数据
    [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q] = params
    (H, C) = state
    outputs = []
    for X in inputs:
        # X代表每个时间步下的每个批量的数据
        # I表示（决定如何）把到目前为止（到当前时间步）看到的数据序列信息有用的部分选择性提取
        I = torch.sigmoid((X @ W_xi + H @ W_hi + b_i))
        # F表示（决定如何）把到前一个时间步存储的序列数据信息无用的部分选择性遗忘
        F = torch.sigmoid((X @ W_xf + H @ W_hf + b_f))
        # O表示（决定如何）把从头到当前数据有用的信息选择性部分提取出来
        O = torch.sigmoid((X @ W_xo + H @ W_ho + b_o))
        #C_tilda表示根据前一个时间步计算出来的隐状态（存储过去时间步的序列信息）结合当前时间步数据信息得到
        #到目前为止的数据序列整个看到的信息（有哪些联系）（表示把当前时间步的数据信息与过去序列数据结合起来表示存储从头到当前数据的整个信息）
        C_tilda = torch.tanh((X @ W_xc + H @ W_hc + b_c))
        # F*C表示选择性对过去记忆的信息遗忘（对过去看到的序列数据无用的一部分信息选择性遗忘），I*C_tilda表示把从头到当前数据整个信息有用的一部分选择性提取出来，C表示存储从头到当前序列数据中的有用的信息
        C = I * C_tilda + F * C
        # H表示把从头到当前数据有用信息选择性部分提取出来，用于更新隐状态H，以及作为输入用于预测输出层的输出
        H = O * torch.tanh(C)
        Y = H @ W_hq + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H, C)


vocab_size, num_hiddens, device = len(vocab), 256, d2l.torch.try_gpu()
num_epochs, lr = 500, 1
model = d2l.torch.RNNModelScratch(vocab_size, num_hiddens, device, get_lstm_params, init_lstm_state, lstm)
d2l.torch.train_ch8(model, train_iter, vocab, lr, num_epochs, device, use_random_iter=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

三. 使用Pytorch框架实现LSTM

1. 使用Pytorch框架实现LSTM

使用Pytorch框架API直接实例化LSTM模型，高级API封装了前文介绍的所有配置细节。 这段代码的运行速度要快得多， 因为它使用的是编译好的运算符而不是Python来处理之前阐述的许多细节，训练和预测结果如下图所示：

input_size = vocab_size
lstm_layer = nn.LSTM(input_size,num_hiddens)
model = d2l.torch.RNNModel(lstm_layer,vocab_size)
model = model.to(device)
d2l.torch.train_ch8(model,train_iter,vocab,lr,num_epochs,device,use_random_iter=False)
1
2
3
4
5

2. 使用Pytorch框架实现LSTM全部代码

input_size = vocab_size
lstm_layer = nn.LSTM(input_size,num_hiddens)
model = d2l.torch.RNNModel(lstm_layer,vocab_size)
model = model.to(device)
d2l.torch.train_ch8(model,train_iter,vocab,lr,num_epochs,device,use_random_iter=False)
1
2
3
4
5

四 小结

• 长短期记忆网络有三种类型的门：输入门、遗忘门和输出门。
• 长短期记忆网络的隐藏层输出包括“隐状态”和“记忆元”。只有隐状态会传递到输出层，而记忆元完全属于内部信息。
• 长短期记忆网络可以缓解梯度消失（计算记忆元公式：以相加的形式来计算记忆元，而不是直接更新覆盖记忆元的方式）和梯度爆炸。

五 链接

循环神经网络RNN第一篇：李沐动手学深度学习V2-NLP序列模型和代码实现
循环神经网络RNN第二篇：李沐动手学深度学习V2-NLP文本预处理和代码实现
循环神经网络RNN第三篇：李沐动手学深度学习V2-NLP语言模型、数据集加载和数据迭代器实现以及代码实现
循环神经网络RNN第四篇：李沐动手学深度学习V2-RNN原理
循环神经网络RNN第五篇：李沐动手学深度学习V2-RNN循环神经网络从零实现
循环神经网络RNN第六篇：李沐动手学深度学习V2-使用Pytorch框架实现RNN循环神经网络
循环神经网络GRU第七篇：李沐动手学深度学习V2-GRU门控循环单元以及代码实现
循环神经网络LSTM第八篇：李沐动手学深度学习V2-LSTM长短期记忆网络以及代码实现