神经网络基础（六）——LSTM与GRU

1. 引言

在神经网络基础——循环神经网络中提到，循环神经网络很难处理长距离的依赖。于是提出了一种改进的循环神经网络，长短时记忆网络(Long Short Term Memory Network, LSTM)，它成功的解决了原始循环神经网络的缺陷，成为当前最流行的RNN，在语音识别、图片描述、自然语言处理等许多领域中成功应用。

---

2. LSTM的基本概念

2.1 实现思路

与RNN相同，在$t$时刻，LSTM的输入有三个：当前时刻网络的输入值${\mathbf{x}}_{\mathbf{t}}$、上一时刻LSTM的输出值${\mathbf{h}}_{\mathbf{t}-1}$、以及上一时刻的单元状态${\mathbf{c}}_{\mathbf{t}-1}$；LSTM的输出有两个：当前时刻LSTM输出值${\mathbf{h}}_{\mathbf{t}}$、和当前时刻的单元状态${\mathbf{c}}_{\mathbf{t}}$。注意${\mathbf{x}}_{\mathbf{t}}$、${\mathbf{h}}_{\mathbf{t}}$、${\mathbf{c}}_{\mathbf{t}}$都是向量。

在原始的RNN神经网络中，隐藏节点中有一个功能称为记忆单元 $c$ ，其作用为：记录前一个时刻的信息，所以对于短期的输入非常敏感，而在LSTM模型中，增加了三个门，每个门都有自己的任务：

• 输入门 (input gate)：负责控制把即时状态输入到长期状态
• 输出门 (output gate)：负责控制是否把长期状态作为当前的LSTM的输出。
• 遗忘门 (forget gate)：负责控制继续保存长期状态。

由于这三个门的存在，使得模型对于记忆单元存储的内容以及输出的内容更加丰富。

当下图中所有的开关都处于闭合状态时，LSTM模型等同于普通的RNN模型，由此也可以看出，LSTM模型相对于RNN最大的区别在于，增加了三个开关。

---

2.2 三个门的工作流程

假设一个LSTM隐藏节点中的单元结构示意图如下：

上图中，

• $z$为该隐藏单元的输入，$a$为该隐藏单元的输出，即隐藏状态的值$h^t$；
• ${\int }_f$，${\int }_g$，${\int }_h$代表三种不同的激活函数，通常情况下，${\int }_f$一般使用 sigmoid 激活函数，sigmoid 函数的输出在(0,1)之间的值，代表了门的打开程度，如果sigmoid函数的值为 1，则说明门是处于打开状态，若为0，则说明门处于关闭状态。
• $Z_i$，$Z_f$，$Z_o$，分别代表输入信号，遗忘信号，输出信号，决定对应三个门的状态是开放还是闭合；
• $W_{zc}$，$W_{ic}$，$W_{fc}$，$W_{oc}$，分别代表输入数据对应的权重，输入信号的权重，遗忘信号的权重，输出信号的权重，决定对应三个门的状态是开放还是闭合;
• $b_x$，$b_i$，$b_f$，$b_o$，分别代表输入数据对应的bias，输入信号的bias，遗忘信号的bias，输出信号的bias。

2.2.1 计算流程

2.2.1.1 单个神经元的工作流程

• 输入数据与输入门控信号的计算
  • 输入数据 $Z$ 与输入权重$W_{zc}$相乘得到$Z$经过激活函数 ${\int }_g$ 得到 $g(Z)$；
  • 输入数据 $Z$与输入门权重$W_{ic}$相乘得到$Z_i$经过激活函数 ${\int }_f$ 得到 $f(Z_i)$；
  • 将 $g(Z)$与$f(Z_i)$按元素相乘得到$g(Z)f(Z_i)$；

输入门公式：
$$\mathbf{f}(Z_i)=sigmoid(W_{ic}\cdot [\mathbf{Z}]+{\mathbf{b}}_i)$$

$f(Z_i)$其实起到了一个控制输入的作用，如果$f(Z_i)$为0，则$g(Z)f(Z_i)$为0，说明没有任何的输入。

• 记忆单元和遗忘门控制信号的计算
  • 输入数据 $Z$与输入门权重$W_{fc}$相乘得到$Z_f$经过激活函数 ${\int }_f$ 得到 $f(Z_f)$；
  • 将记忆单元中的原始值记为$c$，令其与$f(Z_f)$按元素相乘，得到$cf(Z_f)$；
  • 令$g(Z)f(Z_i)$与$cf(Z_f)$的和为$c^{\prime }$，记忆单元中的新的值，即：
    $c^{\prime }=cf(Z_f)+g(Z)f(Z_i)$。

遗忘门公式：
$$\mathbf{f}(Z_f)=sigmoid(W_{fc}\cdot [\mathbf{Z}]+{\mathbf{b}}_f)$$

由此可见，$f(Z_f)$决定了要不要把保留原先记忆单元中的数据，如果$f(Z_f)$为1，说明遗忘门打开，则$c^{\prime }$的内容为当前输入与原来记忆单元的和，否则，记忆单元的值更新为当前输入。

• 输出数据与输出门信号的控制
  • 输入数据 $Z$与输入门权重$W_{oc}$相乘得到$Z_f$经过激活函数 ${\int }_f$ 得到 $f(Z_o)$；
  • 将$c^{\prime }$通过激活函数${\int }_h$得到 $h(c^{\prime })$，再将 $h(c^{\prime })$与$f(Z_o)$按元素相乘得到隐含状态的值$a$，也就是$h^t$。 $h_t=f(Z_o{)}_t\circ \tanh (c^{\prime })$

输出门公式：
$$\mathbf{f}(Z_o)=\sigma (W_{oc}\cdot [\mathbf{Z}]+{\mathbf{b}}_o)$$

如果$f(Z_o)=0$，说明神经元的值无法输出，否则则输出值为$a$。

总结一下规律：更新后记忆单元中的值$c^t$其实是一个变换比较慢的数据，而$h^t$则是一个变化较快的值。

2.2.1.2 输入变量是个啥？

首先明确一点，输入变量$Z$的值可以为一个向量，也可以为一个矩阵。

在2.2.1.1节中，我们并没有使用$X$作为输入变量的符号，而是使用了$Z$，下面来介绍一下，古圣先贤们是怎么样把X变成Z的。
首先给出公式
$$Z=tanh(W_{zc}\times Z^{\prime })$$
$Z^{\prime }$是一个分块矩阵，可能有以下几种情况：

1. 极简版——单层LSTM的工作流程

如下图所示，$t$时刻隐藏状态得到的结果，作为$t+1$时刻的记忆单元的值，参与$t+1$时刻的运算。
此时：

• $Z^{\prime }$就是$X$的shape:$(V_{Batch\_size}\times V_X)$。
• $W_{zc}$，$W_{ic}$，$W_{fc}$的shape就是$X$的shape:$(V_X\times V_C)$。$V_C$是LSTM神经元的数量。
• $W_{oc}$的shae为：$(V_C\times V_Y)$

2.2.1.3 标准版——单层LSTM的工作流程

除了在极简版中把$t$时刻隐藏状态得到的结果，作为$t+1$时刻的记忆单元的值，参与$t+1$时刻的运算之外，还把$t$时刻的输出、$t+1$时刻的特征值进行矩阵的拼接，然后一同作为输入。

此时：

• $Z^{\prime }$就是$[X,h]$，也就是输入矩阵$X$的shape：$(V_{Batch\_size}\times V_X)$，输出矩阵$Y$的shape:$(V_{Batch\_size}\times V_Y)$，最后拼成了一个$(V_{Batch\_size}\times (V_X+V_Y))$。
• $W_{zc}$，$W_{ic}$，$W_{fc}$的shape就是$X$的shape:$(V_X\times V_C)$。$V_C$是LSTM神经元的数量。
• $W_{oc}$的shae为：$(V_C\times V_Y)$

2.2.1.4 常用版——单层LSTM的工作流程

除了在极简版中把$t$时刻隐藏状态得到的结果，作为$t+1$时刻的记忆单元的值，参与$t+1$时刻的运算之外，还把$t$时刻的输出、$t$时刻隐藏状态的值、$t+1$时刻的特征值进行矩阵的拼接，然后一同作为输入。

• $Z^{\prime }$就是$[X,h,c]$，也就是输入矩阵$X$的shape：$(V_{Batch\_size}\times V_X)$，输出矩阵$Y$的shape:$(V_{Batch\_size}\times V_Y)$，记忆单元输出$C$的shape:$(V_{Batch\_size}\times V_Y)$，最后拼成了一个$(V_{Batch\_size}\times (V_X+V_Y+V_Y))$。
• $W_{zc}$，$W_{ic}$，$W_{fc}$的shape就是$X$的shape:$((V_X+V_Y+V_Y)\times V_C)$。$V_C$是LSTM神经元的数量。
• $W_{oc}$的shae为：$(V_C\times V_Y)$

Note：在拼接$t$时刻隐藏状态的值的时候，要求其所对应的权重是diagonal的，也就是W中的对应的分块矩阵部分。

2.2.1.5 常用版——多层LSTM的工作流程

2.2.2 输入维度与隐藏循环神经元数目的关系

因此，在只有两个时刻的输入变量以及两个循环神经元的情况下，LSTM的总架构如下：

Z的每一个维度都代表了操控LSTM的Memory cell。所以，Z的dimension都代表了LSTM隐藏单元的数目。

---

3. GRU

note：与LSTM不同的是，GRU神经网络只有两个门控单元，结构要比LSTM简单很多（但是理解就没那么容易了）。

3.1 基本概念

相对于LSTM神经网络：

1. 将输入门、遗忘门、输出门变为两个门：更新门（Update Gate）$Z_t$和重置门（Reset Gate）$r_t$。
2. 将单元状态与输出合并为一个状态：$h$。

GRU结构如下所示：

在上图中，各符号意义代表：

• $c^{t-1}$：$t-1$时刻隐藏状态的值。
• $h^{t-1}$：$t-1$时刻输出的值。
• $x^t$：$t$时刻输入的值。
• $y^t$：$t$时刻输出的值。
• $W_r$：重置门的权重。
• $W_z$：更新门的权重。

3.2 计算流程

• 根据$t-1$时刻的输出和$t$时刻的输入，判断重置门是否开启。

  • $t$时刻输入数据 $X^t$与$t-1$时刻输出数据$h^{t-1}$拼接成矩阵，$W_{zr}$相乘得到$Z$经过激活函数 ${\int }_r$ 得到 $r(Z)$；
    

• 你重置也好，不重置也好，反正我$t$时刻有输入，那我就算一下$t$时刻有发生了哪些改变。
  

• 根据$t-1$时刻的输出和$t$时刻的输入，判断更新门是否开启。

  • $t$时刻输入数据 $X^t$与$t-1$时刻输出数据$h^{t-1}$拼接成矩阵，$W_{zr}$相乘得到$Z$经过激活函数 ${\int }_r$ 得到 $r(Z)$；
    

• 不管怎么样，反正我在$t$时刻一定要输出，你看着办吧

  • 更新门打开：
    
  • 更新门关闭：
    

---

4. 它们的应用

4.1 Many to One

• 情感分析：输入是一个Vector Sequence，输出是一个Vector
  
• 关键词提取
  

4.2 Many to Many（Seq2Seq）

• 语音识别（Input Sequence 长， Output Sequence 短）：结合CTC（connectionlist Temporal Classification）
  

• 文本翻译
  

5. 代码实现

5.1 自实现LSTM单元版本

本文实现的仅仅是标准版本的LSTM，其他的仅仅区别于矩阵的拼接问题。

至于代码改动部分，其实相对于神经网络基础（五）——循环神经网络一节，仅仅三个函数发生了改变：
get_params, init_rnn_state, rnn

获取参数函数：

def get_params(num_inputs, num_hiddens, num_outputs):
    '''
    初始化模型参数
    :return:
    '''
    W_xi = nd.random.normal(scale=0.01, shape=(num_inputs, num_hiddens), ctx=ctx)
    W_hi = nd.random.normal(scale=0.01, shape=(num_hiddens, num_hiddens), ctx=ctx)

    W_xf = nd.random.normal(scale=0.01, shape=(num_inputs, num_hiddens), ctx=ctx)
    W_hf = nd.random.normal(scale=0.01, shape=(num_hiddens, num_hiddens), ctx=ctx)

    W_xo = nd.random.normal(scale=0.01, shape=(num_inputs, num_hiddens), ctx=ctx)
    W_ho = nd.random.normal(scale=0.01, shape=(num_hiddens, num_hiddens), ctx=ctx)

    W_xc = nd.random.normal(scale=0.01, shape=(num_inputs, num_hiddens), ctx=ctx)
    W_hc = nd.random.normal(scale=0.01, shape=(num_hiddens, num_hiddens), ctx=ctx)

    b_i = nd.zeros(num_hiddens, ctx=ctx)
    b_f = nd.zeros(num_hiddens, ctx=ctx)
    b_o = nd.zeros(num_hiddens, ctx=ctx)
    b_c = nd.zeros(num_hiddens, ctx=ctx)

    W_hq = nd.random.normal(scale=0.01, shape=(num_hiddens, num_outputs), ctx=ctx)
    b_q = nd.zeros(num_outputs, ctx=ctx)

    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.attach_grad()
    return params

初始化隐藏状态和输入函数:

def init_rnn_state(batch_size, num_hiddens):
    '''
    初始化隐藏单元的值
    :return:
    '''
    return (
        nd.zeros(shape=(batch_size, num_hiddens), ctx=ctx),
        nd.zeros(shape=(batch_size, num_hiddens), ctx=ctx),
    )

运行单次一次：

def rnn(inputs, state, params):
    '''
    运行一轮模型
    :return:
    '''
    # inputs和outputs皆为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:
        I = nd.sigmoid(nd.dot(X, W_xi) + nd.dot(H, W_hi) + b_i)
        F = nd.sigmoid(nd.dot(X, W_xf) + nd.dot(H, W_hf) + b_f)
        O = nd.sigmoid(nd.dot(X, W_xo) + nd.dot(H, W_ho) + b_o)

        C_tilda = nd.tanh(nd.dot(X, W_xc) + nd.dot(H, W_hc) + b_c)
        C = C_tilda * I + F * C
        H = O * nd.tanh(C)
        Y = nd.dot(H, W_hq) + b_q
        outputs.append(Y)
    return outputs, (H, C)

5.2 调用Pytorch库的版本

step1. 先调用库定义LSTM神经网络的基本架构：LSTM标准神经元的结构（三门）+有多少层网络。具体参数介绍：看这里。

# 声明一个每个时间点具有10个特征，隐藏层深度为1（默认参数），隐藏神经元数量为20的LSTM神经网络。
lstm_layer = nn.LSTM(input_size=10, hidden_size=20)

step2. 自定义Model

model = RNNModel(lstm_layer, input_size)

RNNModel的实现如下：

class RNNModel(nn.Module):
    def __init__(self, rnn_layer, input_size):
        # 继承Pytorch本身的RNNModel
        super(RNNModel, self).__init__()
        # run_layer 就是第一步中定义好的网络结构
        self.rnn = rnn_layer
        # 从rnn_layer中获得隐藏单元的数量
        self.hidden_size = rnn_layer.hidden_size * (2 if rnn_layer.bidirectional else 1)
        self.input_size= input_size
		# 定义输出层：线性输出，输出的维度与输入维度一样
        self.dense = nn.Linear(self.hidden_size, vocab_size)
		# 假设LSTM的初始单元状态为None
        self.state = None

    def forward(self, inputs, state): # inputs: (batch, seq_len)
        # 获取one-hot向量表示，先看step 3
        X = to_onehot(inputs, self.vocab_size) # X是个list
        # 接下来就是计算LSTM神经网络的结果，返回值为
       		# 1. Y of shape (seq_len, batch, num_directions * hidden_size)
        	# 2. h_n of shape (num_layers * num_directions, batch, hidden_size) 
        	# 3. c_n of shape (num_layers * num_directions, batch, hidden_size)
        Y, self.state = self.rnn(torch.stack(X), state)
        # 全连接层会首先将Y的形状变成(num_steps * batch_size, num_hiddens)，它的输出
        # 形状为(num_steps * batch_size, vocab_size)
        output = self.dense(Y.view(-1, Y.shape[-1]))
        return output, self.state

step2.5. 格式化输入
回归一下每一次训练值是啥：以一句话为例：

原始数据：一二三四五六七八九十

我们选择timestamps=4, batch_size=2，那么需要格式化为：

一二三四
五六七八

剩下的 “九十” 就被丢掉了。对于每一个字符，假设都用$400\times 1$的向量表示。

to_onehot函数的功能如下：把“一、五”用向量的形式表示。

def to_onehot(X, n_class):
    # X shape: (batch, seq_len), output: seq_len elements of (batch, n_class)
    return [one_hot(X[:, i], n_class) for i in range(X.shape[1])]
    
def one_hot(x, n_class, dtype=torch.float32):
    # X shape: (batch), output shape: (batch, n_class)
    x = x.long()
    res = torch.zeros(x.shape[0], n_class, dtype=dtype, device=x.device)
    res.scatter_(1, x.view(-1, 1), 1)
    return res

6. 参考文献

• 《DEEP Learning》
• 《西瓜书》
• 《动手学深度学习》
• 零基础入门深度学习