循环神经网络教程第四部分-用Python和Theano实现GRU/LSTM循环神经网络

作者：徐志强 链接：https://zhuanlan.zhihu.com/p/22371429 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 本篇教程的代码在Github上。这里是循环神经网络教程的最后一部分，前几部分别是：

• 循环神经网络教程第一部分-RNN简介
• 循环神经网络教程第二部分-用python，numpy，theano实现一个RNN
• 循环神经网络教程第三部分-BPTT和梯度消失

本篇中我们将学习LSTM（长短项记忆）网络和GRU（门限递归单元）。LSTM由Sepp Hochreiter and Jürgen Schmidhuber在1997年第一次提出，现在是深度学习在NLP上应用的最广泛的模型。GRU，在2014年第一次提出，是LSTM的简单变种，和LSTM有很多相似特性。我们首先看一下LSTM，然后会看一下GRU和它有什么不同。

LSTM网络

在第三部分中，我们看到了消失梯度问题是如何阻止标准的RNN学习到长距离依赖的。LSTM通过使用一个门限机制来克服消失梯度问题。为了理解其中的意思，先看一下LSTM如何计算隐状态

s_{t}

（我使用

\circ

表示逐元素相乘）：

i = \sigma(x_{t}U^{i}+s_{t-1}W^{i})

f=\sigma(x_{t}U^{f}+s_{t-1}W^f)

o=\sigma(x_{t}U^{o}+s_{t-1}W^{o})

g=tanh(x_{t}U^{g}+s_{t-1}W^g)

c_{t}=c_{t-1}\circ f+g\circ i

s_{t}=tanh(c_{t})\circ o

这些公式初看上去很复杂，但实际上没有那么难。首先，注意到LSTM层只是计算隐状态的另一种方法。之前，我们计算隐状态

s_{t}=tanh(Ux_{t}+Ws_{t-1})

，这里的输入是当前时刻

t

的输入和之前的隐状态

s_{t-1}

，输出是一个新的隐状态

s_{t}

。LSTM单元做的也是同样的事，只是用了不同的方式，这是理解整个全局的关键。你本质上可以把LSTM（GRU）视作一个黑盒，在给定当前输入和之前隐状态后，以某种方式计算下一个隐状态。

现在让我们来理解一下LSTM单元是如何隐状态的。Chris Olah写了一篇关于这个问题的很优秀的文章，为了避免重复他的工作，我在这里只是给一个简单的解释。我建议你去读他的文章来做深入的了解并进行可视化，总结一下：

i,f,o

被称作输入、遗忘和输出门。注意到它们的计算公式是一致的，只是用了不同的参数矩阵。它们被称作门是因为sigmoid函数把这些向量的值挤压到了0和1之间，把它们和其他的向量逐元素相乘，就定义了你想让其他向量能“剩下”多少。输入门定义了针对当前输入得到的隐状态能留下多少。遗忘门定义了你想留下多少之前的状态。最后，输出门定义了你想暴露多少内部状态给外部网络（更高层和下一时刻）。所有门都有相同的维度

d_{s}

，即隐状态的大小。

g

是根据当前的输入和之前的隐状态计算得到的一个“候选”状态。它和普通的RNN有完全相同的计算公式，只是我们把参数

U, W

重命名为

U^{g}, W^{g}

。然而，和在RNN中把

g

作为新的隐状态不同，我们使用上面的输入门从中挑选一部分结果。

c_{t}

是单元的内部记忆。它是之前的记忆

c_{t-1}

乘以遗忘门加上新得到的隐状态

g_{t}

乘以输入门得到的结果。因此，直观上可以认为它是我们如何组合之前的记忆和新的输入而得到的结果。我们可以选择完全忽略旧的记忆（遗忘门全0）或者完全忽略计算得到的新状态（输入门全0），但是大多数时候会选择这两个极端之间的结果。

• 给定当前记忆

c_{t}

，我们最终根据记忆和输出门的乘积计算得到输出隐状态

s_{t}

。在网络中，不是所有的内部记忆都会和其他单元使用的隐状态相关。

直观上，普通RNN可以认为是LSTM的一个特例。如果你把输入门全部固定为1，遗忘门全部固定为0（你通常会忘记之前的记忆），输出门全都固定为1（你暴露出全部记忆），你得到的几乎就是标准RNN，只是多了一个额外的tanh把输出压缩了一些。门机制让LSTM能显式地对长期依赖进行建模。通过学习门的参数，网络能够学会如何表示它的记忆。

值得注意的是，也存在一些基本LSTM架构的变种。一个常见的变种创建peephole连接，让门不仅依赖于之前的隐状态

s_{t-1}

，也依赖于之前的内部状态

c_{t-1}

，在门方程中添加一个额外项。也存在许多其他的变种。 LSTM: A Search Space Odyssey这篇文章用实验比较了一些不同的LSTM架构。

GRUS

GRU层中的思想和LSTM层十分相似，公式如下：

z=\sigma (x_{t}U^z+s_{t-1}W^z)

r=\sigma(x_{t}U^r+s_{t-1}W^r)

h=tanh(x_{t}U^h+(s_{t-1}\circ r)W^h)

s_{t}=(1-z)\circ h+z\circ s_{t-1}

GRU有两个门，重置门

r

，更新门

z

。直观上，重置门决定了如何组合新输入和之前的记忆，更新门决定了留下多少之前的记忆。如果我们把重置门都设为1，更新门都设为0，也同样得到了普通的RNN模型。使用门机制的基本思想和LSTM相同，都是为了学习长期依赖，但是也有一些重要的不同之处：

• GRU有两个门，LSTM有三个门。
• GRU没有不同于隐状态的内部记忆

c_{t}

，没有LSTM中的输出门。

• 输入门和遗忘门通过更新门

z

进行耦合，重置门

r

被直接应用于之前的隐状态。因此，LSTM中的重置门的责任实质上被分割到了

r

和

z

中。

• 在计算输出时，没有使用第二个非线性单元。

GRU VS LSTM

现在你已经看到了两个能够解决消失梯度问题的模型，你可能会疑惑：使用哪一个？GRU非常新，它们之间的权衡没有得到完全的研究。根据Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling和 An Empirical Exploration of Recurrent Network Architectures的实验结果，两者之前没有很大差别。在许多任务中，两种结构产生了差不多的性能，调整像层大小这样的参数可能比选择合适的架构更重要。GRU的参数更少，因而训练稍快或需要更少的数据来泛化。另一方面，如果你有足够的数据，LSTM的强大表达能力可能会产生更好的结果。

实现

让我们回到第二部分中实现的语言模型，现在在RNN中使用GRU单元。这里没有什么重要的原因关于为什么在这一部分中使用GUR而不是LSTM（除了我想更熟悉一下GRU外）。它们的实现几乎相同，因此你可以很容易地根据改变后的公式把GRU的代码修改成LSTM的。

这里基于的是之前的Theano实现，注意到GRU只是另一种计算隐状态的方式，所以这里我们只需要在前向传播函数中改变之前的隐状态计算方式。

def forward_prop_step(x_t, s_t1_prev):
      # This is how we calculated the hidden state in a simple RNN. No longer!
      # s_t = T.tanh(U[:,x_t] + W.dot(s_t1_prev))
       
      # Get the word vector
      x_e = E[:,x_t]
       
      # GRU Layer
      z_t1 = T.nnet.hard_sigmoid(U[0].dot(x_e) + W[0].dot(s_t1_prev) + b[0])
      r_t1 = T.nnet.hard_sigmoid(U[1].dot(x_e) + W[1].dot(s_t1_prev) + b[1])
      c_t1 = T.tanh(U[2].dot(x_e) + W[2].dot(s_t1_prev * r_t1) + b[2])
      s_t1 = (T.ones_like(z_t1) - z_t1) * c_t1 + z_t1 * s_t1_prev
       
      # Final output calculation
      # Theano's softmax returns a matrix with one row, we only need the row
      o_t = T.nnet.softmax(V.dot(s_t1) + c)[0]
 
      return [o_t, s_t1]

在实现中，我们添加了偏置项

b, c

，可以看出这并没有展示在公式中。当然，这里我们需要改变参数

U, W

的初始化方式，因为现在它们的大小变化了。这里并没有展示出初始化的代码，但是在Github上可以找到。这里我同样添加了一个嵌入层

E

，会在下面提到。

现在看起来非常简单，但是梯度怎么计算呢？我们可以像之前一样用链式法则手工推导出

E,W,U,b,c

的梯度。但在实际中，大多数人使用支持自动微分的库Theano。如果你不得不自己来计算梯度，你可能想把不同的单元模块化，并用链式法则得到你自己的自动微分版本。这里我们使用Theano来计算梯度：

# Gradients using Theano
dE = T.grad(cost, E)
dU = T.grad(cost, U)
dW = T.grad(cost, W)
db = T.grad(cost, b)
dV = T.grad(cost, V)
dc = T.grad(cost, c)

这基本上就差不多了。为了得到更好的结果，在实现中我们也使用了一些额外的技巧。

使用RMSPROP来更新参数

在第二部分中，我们使用最简单的随机梯度下降（SGD）来更新我们的参数，事实证明这并不是一个好主意。如果你把学习率设得很低，SGD保证能找到一个好的解，但在实际中会花费很长的时间。有一些常用的SGD的变种，包括 (Nesterov) Momentum Method，AdaGrad，AdaDelta和RmsProp，这篇文章中对这些方法有一个很好的综述。我也打算在将来的文章的文章中仔细探索每一个方法的实现。针对教程本部分，我准备选用rmsprop，它的基本思想是根据之前的梯度和逐参数调整学习率。直观上，这意味着频繁出现的特征会获得较小的学习率，稀有的特征会获得较大的学习率。

rmsprop的实现很简单。针对每个参数，我们保存一个缓存变量，在梯度下降时，我们如下更新参数和缓存变量（以

W

为例）：

cacheW = decay * cacheW + (1 - decay) * dW ** 2
W = W - learning_rate * dW / np.sqrt(cacheW + 1e-6)

衰减率通常设为0.9或0.95，加上1e-6项是为了防止除0。

添加一个嵌入层

使用word2vec和Glove这样的词嵌入模型是提高模型精度的一个常用手段。相对于使用one-hot向量表示词，使用word2vec和Glove学习到的低维向量中含有一定的语义——相似的词有着相似的向量。使用这些向量是预训练的一种形式。直观上，你告诉神经网络哪些词是相似的，以便于它可以更少地学习语言知识。使用预训练的向量在你没有大量的数据时非常有用，因为它能让网络可以对未见过的词进行泛化。我在实验中没有使用预训练的词向量，但是添加一个嵌入层（代码中的矩阵

E

）很容易。嵌入矩阵只是一个查找表——第i个列向量对应于词表中的第i个词。通过更新矩阵

E

，我们也可以自己学习词向量，但只能特定于我们的任务，不如可以下载到的在上亿个文档训练的词向量那么通用。

添加第二个GRU层

在我们的网络中添加第二个层可以让模型捕捉到更高层的交互。你也可以再添加额外的层，但我在实验中没有尝试。在添加2到3个层后，你可能会接着观察到损失值在降低，当然除非你有大量的数据，更多的层不可能会产生很大的影响，甚至可能导致过拟合。

向网络中添加第二个层是很简单的，我们只需要修改前向传播中的计算过程和初始化函数。

# GRU Layer 1
z_t1 = T.nnet.hard_sigmoid(U[0].dot(x_e) + W[0].dot(s_t1_prev) + b[0])
r_t1 = T.nnet.hard_sigmoid(U[1].dot(x_e) + W[1].dot(s_t1_prev) + b[1])
c_t1 = T.tanh(U[2].dot(x_e) + W[2].dot(s_t1_prev * r_t1) + b[2])
s_t1 = (T.ones_like(z_t1) - z_t1) * c_t1 + z_t1 * s_t1_prev
 
# GRU Layer 2
z_t2 = T.nnet.hard_sigmoid(U[3].dot(s_t1) + W[3].dot(s_t2_prev) + b[3])
r_t2 = T.nnet.hard_sigmoid(U[4].dot(s_t1) + W[4].dot(s_t2_prev) + b[4])
c_t2 = T.tanh(U[5].dot(s_t1) + W[5].dot(s_t2_prev * r_t2) + b[5])
s_t2 = (T.ones_like(z_t2) - z_t2) * c_t2 + z_t2 * s_t2_prev

关于性能的注意点

在前面的文章中提到过性能的问题，现在我想说明的是这里提供的代码并不十分高效，主要是为了简明性做了优化，并且主要用于教育目的。对于了解模型来说可能已经足够了，但是不要将模型用于生产环境或者用大量的数据来训练模型。已经有了许多优化RNN性能的技巧，但是其中最重要的一个可能是用批量数据更新模型参数。相较于每次学习一个句子，你应该把相同长度的句子分成组（甚至把所有句子填充到相同长度），然后进行大规模矩阵乘法，并按批将梯度加和。这是因为大规模矩阵乘法可以用GPU高效处理。如果不这么做，使用GPU带来的加速是很少的，训练过程会非常缓慢。

所以，对于训练大规模的模型，我强烈建议使用一个针对性能优化过的深度学习库。用上面的代码需要训练几天或几周的模型用这些库只需要训练几小时。我个人比较喜欢Keras，它非常易用，并带有一些关于RNN的非常好的例子。

结果

为了免去你用几天时间训练模型的痛苦，我训练了一个和教程二中的模型很相似的一个模型。我使用的词表大小是8000，把词映射到了48维向量，并用了两个128维的GRU层。这个IPython notebook包含了加载模型的代码，你可以直接使用它，修改它，用它来生成文本。

下面是一些网络输出的非常不错的例子（我添加了首字母大写）：

I am a bot , and this action was performed automatically .I enforce myself ridiculously well enough to just youtube.I’ve got a good rhythm going !There is no problem here, but at least still wave !It depends on how plausible my judgement is .( with the constitution which makes it impossible ) 观察这些句子在多个时刻的语义依赖是非常有意思的。例如，机器人和自动地是明显相关的，开关括号也是。我们的网络能学习到这些，看起来非常酷！

PS：RNN系列教程翻译算是告一段落了，里面的一些实验我还没有做，后续也会去做。RNN对于序列建模来说很强大，在自动问答，机器翻译，图像描述生成中都有使用，后续会翻译或自己写一些这方面的内容，^_^!!!