lstm学习笔记

从 RNN到LSTM，重点介绍LSTM 的网络结构和LSTM是如何缓解RNN 中出现的梯度消失。

循环神经网络(RNN)

一个RNN可以看作是同一个网络的多份副本，每一份都将信息传递到下一个副本。如果我们将环展开的话：

这种链式结构展示了RNN与序列和列表的密切关系。RNN的这种结构能够非常自然地使用这类数据。

RNN 的主要应用如下：

文本相关。主要应用在自然语言处理方面（NLP）、对话系统、情感分析、机器翻译
时序相关。就是在做时序预测问题，比如预测天气、温度，包括有很多人使用其在做预测股票价格的问题

长期依赖(Long Term Dependencies)的问题

对于RNN 来说，可以处理非常短的文本序列（比如下文第一种情况）但是不可以处理比较长的序列（比如下文第二种情况）

有时候，我们只需要看最近的信息，就可以完成当前的任务。比如，考虑一个语言模型，通过前面的单词来预测接下来的单词。如果我们想预测句子“the clouds are in the sky”中的最后一个单词，我们不需要更多的上下文信息——很明显下一个单词应该是sky。 RNN 是可以被用来进行这样问题的训练学习。

然而，有时候我们需要更多的上下文信息。比如，我们想预测句子“I grew up in France… I speak fluent French”中的最后一个单词。不幸的是，随着距离的增大，RNN对于如何将这样的信息连接起来无能为力。

LSTM缓解梯度消失

（1） RNN 中为什么会出现梯度消失

RNN 中的传播公式 $\begin{array}{l} s_{t} = ϕ (U x_{t} + W s_{t - 1}) \\ o_{t} = f (V s_{t}) \end{array}$

其中 $s_{t}$ 表示隐藏层的状态值， $W$ 表示 $s$ 的权重矩阵， $U$ 表示 $x$ 的权重矩阵。第一个公式是隐藏层的计算公式，第二层是输出层的计算。

假设时间序列 $t = 3$ ，那么可得到： $t = 1$ 的时候的状态和输出， $\begin{array}{l} s_{1} = ϕ (U x_{1} + W s_{0}) \\ o_{1} = f (V ϕ (V x_{1} + W s_{0}) \end{array}$

当 $t = 2$ 的状态和输出：
$\begin{array}{l} s_{2} = ϕ (U x_{2} + W s_{1}) \\ o_{2} = f (V ϕ (V x_{2} + W s_{1})) = f (V ϕ (V x_{2} + W ϕ (U x_{1} + W s_{0}))) \end{array}$

当 $t = 3$ 的状态和输出： $\begin{array}{l} s_{3} = ϕ (U x_{3} + W s_{2}) \\ o_{3} = f (V ϕ (U x_{3} + W s_{2})) = \dots = f (V ϕ (U x_{3} + W ϕ (U x_{2} + W ϕ (U x_{1} + W s_{0})))) \end{array}$

所以对于RNN 而言，所谓的无法解决长依赖是因为 $s_{0}$ ， $x_{1}$ 经过了太多的激活层和权重相乘。而常见的激活函数sigmoid 或者tanh其最大值是1，不可能是一直是1，那么很容易等于0。如 ${0.8}^{50} = 0.00001427247$ 。这就是RNN 中出现梯度消失的原因。

使用Relu 是可以解决梯度消失，因为 $x > 0$ 情况下梯度恒为0。但是容易发生梯度爆炸（虽然可以通过设置适当的阈值）。

如果说通过修改网络结构来解决梯度消失或者梯度爆炸，那么就是LSTM 了。

（2）LSTM 是如何缓解梯度消失的？

$h_{t} = o_{t} ⊙ ϕ (f_{t} ⊙ c_{t - 1} + i_{t} ⊙ ϕ (W_{x c} x_{t} + W_{h c} h_{t - 1} + b_{c}))$

在隐藏层中 LSTM 相对于普通的RNN 有了很多加和，从而保证了在 $c$ (context) 这个路径上是有梯度的。但是其他路径上梯度流与普通 RNN 类似，照样会发生相同的权重矩阵反复连乘。梯度爆炸相对于梯度消失是更容易解决的。

参考文献 Understanding LSTM Networks

LSTM

LSTM 是用来解决RNN 中的梯度消失/ 梯度爆炸问题的，可以处理 long-term sequence了。

门（gate ）定义： gate 实际上就是一层全连接层，输入是一个向量，输出是一个 0到1 之间的实数向量。公式如下： $g (x) = σ (W x + b)$

遗忘门（forget gate）它决定了上一时刻的单元状态 $c_{t - 1}$ 有多少保留到当前时刻 $c_{t}$ 输入门（input gate）它决定了当前时刻网络的输入 $x_{t}$ 有多少保存到单元状态 $c_{t}$ 输出门（output gate）控制单元状态 $c_{t}$ 有多少输出到 LSTM 的当前输出值 $h_{t}$

（1）LSTM网络

在普通的RNN中，重复模块结构非常简单，例如只有一个tanh层。

LSTM也有这种链状结构，不过其重复模块的结构不同。LSTM的重复模块中有4个神经网络层，并且他们之间的交互非常特别。

（2）LSTM分步详解

LSTM的第一步是决定我们将要从元胞状态中扔掉哪些信息。遗忘门观察 $h_{t - 1}$ 和 $x_{t}$ ，对于元胞状态 $C_{t - 1}$ 中的每一个元素，输出一个0-1之间的数。1表示“完全保留该信息”，0表示“完全丢弃该信息”。

下一步是决定我们将会把哪些新信息存储到元胞状态中。这步分为两部分。首先，有一个叫做“输入门(Input Gate)”的Sigmoid层决定我们要更新哪些信息。接下来，一个tanh层创造了一个新的候选值， ${\tilde{C}}_{t}$ ，该值可能被加入到元胞状态中。在下一步中，我们将会把这两个值组合起来用于更新元胞状态。

现在我们该更新旧元胞状态 $C_{t - 1}$ 到新状态 $C_{t}$ 了。上面的步骤中已经决定了该怎么做，这一步我们只需要实际执行即可。

最后，我们需要决定最终的输出。输出将会基于目前的元胞状态，并且会加入一些过滤。首先我们建立一个Sigmoid层的输出门(Output Gate)，来决定我们将输出元胞的哪些部分。然后我们将元胞状态通过tanh之后（使得输出值在-1到1之间），与输出门相乘，这样我们只会输出我们想输出的部分。

优点：解决了RNN 中的梯度消失的问题，可以处理长依赖

缺点：计算复杂度高，运行时间长

（3）LSTM中参数的计算

首先参数的个数和时间steps 无关
$h_{t}$ 和 $c_{t}$ 的维度是相同的
总共四组 [w, b] 参数

直接给出公式 $4 (n (m + n) + n)$ 其中 $m$ 表示输入 $x$ 的维度， $n$ 表示 hidden 或者说 context 的维度。 $(m + n)$ 表示在处理下一层的输入时候，把当前层数据 $x$ 的维度 $m$ 和 hidden 中维度 $n$ 给链接起来，具体可以看一下 lstm 中的示意图。

LSTM参数计算的例子

根据代码可以加深一下理解

 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


import torch.nn as nn
import torch
from torch.autograd import Variable

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, cell_size, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.cell_size = cell_size
        self.gate = nn.Linear(input_size + hidden_size, cell_size)
        self.output = nn.Linear(hidden_size, output_size)
        self.sigmoid = nn.Sigmoid()
        self.tanh = nn.Tanh()
        self.softmax = nn.LogSoftmax()

    def forward(self, input, hidden, cell):
        combined = torch.cat((input, hidden), 1)
        f_gate = self.gate(combined)
        i_gate = self.gate(combined)
        o_gate = self.gate(combined)
        f_gate = self.sigmoid(f_gate)
        i_gate = self.sigmoid(i_gate)
        o_gate = self.sigmoid(o_gate)
        cell_helper = self.gate(combined)
        cell_helper = self.tanh(cell_helper)
        cell = torch.add(torch.mul(cell, f_gate), torch.mul(cell_helper, i_gate))
        hidden = torch.mul(self.tanh(cell), o_gate)
        output = self.output(hidden)
        output = self.softmax(output)
        return output, hidden, cell

    def initHidden(self):
        return Variable(torch.zeros(1, self.hidden_size))

    def initCell(self):
        return Variable(torch.zeros(1, self.cell_size))

这个对于 pytorch 中 lstm 的实现讲解的比较好：LSTM:Pytorch实现，可以作为参考。

GRU

GRU (gated recurrent unit) 是对于 LSTM 速度上的提升，但是相应的表达能力也受到了限制

GRU 中一共有两个门。GRU 把LSTM 中遗忘门(forget gate) 和输入门(input gate) 使用更新门(update gate) 进行代替。还有一个重置门(reset gate)，重置门主要决定了多少过去的信息需要遗忘。GRU 不会保存内部记忆 context，而且没有输出门。

文章目录

循环神经网络(RNN)

LSTM

GRU