XDRush

RNN原理详解以及tensorflow中的RNN实现

发表于 |

1 RNN原理

1.1 RNN的时序反向传播原理

RNN中采用时序反向传播算法（BPTT）对参数更新，下面将简单介绍下BPTT原理，并解释其与传统反向传播的区别。我们还将了解梯度消失问题，这也是推动LSTM和GRU发展的原因。

1.1.1 时序反向传播算法

我们以基本RNN结构来说明BPTT算法的原理：
基本的RNN结构图

上图为基本的RNN展开结构图，下面公式展示的是RNN的方程式：
RNN基本方程

同样，将损失函数定义为交叉熵损失函数：
RNN交叉熵损失函数

这里$y_t$为t时刻正确的label，$\widehat{y}_t$是我们的预测。通常我们会将一个完整的句子序列视为一个训练样本，因此总误差为各时间步上的误差之和。
基本RNN误差示意图

别忘了我们的目的是要计算误差对应的参数U、V和W的梯度，然后借助SGD算法来更新参数。当然，我们统计的不只是误差，还包括训练样本在每时间步的梯度：
RNN反向传播更新W

这一步比较好理解，因为总误差等于每个时刻的误差之和，上面就梯度公式对$W$、$V$、$U$均适用。

我们借助导数的链式求导法则来计算梯度，本文后续部分以$E_3$为例来进行介绍：
E3反向传播

上式表明，$\dfrac{\partial{E_3}}{\partial{V}}$的值仅取决于当前时间步的值：$y_t$、$\widehat{y}_t$、$s_3$。同样的，其他时间步对$E$的偏导数也能求出，有了这些值，计算参数$V$的梯度就比较简单了。

接下来再看看$\dfrac{\partial{E_3}}{\partial{W}}$如何求。由上面的公式我们可以推断出$E_3$对$W$的偏导计算公式如下：
E3对W反向传播求导
上面的计算公式用到了复合函数求导法则，将每个时间步长对梯度的贡献相加。换言之，由于参数$W$时间步长应用于想要的输出，因此需从$t=3$开始通过所有网络路径到$t=0$进行反向传播梯度。
反向传播示意图

需要注意的是，这与我们在深度神经网络中应用的标准反向传播算法完全一致，主要区别在于我们对每时间步的参数$W$的梯度进行了求和，传统的人工神经网络中，我们不在层与层之间共享参数，也就无需求和。

1.1.2 梯度消失问题

我们知道在传统RNN中，是无法解决长期以来问题的。而文本信息的句意通常取决于相隔较远的单词，例如“The man who wore a wig on his head went inside”的语意重心在于一个人走进屋里，而非男人戴着假发。但标准的RNN难以捕获此类信息。那么不妨通过分析上面计算出的梯度来一探究竟：

E3对W反向传播求导
上式中，别忘了一点：$\dfrac{\partial{s_3}}{\partial{s_k}}$本身为链式法则，

还需要注意，在对向量函数的向量求导，结果是一个矩阵，逐元素求导，因此，上述梯度可重写为：
链式求导法则重写

tanh、sigmoid函数及其导数的值域如下图所示（参考http://nn.readthedocs.io/en/rtd/transfer/）：

tanh函数及其导数
tanh函数及其导数取值范围

sigmoid函数及其导数
sigmoid函数及其导数

可以看到tanh和sigmoid函数在两端的导数均为0，近乎呈直线状（导数为0，函数图像为直线），此种情况下可称相应的神经元已经饱和。两函数的梯度为0，使前层的其它梯度也趋近于0。由于矩阵元素数值较小，且矩阵相乘数次（t - k次）后，梯度值迅速以指数形式收缩（意思相近于，小数相乘，数值收缩，越来越小），最终在几个时间步长后完全消失。“较远”的时间步长贡献的梯度变为0，这些时间段的状态不会对你的学习有所贡献：你最终还是无法学习长期依赖。梯度消失不仅存在于循环神经网络，也出现在深度前馈神经网络中。区别在于，循环神经网络非常深（本例中，深度与句长相同），因此梯度消失问题更为常见。

不难想象，如果雅克比矩阵的值非常大，参照激活函数及网络参数可能会出现梯度爆炸，即所谓的梯度爆炸问题。相较于梯度爆炸，梯度消失问题更受关注，主要有两个原因：其一，梯度爆炸现象明显，梯度会变成Nan（而并非数字），并出现程序崩溃；其二，在预定义阈值处将梯度截断是一种解决梯度爆炸问题简单有效的方法。而梯度消失问题更为复杂，因为其现象不明显，且解决方案尚不明确。

幸运的是，目前有一些方法可解决梯度消失问题。合理初始化矩阵 W可缓解梯度消失现象。还可采用正则化方法。此外，更好的方法是使用 ReLU，而非tanh或sigmoid激活函数。ReLU函数的导数是个常量，0或1，因此不太可能出现梯度消失现象。

更常用的方法是借助LSTM或GRU架构。1997年，首次提出LSTM ，目前该模型在NLP领域的应用极其广泛。GRU则于2014年问世，是LSTM的简化版。这些循环神经网络旨在解决梯度消失和有效学习长期依赖问题。

1.2 RNN变体之LSTM

LSTM的整体结构如下所示；
LSTM整体结构

接下来我们来逐步拆解下LSTM，看看里面每一个门的原理：

1.2.1 遗忘门

在LSTM中的第一步是决定从cell状态中丢弃什么信息。这个决定是通过一个称为“遗忘门”的结构来完成。这个“门”会读取$h{t-1}$和$x_t$，输出一个0到1之间的数值给每个在cell状态$C{t-1}$中的值，1表示“完全保留”，0表示“完全丢弃”。
LSTM遗忘门

1.2.2 输入门

下一步是决定让多少新的信息加入到cell状态中来。实现这个需要包括两个步骤：首先，一个叫做“input gate layer”的sigmoid层决定哪些信息需要更新；一个$tanh$层生成一个向量，也就是备选的用来更新的内容，$C_t$。在下一步，我们把这两部分联合起来，对 cell 的状态进行一个更新。
LSTM输入门

有了上述的结构，我们就可以按照下图来更新 cell 状态了， 即把$C_{t-1}$更新为 $C_t$，这部分信息就是我们要添加的新内容。
LSTM更新cell状态值

1.2.3 输出门

最后，我们需要来决定输出什么值了。这个输出主要是依赖于 cell 的状态$C_t$，但是又不仅仅依赖于$C_t$，而是需要经过一个过滤的处理。

  • 首先，我们还是使用一个sigmoid层来（计算出）决定$C_t$中的哪部分信息会被输出；
  • 接着，我们把$C_t$通过一个 tanh 层（把数值都归到 -1 和 1 之间），然后把 tanh 层的输出和 sigmoid 层计算出来的权重相乘，这样就得到了最后输出的结果。

在语言模型例子中，假设我们的模型刚刚接触了一个代词，接下来可能要输出一个动词，这个输出可能就和代词的信息相关了。比如说，这个动词应该采用单数形式还是复数的形式，那么我们就得把刚学到的和代词相关的信息都加入到 cell 状态中来，才能够进行正确的预测。
LSTM输出门

1.3 RNN变体之GRU

GRU（Gated Recurrent Unit ），这是由 Cho, et al. (2014) 提出。在 GRU 中，如下图所示，只有两个门：重置门（reset gate）和更新门（update gate）。同时在这个结构中，把细胞状态和隐藏状态进行了合并。最后模型比标准的 LSTM 结构要简单，而且这个结构后来也非常流行。
GRU结构

2 Tensorflow中的RNN实现

2.1 tensorflow中的RNN

tensorflow提供了基本的RNN接口：tf.nn.rnn_cell.RNNCell()，我们首先来简单的看下这个接口：

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
class RNNCell(base_layer.Layer):
  """Abstract object representing an RNN cell.
  
  Every `RNNCell` must have the properties below and implement `call` with the signature `(output, next_state) = call(input, state)`.  The optional third input argument, `scope`, is allowed for backwards compatibility purposes; but should be left off for new subclasses.
  This definition of cell differs from the definition used in the literature. In the literature, 'cell' refers to an object with a single scalar output. This definition refers to a horizontal array of such units.
  An RNN cell, in the most abstract setting, is anything that has a state and performs some operation that takes a matrix of inputs. This operation results in an output matrix with `self.output_size` columns. If `self.state_size` is an integer, this operation also results in a new state matrix with `self.state_size` columns.  If `self.state_size` is a (possibly nested tuple of) TensorShape object(s), then it should return a matching structure of Tensors having shape `[batch_size].concatenate(s)` for each `s` in `self.batch_size`.
  """
  def __call__(self, inputs, state, scope=None):
    """Run this RNN cell on inputs, starting from the given state.
    Args:
      inputs: `2-D` tensor with shape `[batch_size x input_size]`.
      state: if `self.state_size` is an integer, this should be a `2-D Tensor` with shape `[batch_size x self.state_size]`.  Otherwise, if `self.state_size` is a tuple of integers, this should be a tuple with shapes `[batch_size x s] for s in self.state_size`.
      scope: VariableScope for the created subgraph; defaults to class name.
    Returns:
      A pair containing:
      - Output: A `2-D` tensor with shape `[batch_size x self.output_size]`.
      - New state: Either a single `2-D` tensor, or a tuple of tensors matching the arity and shapes of `state`.
    """
    if scope is not None:
      with vs.variable_scope(scope,
                             custom_getter=self._rnn_get_variable) as scope:
        return super(RNNCell, self).__call__(inputs, state, scope=scope)
    else:
      with vs.variable_scope(vs.get_variable_scope(),
                             custom_getter=self._rnn_get_variable):
        return super(RNNCell, self).__call__(inputs, state)
  def _rnn_get_variable(self, getter, *args, **kwargs):
    variable = getter(*args, **kwargs)
    trainable = (variable in tf_variables.trainable_variables() or
                 (isinstance(variable, tf_variables.PartitionedVariable) and
                  list(variable)[0] in tf_variables.trainable_variables()))
    if trainable and variable not in self._trainable_weights:
      self._trainable_weights.append(variable)
    elif not trainable and variable not in self._non_trainable_weights:
      self._non_trainable_weights.append(variable)
    return variable
  @property
  def state_size(self):
    """size(s) of state(s) used by this cell.
    It can be represented by an Integer, a TensorShape or a tuple of Integers or TensorShapes.
    """
    raise NotImplementedError("Abstract method")
  @property
  def output_size(self):
    """Integer or TensorShape: size of outputs produced by this cell."""
    raise NotImplementedError("Abstract method")
  def build(self, _):
    # This tells the parent Layer object that it's OK to call
    # self.add_variable() inside the call() method.
    pass
  def zero_state(self, batch_size, dtype):
    """Return zero-filled state tensor(s).
    Args:
      batch_size: int, float, or unit Tensor representing the batch size.
      dtype: the data type to use for the state.
    Returns:
      If `state_size` is an int or TensorShape, then the return value is a `N-D` tensor of shape `[batch_size x state_size]` filled with zeros.
      If `state_size` is a nested list or tuple, then the return value is a nested list or tuple (of the same structure) of `2-D` tensors with the shapes `[batch_size x s]` for each s in `state_size`.
    """
    with ops.name_scope(type(self).__name__ + "ZeroState", values=[batch_size]):
      state_size = self.state_size
      return _zero_state_tensors(state_size, batch_size, dtype)

从上面的代码我们得知，RNNCell()其实是不能直接调用的，需要对其中的几个方法做implemention，直接调用RNNCell()会报错：

1
2
3
4
5
6
7
8
9
10
input = tf.random_uniform(shape=[3, 4, 6], dtype=tf.float32)
cell = tf.nn.rnn_cell.RNNCell(10)
init_state = cell.zero_state(4, dtype=tf.float32)
output, final_state = tf.nn.dynamic_rnn(cell, inputs=input, initial_state=init_state, time_major=True)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print (sess.run(output))
    print (sess.run(final_state))

运行上面代码会报错，具体错误为：

1
2
raise NotImplementedError("Abstract method")
NotImplementedError: Abstract method

这个Error正是上面RNNCell类中方法抛出来的Error。

可以认为，RNNCell是所有其他RNN的基类，这个从源码中能够很直接的看到：

1
2
3
4
5
6
7
8
9
10
## BasicRNNCell
class BasicRNNCell(RNNCell):
## BasicLSTMCell
class BasicLSTMCell(RNNCell):
## GRUCell
class GRUCell(RNNCell):
## 等等其他的RNN变体

因此，我们将上面代码中的RNNCell换成BasicRNNCell/BasicLSTMCell/GRUCell都可以正确运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
BATCH_SIZE = 4
## 因为后面time_major=True，因此这里shape=[3, 4, 6]，3表示max_time，也就是文本的长度，6表示文本词向量大小
input = tf.random_uniform(shape=[3, BATCH_SIZE, 6], dtype=tf.float32)
cell = tf.nn.rnn_cell.BasicRNNCell(10)
## 或者用LSTMCell
# cell = tf.nn.rnn_cell.LSTMCell(10)
## 或者用GRUCell
# cell = tf.nn.rnn_cell.GRUCell(10)
init_state = cell.zero_state(BATCH_SIZE, dtype=tf.float32)
output, final_state = tf.nn.dynamic_rnn(cell, inputs=input, initial_state=init_state, time_major=True)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print (sess.run(output))
    print (sess.run(final_state))

上面例子中，在定义cell是，无论是BasicRNNCell、BasicLSTMCell、GRUCell都有一个参数num_units，理解这几个Cell的参数含义十分重要：
BasicLSTMCell

1
def __init__(self, num_units, forget_bias=1.0, state_is_tuple=True, activation=None, reuse=None):

几个参数的含义如下：

  • num_uints：官方API里给出的解释是“The number of units in the LSTM cell”，也就是上面LSTM结构图中$h_t$和$C_t$的维度（$h_t$和$C_t$具有相同的维度）。指定这个参数之后，RNN内部会对$W$、$b$作自动维度适配；
  • forget_bias：没太弄明白这个参数是干嘛的；
  • state_is_tuple：决定输出是否是tuple，默认为True，为False根据官方文档会被废弃掉；
  • activation：指定激活函数，当activation为None时，默认使用的就是tanh；

BasicRNNCell、GRUCell等参数同BasicLSTMCell，这里不做多述。

2.2 关于output和state

个人认为，RNN最难理解的地方之一就是output和state，output对应的是输出，state对应的是状态，在tensorflow中，dynamic_rnn、static_rnn、bidirectional_dynamic_rnn、static_bidirectional_rnn都是返回(outputs, last_states)元组，注意，last_states是最终的状态，而outputs对应的则是每个时刻的输出。在使用tensorflow做RNN相关任务时，这一点不理解清楚后面就没法儿继续了。

output和state在RNN及其变体中的意义是不一样的，所表示的值也不一样，下面来看下几个最基本的RNN及其变体中的output和state的含义：

BasicRNNCell
基本的RNN结构如下所示：
基本的RNN
在基本的RNN结构中，我们可以认为输出就等于隐层状态值。我们来看下以下代码的outputs和last_states的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
def dynamic_rnn_test():
    BATCH_SIZE = 2
    EMBEDDING_DIM = 4
    X = np.random.randn(BATCH_SIZE, 5, EMBEDDING_DIM)
    X_lengths = [5, 5]
    cell = tf.nn.rnn_cell.BasicRNNCell(num_units=10)
    outputs, last_states = tf.nn.dynamic_rnn(cell=cell, dtype=tf.float64, sequence_length=X_lengths, inputs=X)
    result = tf.contrib.learn.run_n({"outputs": outputs, "last_states": last_states}, n=1, feed_dict=None)
    print (result[0]["outputs"])
    print ("--------------------------------")
    print (result[0]["last_states"])

上面代码的输出结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
## outputs结果
[[[-0.26285439 -0.73199998  0.67373167 -0.42019807 -0.76447828 -0.15671307  0.19419611 -0.06485997 -0.59310542  0.41760793]
  [-0.51952513  0.61765864  0.54485767  0.35961272  0.09553398  0.68890209   -0.46678386  0.34405317  0.8904701  -0.04432281]
  [ 0.96647506 -0.50980204  0.55754585  0.93328233  0.57254379  0.6663917  -0.40768854  0.86358991 -0.58068622 -0.72018298]
  [ 0.3345003  -0.09220678  0.69535521 -0.01648253 -0.21293752 -0.12114425  0.14904557  0.59020341  0.3342177   0.25945014]
  [ 0.05128395  0.86625483  0.28549682  0.76454802  0.44757274  0.691485  0.00960586  0.23504622  0.75175537 -0.33478982]]
 [[-0.27505881  0.78801392 -0.92769186  0.38675853  0.31331528 -0.79453833  0.77526593 -0.34045865  0.52494778  0.08722081]
  [ 0.21659185 -0.05254756 -0.46941906 -0.70990551  0.82241305  0.7653751  -0.75469825 -0.65669409 -0.68308972 -0.54132448]
  [ 0.6928769  -0.80066683  0.02133818 -0.66396161 -0.48229484 -0.80333658  0.66119584  0.79458079 -0.73295564 -0.65123496]
  [-0.84663     0.26150571 -0.35573722 -0.88728337 -0.70946976 -0.59880986  0.95380342  0.63640031  0.14041671 -0.74008235]
  [-0.49611388 -0.6615701  -0.91717102 -0.7921021   0.19823286 -0.52368639  0.73433595 -0.42381531 -0.22037713 -0.6572696 ]]]
--------------------------------
## last_states结果
[[ 0.05128395  0.86625483  0.28549682  0.76454802  0.44757274  0.691485  0.00960586  0.23504622  0.75175537 -0.33478982]
 [-0.49611388 -0.6615701  -0.91717102 -0.7921021   0.19823286 -0.52368639  0.73433595 -0.42381531 -0.22037713 -0.6572696 ]]

比较下outputs[0][4]（第一个样本最后时刻的输出）和last_states[0]（第一个样本最后的状态）、以及outputs[1][4]（第二个样本最后时刻的输出）和last_states[1]（第二个样本最后时刻的输出）的值，不难发现，它们是相等的！这也印证上面的说法。

BasicLSTMCell
LSTM与基本的RNN有些不用（参见1.3节），因为LSTM引入了4个门，多了几个状态，因此LSTM的输出和BasicRNNCell是不同的。我们通过一个例子看看BasicLSTMCell的基本用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
BATCH_SIZE = 2
    EMBEDDING_DIM = 4
    X = np.random.randn(BATCH_SIZE, 5, EMBEDDING_DIM)
    X_lengths = [5, 5]
    ## 使用LSTM
    cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=10)
    outputs, last_states = tf.nn.dynamic_rnn(cell=cell, dtype=tf.float64, sequence_length=X_lengths, inputs=X)
    result = tf.contrib.learn.run_n({"outputs": outputs, "last_states": last_states}, n=1, feed_dict=None)
    print (result[0]["outputs"])
    print ("--------------------------------")
    print (result[0]["last_states"])

以上运行的结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[[[-0.02559858  0.06167649  0.1645186   0.05837131  0.01109476 -0.02938359  0.11438462 -0.0655154   0.05643917 -0.17126968]
  [ 0.03442813  0.01858283  0.19324815 -0.08899226  0.03568535 -0.04120232  0.1620414  -0.12981834  0.13737953 -0.10649411]
  [ 0.021796   -0.0292876   0.04972559 -0.04365079  0.06611464 -0.0123974  0.04471634 -0.09371935  0.07161399 -0.00129043]
  [-0.06856613  0.08481594  0.08859627 -0.07172004 -0.02254162  0.04920269  0.06426967 -0.07178349  0.06880909 -0.03122769]
  [-0.05681122  0.1265717   0.08145183 -0.10992898 -0.04531312  0.08419307  0.05815578 -0.03600487  0.06829341 -0.00815202]]
 [[-0.03048013 -0.05028687  0.04530328 -0.01116215 -0.00322128 -0.0376331  0.05989264 -0.1386925  -0.02739475 -0.0416665 ]
  [-0.07246373  0.00922893 -0.02089626  0.12696067  0.05484725 -0.05276134  0.02418303 -0.0003094  -0.04619291 -0.02940275]
  [-0.06912543  0.06466857  0.22031627 -0.07334317 -0.03599558  0.01374829  0.12909539 -0.1685715   0.05465224 -0.19901284]
  [-0.0769867   0.05043309  0.08731908  0.00185187  0.00557504  0.007338  0.0641817  -0.0849491   0.0245508  -0.07668919]
  [-0.01582939  0.00979516 -0.02073626  0.09953952  0.10595823 -0.0135512  -0.12155518  0.04029387  0.00712342  0.02277357]]]
--------------------------------
LSTMStateTuple(
c=array([[-0.13211159,  0.26529373,  0.18125151, -0.19673843, -0.10883727,  0.16908338,  0.10463188, -0.08444297,  0.17317917, -0.01578971],  [-0.03322975,  0.02126845, -0.04260041,  0.19423348,  0.22194511,  -0.03170695, -0.19370151,  0.10526997,  0.0245572 ,  0.05014028]]), 
h=array([[-0.05681122,  0.1265717 ,  0.08145183, -0.10992898, -0.04531312,  0.08419307,  0.05815578, -0.03600487,  0.06829341, -0.00815202],  [-0.01582939,  0.00979516, -0.02073626,  0.09953952,  0.10595823,  -0.0135512 , -0.12155518,  0.04029387,  0.00712342,  0.02277357]]))

从上面结果中我们看到，和BasicRNNCell相同的是，BasicLSTMCell返回的outputs是一样的，都是对应于每个时刻的输出（其实这里的输出也就是每个时刻的隐层状态值；更为一般的做法是，得到outputs值之后，在经过一个全连接层、softmax层做分类任务）。不同的是，last_states的值，BasicLSTMCell的last_states返回的是一个LSTMStateTuple，也就是一个LSTMState结构的元组，元组里面包含两个元素：c和h，c表示的就是最后时刻cell的内部状态值，h表示的就是最后时刻隐层状态值。

GRUCell
从1.4节中GRU原理可知，GRU的输出outputs和LSTM、BasicRNNCell是一样的，last_states和BasicRNNCell一样，只输出最后一个时刻的隐层状态值。同样用个例子来说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
BATCH_SIZE = 2
    EMBEDDING_DIM = 4
    X = np.random.randn(BATCH_SIZE, 5, EMBEDDING_DIM)
    X_lengths = [5, 5]
    ## cell用GRU
    cell = tf.nn.rnn_cell.GRUCell(num_units=10)
    outputs, last_states = tf.nn.dynamic_rnn(cell=cell, dtype=tf.float64, sequence_length=X_lengths, inputs=X)
    result = tf.contrib.learn.run_n({"outputs": outputs, "last_states": last_states}, n=1, feed_dict=None)
    print (result[0]["outputs"])
    print ("--------------------------------")
    print (result[0]["last_states"])

输出结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[[[ 0.2818741   0.03127117 -0.10587379  0.04028049  0.10053002  0.15848186  -0.18849411  0.27622443  0.38123248 -0.13761087]
  [ 0.20203697  0.27380701  0.20594786  0.32964536 -0.03476539  0.0324929  -0.17276558  0.23946512  0.25474486 -0.03569277]
  [ 0.09995877  0.03133022  0.03788231  0.33481101  0.05394468  0.17044128  -0.22957891  0.07784969  0.12172921 -0.11151596]
  [-0.01079724  0.34425545  0.36282874  0.51701521 -0.13545613  0.20845521  -0.16279659  0.08200397 -0.07883915 -0.0671937 ]
  [ 0.04381321  0.10883886  0.37020907  0.42074759  0.14924879  0.07081199  -0.20527748 -0.0342331  -0.01571459  0.01904762]]
 [[ 0.08714771  0.49216403  0.23638074  0.54007724 -0.12808233  0.05203507  0.04589614  0.20300933  0.00669649 -0.08931576]
  [ 0.15230049  0.31014089  0.25244098  0.44602376 -0.04282711  0.13599053  -0.01098503  0.14189271  0.04150135 -0.06910757]
  [ 0.3996701   0.10472691  0.21537184  0.39543418  0.22428281  0.07584328  -0.20120173  0.10623939  0.26915325 -0.09094824]
  [ 0.38323232  0.09812629  0.04226342  0.37831236  0.27365562  0.20740802  -0.24894298  0.1094313   0.2308372  -0.12473171]
  [ 0.27563199  0.01112365  0.06366856  0.41799209  0.45473254  0.27676832  -0.34215252  0.0085023   0.23020847 -0.23767658]]]
--------------------------------
[[ 0.04381321  0.10883886  0.37020907  0.42074759  0.14924879  0.07081199  -0.20527748 -0.0342331  -0.01571459  0.01904762]
 [ 0.27563199  0.01112365  0.06366856  0.41799209  0.45473254  0.27676832  -0.34215252  0.0085023   0.23020847 -0.23767658]]

2.2 dynamic_rnn和static_rnn

上面代码中，我们用到了一个新的api-dynamic_rnn，具体dynamic_rnn如何用？我们不妨先来看下dynamic_rnn的参数：

1
def dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None, dtype=None, parallel_iterations=None, swap_memory=False, time_major=False, scope=None):

我们来结合一个例子来说明这些参数的含义：

假设RNN的输入为[2, 5, 4]，其中2位batch_size，5为文本最大长度，4为embedding_size，可以看出，有两个样本，我们假设第二个文本的长度只有3（很容易理解，两个句子的长度不一样，第一个句子长度为5，第二个句子长度为3），那么传统上我们需要对第二个句子做zero-padding。

假设cell的HIDDEN_SIZE=10，dynamic_rnn返回两个参数：outputs, last_states，其中outputs的shape为[batch_size, max_length, HIDDEN_SIZE]，也就是最终的输出结果；last_states是最终的状态，是由(c, h)组成的元组，大小均为[batch_size, HIDDEN_SIZE]。

再来看下一个很重要的参数：sequence_length，这个参数用来指定每个文本的长度，比如上面例子中，我们令sequence_length = [5, 3]，表示第一个句子的长度为5，第二个句子的长度为3；当我们传入这个参数时，对于第二个样本，tensorflow对3以后的padding就不做计算了，其last_states将重复第3步的last_states结果直到最后一步，而outputs中超过3步的结果将会被置零。

完整的例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
BATCH_SIZE = 2
    EMBEDDING_DIM = 4
    X = np.random.randn(BATCH_SIZE, 5, EMBEDDING_DIM)
    X[1, 3:] = 0
    X_lengths = [5, 3]
    print (X)
    cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=10)
    outputs, last_states = tf.nn.dynamic_rnn(cell=cell, dtype=tf.float64, sequence_length=X_lengths, inputs=X)
    result = tf.contrib.learn.run_n({"outputs": outputs, "last_states": last_states}, n=1, feed_dict=None)
    print (result[0]["outputs"][0])
    print ("--------------------------------")
    print (result[0]["last_states"])

以上运行结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
## 以下是outputs输出结果，可以看出X[1]的最后两维均为0.
[[[ 0.05207716  0.02861694  0.02288652  0.0409087   0.02277852  0.08781847  -0.00247622  0.06011031  0.13020951  0.000251  ]
  [-0.07430806  0.01455017  0.09025484  0.15882481 -0.09267721  0.06793234  -0.1265452   0.01313293  0.0492417   0.07891826]
  [ 0.07847199  0.08677312 -0.00230764  0.05670163 -0.0037383   0.06010096  -0.08496443  0.05015436  0.05824103  0.07590659]
  [-0.07346585 -0.02648895  0.03345542  0.09968405 -0.18647533 -0.07887278  -0.07283668 -0.12607698 -0.05489173  0.06213264]
  [ 0.01166963  0.02953469  0.03331421  0.09969857 -0.07744646  0.03921037  -0.11335107 -0.01561479  0.03017359  0.13571448]]
 [[-0.05919386 -0.00281228  0.00711866  0.06299696 -0.04266599  0.0259747  -0.07946968 -0.00289627 -0.02592751  0.07808545]
  [ 0.03129078 -0.02892244 -0.01596121 -0.0068038   0.04108508  0.01717525  0.02310689  0.0062713   0.01016119 -0.05758133]
  [ 0.2078819  -0.07376988 -0.12247892 -0.07339147  0.06875815 -0.07224105  0.09830238  0.04630288 -0.03923044 -0.15668869]
  [ 0.          0.          0.          0.          0.          0.          0.
    0.          0.          0.        ]
  [ 0.          0.          0.          0.          0.          0.          0.
    0.          0.          0.        ]]]
## 以下是last_states输出结果：
LSTMStateTuple(
c=array([[ 0.02389863,  0.06531061,  0.06234521,  0.20854867, -0.18754284,  0.08002822, -0.2021616 , -0.04034186,  0.05810034,  0.24871611],
       [ 0.45062326, -0.10235791, -0.27717666, -0.1610663 ,  0.23795195,  -0.12335596,  0.16761175,  0.07196362, -0.0869157 , -0.29036735]]), 
h=array([[ 0.01166963,  0.02953469,  0.03331421,  0.09969857, -0.07744646,  0.03921037, -0.11335107, -0.01561479,  0.03017359,  0.13571448],
       [ 0.2078819 , -0.07376988, -0.12247892, -0.07339147,  0.06875815,  -0.07224105,  0.09830238,  0.04630288, -0.03923044, -0.15668869]]))

既然有dynamic_rnn，自然也就有static_rnn，来看下static_rnn的参数：

1
2
3
4
5
6
def static_rnn(cell,
               inputs,
               initial_state=None,
               dtype=None,
               sequence_length=None,
               scope=None):

2.3 tensorflow中的双向RNN

tensorflow提供了双向RNN接口:tf.nn.bidirectional_dynamic_rnn()，我们首先来看一下这个API的解释：

1
def bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs, sequence_length=None, initial_state_fw=None, initial_state_bw=None, dtype=None, parallel_iterations=None, swap_memory=False, time_major=False, scope=None):

函数参数说明：
cell_fw/cell_bw：定义前向和反向的rnn cell；
inputs：输入序列；
sequence_length：序列长度；
initial_state_fw/initial_state_bw：前向、后向rnn_cell的初始化状态，一般初始化为全零状态；
dtype：数据类型；
time_major：一个很重要的参数，决定了输入和输出的格式，如果time_major为True，那么输出就是时序优先级，输入/输出的tensor格式必须为[max_time, batch_size, depth]，如果time_major为False，那么就是bacth优先级的，输入/输出的格式必须为[batch_size, max_time, depth]；默认情况下，time_major=False，这是因为大多数情况下，tensorflow处理数据都是以batch为单位的，但是当time_major=True时会更高效一些，因为当time_major=True时，可以避免开始和结束时tensor类型的转化开销；其中depth表示输入的词向量的维度（也就是embedding size的大小），max_time可以理解为句子的长度（一般以一个batch中最长的句子为准，不够的需要做padding）。

函数返回值
bidirectional_dynamic_rnn返回一个(outputs, outputs_state)形式的一个元祖。
其中：

  • outputs=(outputs_fw, outputs_bw)，是一个包含前向cell和后向cell输出tensor组成的元组；如果time_major=False，则两个tensor的shape为[batch_size, max_time, depth]，应用在文本中，max_time可以理解为句子的长度（一般以最长的句子为准，短句需要做padding），depth为输入句子词向量的维度；
  • outputs_state=(outputs_state_fw, outputs_state_bw)，包含了前向和后向最后的隐藏状态组成的元组，outputs_state_fw和outputs_state_bw的类型都是LSTMStateTuple，是由(c, h)组成，分别代表memory cell和hidden state状态；

因为bidirectional_dynamic_rnn返回的是前向、后向的结果，最终的结果还需要对前向、后向结果做拼接，利用tf.concat(outputs, 2)即可。

前向和后向cell的定义
cell_fw和cell_bw的定义完全一样的，如果两个cell都是LSTM的话就是双向LSTM，如果两个cell都是GRU的话，就是双向GRU：

1
2
3
4
5
6
7
8
9
10
11
HIDDEN_SIZE = 100
## 定义LSTM
cell_lstm_fw = tf.nn.rnn_cell.LSTMCell(HIDDEN_SIZE)
cell_lstm_bw = tf.nn.rnn_cell.LSTMCell(HIDDEN_SIZE)
## 定义GRU
cell_gru_fw = tf.contrib.rnn.GRUCell(HIDDEN_SIZE)
cell_gru_bw = tf.contrib.rnn.GRUCell(HIDDEN_SIZE)
## 或者用nn模块下的GRUCell也可以
cell_gru_fw = tf.nn.rnn_cell.GRUCell(HIDDEN_SIZE)
cell_gru_bw = tf.nn.rnn_cell.GRUCell(HIDDEN_SIZE)

这里有一点需要注意：RNN/LSTM/GRU在声明cell时，只需传入一个HIDDEN_SIZE即可，它会自动匹配输入数据的维度。

tf.contrib模块下的功能是开发者提供的，等功能得到进一步验证成熟之后，会被放入到官方的模块中。

在bidirectional_dynamic_rnn函数内部，会通过array_ops.reverse_sequence函数将输入序列逆序排列，使其达到反向传播的效果。

在实现的时候，只需将定义好的两个cell作为参数传入即可：

1
(outputs, outputs_state) = tf.nn.bidirectional_dynamic_rnn(cell_gru_fw, cell_gru_bw, inputs_embedded)

需要注意的是，inputs_embedded为输入的tensor，格式为[batch_size, max_time, depth]。

最终的outputs = tf.concat((outputs_fw, outputs_bw), 2)或者直接是outputs = tf.concat(outputs, 2)。

如果还需要用到最后的输出状态，则需要进一步对(outputs_state_fw, outputs_state_bw)做处理：

1
2
3
final_state_c = tf.concat((outputs_state_fw.c, outputs_state_bw.c), 1)
final_state_h = tf.concat((outputs_state_fw.h, outputs_state_bw.h), 1)
outputs_final_state = tf.contrib.rnn.LSTMStateTuple(c=final_state_c, h=final_state_h)

下面给出一个基本的双向LSTM实现步骤：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import tensorflow as tf 
vocab_size = 1000
embedding_size = 50
batch_size =100
max_time = 10
hidden_units = 10
inputs = tf.placeholder(shape=(batch_size, max_time), dtype=tf.int32, name='inputs')
embedding = tf.Variable(tf.random_uniform([vocab_size, embedding_size], -1.0, 1.0), dtype=tf.float32)
inputs_embeded = tf.nn.embedding_lookup(embedding, inputs)
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units)
((outputs_fw, outputs_bw), (outputs_state_fw, outputs_state_bw)) = tf.nn.bidirectional_dynamic_rnn(lstm_cell, lstm_cell, inputs_embeded, sequence_length=max_time)
outputs = tf.concat((outputs_fw, outputs_bw), 2)
final_state_c = tf.concat((outputs_state_fw.c, outputs_state_bw.c), 1)
final_state_h = tf.concat((outputs_state_fw.h, outputs_state_bw.h), 1)
outputs_final_state = tf.contrib.rnn.LSTMStateTuple(c=final_state_c,
                                                    h=final_state_h)

以上就是一个基本的双向LSTM实现流程。

参考

[1] https://sthsf.github.io/2017/08/31/Tensorflow基础知识-bidirectional-rnn/
[2] http://www.cnetnews.com.cn/2017/1118/3100705.shtml
[3] http://blog.csdn.net/wuzqChom/article/details/75453327
[4] http://blog.csdn.net/u012436149/article/details/71080601
[5] 深度学习与自然语言处理(7)_斯坦福cs224d 语言模型，RNN，LSTM与GRU:https://www.zybuluo.com/hanxiaoyang/note/438990