学会区分RNN的output和state

写这篇文章的起因是，有人问调用 outputs, last_state = tf.nn.static_rnn(cell, inputs) 之后，last_state 和 outputs[-1] 相等吗？如果不想等，为什么会不等呢？

其实这也是学习 RNN 的一大难点。我个人认为，学习 RNN 最难的地方就是弄明白它的输入和输出是什么。一个简单的回答是，对于一个 RNN 单元，它每次接受一个当前输入 xtxt 和前一步的隐层状态 st−1st−1，然后产生一个新的隐层状态stst，也即：st=f(xt,st−1)st=f(xt,st−1)，其中 ff代表某个函数，对应于 RNN 内部的运算过程。 
一、首先-单层RNN 
这种说法并没有错，但是不够好，因为很多时候，把 RNN 的输出和状态区分开来，理解起来会更加顺畅。也就是说，我们认为 RNN 是这样一个单元：yt,st=f(xt,st−1)yt,st=f(xt,st−1)，画成图的话，就是这样： 

这也是本文所要强调的地方：务必要区分 RNN 的输出和状态。这么做有什么用呢？

先看一个最基本的例子，考虑 Vanilla RNN/GRU Cell（vanilla RNN 就是最普通的 RNN，对应于 TensorFlow 里的 BasicRNNCell），工作过程如下： 
 
这时，st=yt=htst=yt=ht，区分这俩确实没用。

二、其次-单层LSTM 
但是！如果是 LSTM 呢？对于 LSTM，它的循环部件其实有两部分，一个是内部 cell 的值，另一个是根据 cell 和 output gate 计算出的 hidden state，输出层只利用 hidden state 的信息，而不直接利用 cell。这样一来，LSTM 的工作过程就是： 
 
其中真正用于循环的状态 stst其实是(ct,ht)(ct,ht) 组成的 tuple（就是 TensorFlow 里的 LSTMStateTuple，当然，如果你选择不用 tuple 表示 LSTM 的内部状态，也可以把 ctct和 htht 拼起来，合起来拼成一个 Tensor，这样的话它的状态就是一个 Tensor 了，这时做别的计算可能会方便一些，这个其实就是 TensorFlow 里的 state_is_tuple 这个开关。），而输出 ytyt 仅仅是htht（例如网络后面再接一个全连接层然后用 softmax 做分类，这个全连接层的输入仅仅是htht，而没有ctct），这时就可以看到区分 RNN 的输出和状态的意义了。

三、然后-多层RNN 
当然，这种抽象的意义不止于此。如果是一个多层的 Vanilla RNN/GRU Cell，那么一种简单的抽象办法就是，把多层 Cell 当成一个整体，当成一层大的 Cell，然后原先各层之间的关系都当成这个大的 Cell 的内部计算过程/数据流动过程，这样对外而言，多层的 RNN 和单层的 RNN 接口就是一模一样的：在外部看来，多层 RNN 只是一个内部计算更复杂的单层 RNN。图示如下： 
 
大方框表示把多层 RNN 整体视为一层大的 Cell，而里面的小方框则对应于原先的每一层 RNN。这时，如果把大方框视为一个整体，那么这个整体进行循环所需要的状态就是各层的状态组成的集合，或者说把各层的状态放在一起组成一个 tuple：st=(s(1)t,s(2)t,⋯,s(l)t)st=(st(1),st(2),⋯,st(l))（这里为什么要用 tuple 呢？直接把它们拼成一个 Tensor 不行吗，tuple 还得一个一个遍历，这多麻烦？答案是，不行。因为多层 RNN 并不需要每一层都一样大，例如有可能最底层维度比较高，隐层单元数较大，越往上则隐层维度越小。这样一来，每一层的状态维度都不一样，没法 concat 成一个 Tensor 啊！）；而这个大的 RNN 单元的输出则只有原先的最上层 RNN 的输出，即整体的yt=y(l)t=h(l)tyt=yt(l)=ht(l) 。

在这个例子里，大 RNN 单元的输出和状态显然不一样。在这种视角下，多层 RNN 和单层 RNN 可以用一个统一的视角来看待，世界清爽了许多。事实上，在 TensorFlow 里，MultiRNNCell 就是 RNNCell 的一个子类，它把多层的 RNN 当成一个整体、当成一个内部结构更复杂的单层 RNN 来看待。我在文章最开始提到的代表 RNN 内部计算的函数 f，其实就是 RNNCell 的 _call_ 方法。

四、最后-多层LSTM

再来看最后一个例子，多层 LSTM： 

和之前的例子类似，把多层 LSTM 看成一个整体，这个整体的输出就是最上层 LSTM 的输出： yt=ht(l)yt=ht(l) ；而这个整体进行循环所依赖的状态则是每一层状态组合成的 tuple，而每一层状态本身又是一个(c,h)(c,h)tuple，所以最后结果就是一个 tuple 的 tuple，如图所示。

这样一来，便可以回答两个问题：

其一是，outputs, last_state = tf.nn.static_rnn(cell, inputs) 之后，last_state 和 outputs[-1] 相等吗？

outputs 是 RNN Cell 的 output 组成的列表，假设一共有 T 个时间步，那么 outputs = [y_1, y_2, …, y_T]，因此 outputs[-1] = y_T；而 last_state 则是最后一步的隐层状态，即 s_T。

那么，到底 outputs[-1] 等不等于 last_state 呢？或者说 yTyT 等不等于 sTsT呢？看一下上面四个图就可以知道，当且仅当使用单层 Vanilla RNN/GRU 的时候，他们才相等。

五、最最后注意

LSTM 作为一个 state 和 output 不一样的奇葩，导致我们经常需要操作那个 (c, h) tuple，或者在 tuple 和 Tensor 之间转换。有一段很常用的转换代码是这样的：

lstm_state_as_tensor_shape = [num_layers, 2, batch_size, hidden_size]
initial_state = tf.zeros(lstm_state_as_tensor_shape)
unstack_state = tf.unstack(initial_state, axis=0)
tuple_state = tuple([tf.contrib.rnn.LSTMStateTuple(unstack_state[idx][0], unstack_state[idx][1]) for idx in range(num_layers)])
inputs = tf.unstack(inputs, num=num_steps, axis=1)
outputs, state_out = tf.contrib.rnn.static_rnn(cell, inputs, initial_state=tuple_state)

对着上面最后一张多层 LSTM 的图琢磨琢磨，就知道这几行代码到底是如何把 Tensor 转换成多层 LSTM 的状态的了

还有一个问题待解答：

cell_outputs = []

def lstm_cell():#定义一个LSTM结构
    return tf.contrib.rnn.LSTMCell(num_input_hidden_size, forget_bias = 1.0, cell_clip = 5.0, state_is_tuple=True)

def attn_cell():#使用DropoutWrapper类来实现dropout功能
    return tf.contrib.rnn.DropoutWrapper(lstm_cell(), output_keep_prob = 1 - isdrop * 0.5) 

cell = tf.contrib.rnn.MultiRNNCell([attn_cell() for _ in range(LSTM_DEPTH)], state_is_tuple=True)
(cell_output_one_step, state) = cell(cell_inputs[time_step], state)

cell_outputs.append(cell_output_one_step)


h_fc1 = tf.concat([cell_outputs[time_step], efs], axis = 1)
h_fc2 = full_connect_lstm(h_fc1, num_input_hidden_size + GOP_LENGTH + 1, num_denlayers_2_features,acti_mode = acti_mode_fc, keep_prob = 1-isdrop*0.2, is_reuse_var=(time_step>0)

其中cell_output_one_step是指t时刻，多层LSTM的最后输出，cell_outputs.append是将所有时刻的多层LSTM最后输出合并在一起吗？

LSTM后面接全连接层的时候，使用的是cell_outputs[time_step]，即time_step时刻的LSTM多层网络的最后输出