1、 长短期记忆

LSTM 中引入了3个门，即输入门（input gate）、遗忘门（forget gate）和输出门（output gate），以及与隐藏状态形状相同的记忆细胞（某些文献把记忆细胞当成一种特殊的隐藏状态），从而记录额外的信息。

1.1 输入门、遗忘门和输出门

$$I_t=sigmoid(X_t{W}_{xi}+H_{t-1}Whi+b_i)$$
$$F_t=sigmoid(X_t{W}_{xf}+H_{t-1}Whf+b_f)$$
$$O_t=sigmoid(X_t{W}_{xo}+H_{t-1}Who+b_o)$$

1.2 候选记忆细胞

接下来，长短期记忆需要计算候选记忆细胞$\widehat{C_t}$ 。它的计算与上面介绍的3个门类似，但使用了值域在 [−1,1]的tanh函数作为激活函数

$$\widehat{C_t}=tanh(X_t{W}_{xc}+H_{t-1}{W}_{hc}+b_c)$$

1.3 记忆细胞

$$C_t=F_t\ast C_{t-1}+I_t\ast \widehat{C_t}$$

1.4 隐藏状态

$$H_t=O_t\ast tanh(C_t)$$

2、代码定义模型

• 初始化参数

num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
print('will use', device)

def get_params():
    def _one(shape):
        ts = torch.tensor(np.random.normal(0, 0.01, size=shape), device=device, dtype=torch.float32)
        return torch.nn.Parameter(ts, requires_grad=True)
    def _three():
        return (_one((num_inputs, num_hiddens)),
                _one((num_hiddens, num_hiddens)),
                torch.nn.Parameter(torch.zeros(num_hiddens, device=device, dtype=torch.float32), requires_grad=True))
    
    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 = _one((num_hiddens, num_outputs))
    b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device, dtype=torch.float32), requires_grad=True)
    return nn.ParameterList([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])


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

• 模型定义

def lstm(inputs, state, 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] = params
    (H, C) = state
    outputs = []
    for X in inputs:
        I = torch.sigmoid(torch.matmul(X, W_xi) + torch.matmul(H, W_hi) + b_i)
        F = torch.sigmoid(torch.matmul(X, W_xf) + torch.matmul(H, W_hf) + b_f)
        O = torch.sigmoid(torch.matmul(X, W_xo) + torch.matmul(H, W_ho) + b_o)
        C_tilda = torch.tanh(torch.matmul(X, W_xc) + torch.matmul(H, W_hc) + b_c)
        C = F * C + I * C_tilda
        H = O * C.tanh()
        Y = torch.matmul(H, W_hq) + b_q
        outputs.append(Y)
    return outputs, (H, C)

一、长短期记忆网络（LSTM）

  最早用来处理隐变量模型存在的长期信息保存和短期输入跳跃问题的方法（long short-term memory LSTM）。其拥有许多门控循环单元相同的属性。LSTM比GRU更复杂，但是其比GRU早诞生20年左右。

1.1 门控记忆单元

  LSTM引入了存储单元（memory cell），简称为单元（cell）。有些文献认为存储单元是隐藏状态的一种特殊类型，它们与隐藏状态具有相同的形状，其设计目的是用于记录附加的信息。为了控制存储单元，我们需要许多门。其中一个门用来从单元中读出条目。我们将其称为 输出门（output gate）。另外一个门用来决定何时将数据读入单元。我们将其称为 输入门（input gate）。最后，我们需要一种机制来重置单元的内容，由遗忘门（forget gate）来管理。这种设计的动机与门控循环单元相同，即能够通过专用机制决定什么时候记忆或忽略隐藏状态中的输入。让我们看看这在实践中是如何运作的。

• 遗忘门：将值朝0方向减少
• 输入门：决定是否忽略输入数据
• 输出门：决定是不是使用隐藏状态

1.2 输入门、遗忘门与输出门

  就如在门控循环单元中一样，当前时间步的输入和前一个时间步的隐藏状态作为数据送入长短期记忆网络门中，如下图所示。它们由三个具有 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}$ 是偏置参数。

1.3候选记忆单元

  接下来，设计记忆单元。由于还没有指定各种门的操作，所以先介绍 候选记忆单元（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}$ 是偏置参数。

候选记忆单元的图示如下

1.4 记忆单元

  在门控循环单元中，有一种机制来控制输入和遗忘（或跳过）。类似地，在长短期记忆网络中，也有两个门用于这样的目的：输入门 ${\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}$ 将随时间被保存并传递到当前时间步。引入这种设计是为了缓解梯度消失问题，并更好地捕获序列中的长距离依赖关系。

这样就得到了流程图，如下。

1.5 隐藏状态

  最后，我们需要定义如何计算隐藏状态 ${\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

import torch
from torch import nn
from d2l import torch as d2l
# load data iter
batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

2.1 初始化模型参数

# 随便初始化，这里采用标准差为0.01的高斯分布初始化，偏置使用0
def get_lstm_params(vocab_size,num_hiddens,device):
    num_inputs = num_outputs = vocab_size
    
    def normal(shape):
        return torch.randn(size=shape,device=device)*0.01
    def three():
        return(normal((num_inputs,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((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    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

2.2 定义网络模型

在初始化函数之中，LSTM的隐藏状态需要返回一个额外的记忆单元，其单元的值为0，形状为（批量大小，隐藏单元数）。

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

# 实际模型的定义与前面定义相同，提供三个门和一个额外的记忆单元。只有隐藏状态才会传递到输出层，而记忆单元不直接参与输出计算
def lstm(inputs,state,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] = params
    (H,C) = state
    outputs = []
    for X in inputs:
        I = torch.sigmoid((X@W_xi)+(H@W_hi)+b_i)
        F = torch.sigmoid((X @ W_xf) + (H @ W_hf) + b_f)
        O = torch.sigmoid((X @ W_xo) + (H @ W_ho) + b_o)
        C_tilda = torch.tanh((X @ W_xc) + (H @ W_hc) + b_c)
        C = F * C + I * C_tilda
        H = O * torch.tanh(C)
        Y = (H @ W_hq) + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H, C)

2.3 训练和预测

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

perplexity 1.1, 49112.9 tokens/sec on cuda:0
time traveller for so it will be convenient to speak of himwas e
traveller abcerthen thing the time traveller held in his ha

2.4 简洁实现

num_inputs = vocab_size
lstm_layer = nn.LSTM(num_inputs, num_hiddens)
model = d2l.RNNModel(lstm_layer, len(vocab))
model = model.to(device)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

perplexity 1.1, 281347.3 tokens/sec on cuda:0
time traveller for so it will be convenient to speak of himwas e
travelleryou can show black is white by argument said filby

  长短期记忆网络是典型的具有重要状态控制的隐变量自回归模型。多年来已经提出了其许多变体，例如，多层、残差连接、不同类型的正则化。然而，由于序列的长距离依赖性，训练长短期记忆网络和其他序列模型(例如门控循环单元)的成本是相当高的。在后面的内容中，我们将遇到可在某些情况下使用的替代模型，如 Transformer。

小结

• 长短期记忆网络有三种类型的门：输入门、遗忘门和控制信息流的输出门。
• 长短期记忆网络的隐藏层输出包括“隐藏状态”和“记忆单元”。只有隐藏状态会传递到输出层，而记忆单元完全属于内部信息。
• 长短期记忆网络可以缓解梯度消失和梯度爆炸。

练习

1. 你需要如何更改模型以生成适当的单词，而不是字符序列

在输入的时候，我们需要将一个个单词当成vocab进行编码，但是这样的话，onehot编码的大小可能需要变得非常大了。进行数据整理，给每个单词一个对应的编号，对这个编号进行onehot编码也可以。

2. 在给定隐藏层维度的情况下，比较门控循环单元、长短期记忆网络和常规循环神经网络的计算成本。要特别注意训练和推理成本。
3. 既然候选记忆单元通过使用 $\tanh$ 函数来确保值范围在 $(-1,1)$ 之间，那么为什么隐藏状态需要再次使用 $\tanh$ 函数来确保输出值范围在 $(-1,1)$ 之间呢？

$$\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}$$ $${\tilde{\mathbf{C}}}_t=\text{tanh}({\mathbf{X}}_t{\mathbf{W}}_{xc}+{\mathbf{H}}_{t-1}{\mathbf{W}}_{hc}+{\mathbf{b}}_c),$$ $${\mathbf{C}}_t={\mathbf{F}}_t\odot {\mathbf{C}}_{t-1}+{\mathbf{I}}_t\odot {\tilde{\mathbf{C}}}_t.$$$${\mathbf{H}}_t={\mathbf{O}}_t\odot \tanh ({\mathbf{C}}_t).$$

一、引言

1.1 什么是LSTM

首先看看百科的解释。
长短期记忆（英语：Long Short-Term Memory，LSTM）是一种时间循环神经网络（RNN)，论文首次发表于1997年。由于独特的设计结构，LSTM适合于处理和预测时间序列中间隔和延迟非常长的重要事件。¹

为了更好地理解长短期记忆网络 - LSTM(下文简称LSTM)，可以先了解循环神经网络-RNN(下文简称RNN)的相关知识，这里有一些相关的文章。LSTM只是RNN的一个变种，LSTM是为了解决RNN中的梯度消失的问题而提出的。

二、循环神经网络RNN

2.1 为什么需要RNN

人的思想是有记忆延续性。比如当你在阅读这篇文章，你会根据你曾经对每个字的理解来理解这篇文章的字，而不是每次都要思考一个字在这篇文章的语境下到底如何理解（从一个字或词的多种解释来选择一个符合当下语境的解释）。

举个例子：要识别这么一个句子:
The cat, which already ate cakes, () full.²

假设对其中的单词从左到右一个一个地处理，前面已经cat的识别结果是一个单数名词，到后边()里的内容，到底是填were 还是 was，那么就需要根据前边cat的识别结果进行判断。这就是RNN需要做的。

使用神经网络来预测句子中下一个字的解释。传统的神经网络在模型训练好了以后，在输入层给定一个x，通过网络之后就能在输出层得到特定的y。利用这个模型可以通过训练拟合任意函数，但是只能单独的取处理一个个的输入，前一个输出和后一个输出是完全没有关系的。

神经网络的结构如下：

但是，在理解一句话的意思的时候，一个字的意思是跟前面的字相关联的，即前面的输出和后面的输出是有关系的。所以仅仅利用这样的模型是不够的的，为了解决这个问题，有人提出了RNN。
RNN模型构造：

RNN神经网络示意图：

蓝色部分的是隐藏层，RNN利用隐藏层将信息向后传递。
我们来看看RNN隐藏层里发生了什么,将上图按时间线展开³：

再给出一个更具体的图，给出各层元素的对应关系

现在看上去就比较清楚了，这个网络在 t 时刻接收到输入 $x_t$ 之后，隐藏层的值是 $s_t$ ，输出值是 $o_t$ 。关键一点是，$s_t$ 的值不仅仅取决于 $x_t$ ，还取决于 $s_{t-1}$ 。 我们可以用下面的公式来表示RNN的计算方法：
用公式表示如下：
$$O_t=g(V\cdot S_t)$$

$$S_t=f(U\cdot X_t+W\cdot S_{t-1}）$$
注意：为了简单说明问题，偏置都没有包含在公式里面。

这样，就可以做到的在一个序列中根据前面的输出来影响后面的输出。

三、长短时记忆神经网络LSTM

3.1 为什么需要LSTM

回到我们的例子：
The cat, which already ate …, () full.

这个例子与之前的例子稍微有一些不同，这里的cat 和()之间已经相隔了较长的一段距离，这时候用RNN来处理这样的长期信息就不太合适。

因为RNN在反向传播阶段有梯度消失等问题不能处理长依赖问题，这里的梯度消失是由于RNN在计算过程中使用链式法则。

具体来说，RNN使用覆盖的方式来计算状态：$S_t=f(S_{t-1},x_t)$,这类似于复合函数，根据链式求导的法则，复合函数求导：设$f$ 和 $g$ 为 $x$ 的可导函数，则$(f\circ g{)}^{\prime }(x)=f^{\prime }(g(x))g^{\prime }(x)$,这是一种连乘的方式，如果导数小于或大于1，会发生梯度下降以及梯度爆炸。梯度爆炸可以通过剪枝算法解决，但是梯度消失却没办法解决。

梯度消失可能不太好理解，可以简单理解为RNN中后边输入的数据影响越大，前面的数据的影响小，因此不能处理长期信息。后来，有学者在一篇论文Long Short-Term Memory ⁴ 提出了LSTM，LSTM通过选择性地保留信息，有效地缓解了梯度消失以及梯度下降的问题，可以说LSTM正是为了适合学习长期依赖而产生的。

3.2 LSTM结构分析

回顾一下RNN的模型构造：

可以看到，RNN循环网络模型的链式结构非常简单，通常仅含有一个tanh层。

LSTM模型构造：

而LSTM的链式结构中，循环单元结构不同，里边有四个神经网络层。

先来解释一下图中符号含义：

LSTM结构（图右）和普通RNN的主要输入输出区别如下所示：

相比RNN只有一个传递状态 $h^t$ , LSTM有两个传输状态,一个 $c^t$ （cell state）， 和一个 $h^t$ (hidden state)。（RNN中的 $h^t$ 对应LSTM中的 $C^t$）

3.3 LSTM背后的核心思想

LSTM的核心思想，LSTM的关键是细胞状态(cell state)，即下图中上边的水平线。cell state像是一条传送带，它贯穿整条链，其中只发生一些小的线性作用。信息流过这条线而不改变是非常容易的。⁵ 改变cell state需要三个门的相互配合。

如下图所示：

LSTM删除或添加信息到cell state，是由被称为门的结构控制的。LSTM中有三个门，“遗忘门” “输入门” 以及“输出门”，用来保护和更新cell的状态。
门是筛选信息的方法，由一个sigmoid网络层和一个点乘操作组成。
如下图：

sigmoid层作为激活函数，将输出控制在(0,1)区间内，Sigmoid的函数图形如下：

可以看到，绝大多数的值都是接近0或者接近1的。利用这一个性质，0 表示不允许任何通过，1 表示允许一切通过。

3.4 LSTM的运行机制

第一步，需要决定从cell state中丢弃什么样的信息，这个由“遗忘门”的sigmoid层决定。根据输入$h_{t-1}$ 和 $x_t$，得到的输出是0和1之间的数。0 代表“完全保留这个值”，1代表“完全丢弃这个值”。

回到开始的例子，原来的主语是"cat"，之后遇到了一个新的主语"cats"。这时需要把之前的"cat"给忘掉，以便确定接下来是要使用"were"，而不是"was"。如下图：

第二步，需要决定在cell state里存储什么样的信息。这一步划分为两个部分，一是称为“输入门”的sigmoid层决定哪些数据需要更新。然后，tanh层创建一个新的候选值向量${\tilde{C}}_t$,这些值能加入state中。第二部分，需要将这两个部分合并以实现对state的更新。

在例子中，这里对应于把新的"cats"加入到"cell state"中，以替代需要遗忘的"cat"。如下图：

在决定好需要遗忘的以及需要加入的记忆之后，就可以把旧的cell state $C_{t-1}$更新到新的cell state $C_t$。 这一步中，把旧的state $C_{t-1}$ 与$f_t$ 相乘，遗忘先前决定遗忘的东西，之后加上新的记忆信息 $i_t\ast {\tilde{C}}_t$。这里为了体现对状态值的更新度是有限制的，可以把$i_t$当成一个权重。如下图：

最后，需要决定输出。这个输出将会基于cell state ，这是一个过滤后的值。首先，使用“输出门”的sigmoid层决定输出cell state的哪些部分的。然后，将cell state放入tanh（将数值限制在-1到1），最后将结果与sigmoid门的输出相乘，这样就可以只输出需要的部分。如下图：

3.5 LSTM如何避免梯度下降

上边提到了RNN中的梯度下降以及梯度爆炸问题，是是因为在计算过程中使用链式法则，使用了乘积。而在LSTM中，状态是通过累加的方式来计算，$S_t={\sum }_{\tau =1}^t\Delta S_{\tau }$。这样的计算，就不是复合函数的形式，它的导数也就不是乘积的形式，就不会发生梯度消失的情况。

四、入门例子

下面给出LSTM的一个入门实例-根据前9年的数据预测后3年的客流⁶,感谢原作者的代码，完整的代码见GithubYonv1943。这里简单说一下这个代码实例的结果，需要了解更加详细的代码细节可以看看原作者的原文详解。

考虑有一组某机场1949年~1960年12年共144个月的客流量数据。使用这个数据中的前9年的客流量来预测后3年的客流量，再和实际的数据进行比对，可以看出LSTM的对这类具有时序关系的拟合效果。

结果图：

• 数据：机场1949~1960年12年共144个月的客流量数据。数据具有三个维度[客运量，年份，月份]。其中前75%（前9年）的数据作为训练集，后25%(后3年)的数据作为测试集。
• 纵坐标：标准化处理：变量值与平均数的差除以标准差，给出数值的相对位置。横坐标为月数。
• 图解释：竖直黑线左边是训练集(前9年)。右边(后3年)红色的是预测数值，蓝色的是实际数值。

可以看到在这个LSTM对这个数据集的拟合效果是比较好的，在这样的实际场景中，可以利用LSTM这样的工具来对客流量做一个预测，以便对客运高峰等情况做好预备方案。

五、总结

• RNN的计算中存在多个偏导数连乘，导致梯度消失或梯度爆炸，难以处理长依赖的信息。
• LSTM通过三个选择性地保留信息，可以选择最近的信息或者很久之前的信息。
• LSTM更新cell state是采用了线性求和的计算，因此不会出现梯度消失问题，可以处理长期依赖的信息。

六、参考资料