李沐动手学深度学习V2-LSTM长短期记忆网络以及代码实现

一. 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}$。它们的计算方法如下：
$$\begin{array}{rl}{\mathbf{I}}_t& =\sigma ({\mathbf{X}}_t{\mathbf{W}}_{xi}+{\mathbf{H}}_{t-1}{\mathbf{W}}_{hi}+{\mathbf{b}}_i),\\ {\mathbf{F}}_t& =\sigma ({\mathbf{X}}_t{\mathbf{W}}_{xf}+{\mathbf{H}}_{t-1}{\mathbf{W}}_{hf}+{\mathbf{b}}_f),\\ {\mathbf{O}}_t& =\sigma ({\mathbf{X}}_t{\mathbf{W}}_{xo}+{\mathbf{H}}_{t-1}{\mathbf{W}}_{ho}+{\mathbf{b}}_o),\end{array}$$
其中${\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)，也即是在RNN中求当前隐状态的计算方法，下面计算在时间步$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)

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

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))

模型的定义：定义三个门和一个额外的记忆元以及计算方式， 注意只有隐状态才会传递到输出层， 而记忆元${\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)

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)

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)

三. 使用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)

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)

四 小结

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

五. 李宏毅机器学习对LSTM讲解

LSTM

前一篇提到的RNN只是最简单的版本，并没有对memory的管理多加约束，可以随时进行读取，而现在常用的memory管理方式叫做长短期记忆(Long Short-term Memory)，简称LSTM

冷知识：可以被理解为比较长的短期记忆，因此是short-term，而非是long-short term

Three-gate

LSTM有三个gate：

• 当某个neuron的输出想要被写进memory cell，它就必须要先经过一道叫做input gate的闸门，如果input gate关闭，则任何内容都无法被写入，而关闭与否、什么时候关闭，都是由神经网络自己学习到的

• output gate决定了外界是否可以从memory cell中读取值，当output gate关闭的时候，memory里面的内容同样无法被读取，也都是需要由神经网络自己学习的

• forget gate则决定了什么时候需要把memory cell里存放的内容忘记清空，什么时候依旧保存，也都是需要由神经网络自己学习的
  
  整个LSTM可以看做是4个input，1个output：

• 4个input=想要被存到memory cell里的值(也即是上面提到的候选记忆单元C_tilda)+操控input gate的信号+操控output gate的信号+操控forget gate的信号

• 1个output=想要从memory cell中被读取的值

Memory Cell

如果从表达式的角度看LSTM，它比较像下图中的样子

• $z$是想要被存到cell里的输入值(也即是上面提到的候选记忆单元C_tilda)
• $z_i$是操控input gate的信号
• $z_o$是操控output gate的信号
• $z_f$是操控forget gate的信号
• $a$是综合上述4个input得到的output值

把$z$、$z_i$、$z_o$、$z_f$通过activation function(一般是sigmoid()激活函数)，分别得到$g(z)$、$f(z_i)$、$f(z_o)$、$f(z_f)$

其中对$z_i$、$z_o$和$z_f$来说，它们通过的激活函数$f()$一般会选sigmoid function，因为它的输出在0~1之间，代表gate被打开的程度

令$g(z)$与$f(z_i)$相乘得到$g(z)\cdot f(z_i)$，然后把原先存放在cell中的$c$与$f(z_f)$相乘得到$cf(z_f)$，两者相加得到存在memory中的新值$c^{\prime }=g(z)\cdot f(z_i)+cf(z_f)$

• 若$f(z_i)=0$，则相当于没有输入，若$f(z_i)=1$，则相当于直接输入$g(z)$
• 若$f(z_f)=1$，则保存原来的值$c$并和当前输入值相加得到memory cell更新后的值，若$f(z_f)=0$，则旧的值将被遗忘清除

从中也可以看出，forget gate的逻辑与我们的直觉是相反的，控制信号打开表示记得，关闭表示遗忘

此后，$c^{\prime }$通过激活函数tanh()得到$h(c^{\prime })$，与output gate的$f(z_o)$相乘，得到输出$a=h(c^{\prime })f(z_o)$

LSTM Example

下图演示了一个LSTM的基本过程，$x_1$、$x_2$、$x_3$是输入序列，$y$是输出序列，基本原则是：

• 当$x_2=1$时，将$x_1$的值写入memory
• 当$x_2=-1$时，将memory里的值清零
• 当$x_3=1$时，将memory里的值输出
• 当neuron的输入为正时，对应gate打开，反之则关闭
  

LSTM Structure

你可能会觉得上面的结构与平常所见的神经网络不太一样，实际上我们只需要把LSTM整体看做是下面的一个neuron即可

假设目前我们的hidden layer只有两个neuron，则结构如下图所示：

• 输入$x_1$、$x_2$会分别乘上四组不同的weight，作为neuron的输入以及三个状态门的控制信号
• 在原来的neuron里，1个input对应1个output，而在LSTM里，4个input才产生1个output，并且所有的input都是不相同的
• 从中也可以看出LSTM所需要的参数量是一般NN的4倍
  

LSTM for RNN

从上图中你可能看不出LSTM与RNN有什么关系，接下来我们用另外的图来表示它

假设我们现在有一整排的LSTM作为neuron，每个LSTM的cell里都存了一个scalar值，把所有的scalar连接起来就组成了一个vector $c^{t-1}$

在时间点$t$，输入了一个vector $x^t$，它会乘上一个matrix，通过转换得到$z$，而$z$的每个dimension就代表了操控每个LSTM的输入值，同理经过不同的转换得到$z^i$、$z^f$和$z^o$，得到操控每个LSTM的门信号

下图是单个LSTM的运算情景，其中LSTM的4个input分别是$z$、$z^i$、$z^f$和$z^o$的其中1维，每个LSTM的cell所得到的input都是各不相同的，但它们却是可以一起共同运算的，整个运算流程如下图左侧所示：

$f(z^f)$与上一个时间点的cell值$c^{t-1}$相乘，并加到经过input gate的输入$g(z)\cdot f(z^i)$上，得到这个时刻cell中的值$c^t$，最终再乘上output gate的信号$f(z^o)$，得到输出$y^t$

上述的过程反复进行下去，就得到下图中各个时间点上，LSTM值的变化情况，其中与上面的描述略有不同的是，这里还需要把hidden layer的最终输出$y^t$(以及当前cell的值$c^t$)都连接到下一个时间点的输入上

因此在下一个时间点操控这些gate值，不只是看输入的$x^{t+1}$，还要看前一个时间点的输出$h^t$和cell值$c^t$，你需要把$x^{t+1}$、$h^t$这2个vector并在一起，乘上4个不同的转换矩阵，去得到LSTM的4个输入值$z$(也即是上面李沐说的C_tilda)、$z^i$、$z^f$、$z^o$，再去对LSTM进行操控，$c^t$用于计算下一时刻memory cell 里面的值$c^{t+1}$

注意：下图是同一个LSTM在两个相邻时间点上的情况

上图是单个LSTM作为neuron的情况，事实上LSTM基本上都会叠多层，如下图所示，左边两个LSTM代表了两层叠加，右边两个则是它们在下一个时间点的状态

六 链接

循环神经网络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长短期记忆网络以及代码实现
深度循环神经网络第九篇：李沐动手学深度学习V2-深度循环神经网络和代码实现
双向循环神经网络第十篇：李沐动手学深度学习V2-双向循环神经网络Bidirectional RNN和代码实现