写这篇文章的起因是,有人问调用 outputs, last_state = tf.nn.static_rnn(cell, inputs) 之后,last_state 和 outputs[-1] 相等吗?如果不想等,为什么会不等呢?
其实这也是学习 RNN 的一大难点。我个人认为,学习 RNN 最难的地方就是弄明白它的输入和输出是什么。一个简单的回答是,对于一个 RNN 单元,它每次接受一个当前输入
xt
x
t
和前一步的隐层状态
st−1
s
t
−
1
,然后产生一个新的隐层状态
st
s
t
,也即:
st=f(xt,st−1)
s
t
=
f
(
x
t
,
s
t
−
1
)
,其中
f
f
代表某个函数,对应于 RNN 内部的运算过程。
一、首先-单层RNN
这种说法并没有错,但是不够好,因为很多时候,把 RNN 的输出和状态区分开来,理解起来会更加顺畅。也就是说,我们认为 RNN 是这样一个单元:
yt,st=f(xt,st−1)
y
t
,
s
t
=
f
(
x
t
,
s
t
−
1
)
,画成图的话,就是这样:
这也是本文所要强调的地方:务必要区分 RNN 的输出和状态。这么做有什么用呢?
先看一个最基本的例子,考虑 Vanilla RNN/GRU Cell(vanilla RNN 就是最普通的 RNN,对应于 TensorFlow 里的 BasicRNNCell),工作过程如下:
这时,
st=yt=ht
s
t
=
y
t
=
h
t
,区分这俩确实没用。
二、其次-单层LSTM
但是!如果是 LSTM 呢?对于 LSTM,它的循环部件其实有两部分,一个是内部 cell 的值,另一个是根据 cell 和 output gate 计算出的 hidden state,输出层只利用 hidden state 的信息,而不直接利用 cell。这样一来,LSTM 的工作过程就是:
其中真正用于循环的状态
st
s
t
其实是
(ct,ht)
(
c
t
,
h
t
)
组成的 tuple(就是 TensorFlow 里的 LSTMStateTuple,当然,如果你选择不用 tuple 表示 LSTM 的内部状态,也可以把
ct
c
t
和
ht
h
t
拼起来,合起来拼成一个 Tensor,这样的话它的状态就是一个 Tensor 了,这时做别的计算可能会方便一些,这个其实就是 TensorFlow 里的 state_is_tuple 这个开关。),而输出
yt
y
t
仅仅是
ht
h
t
(例如网络后面再接一个全连接层然后用 softmax 做分类,这个全连接层的输入仅仅是
ht
h
t
,而没有
ct
c
t
),这时就可以看到区分 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)
s
t
=
(
s
t
(
1
)
,
s
t
(
2
)
,
⋯
,
s
t
(
l
)
)
(这里为什么要用 tuple 呢?直接把它们拼成一个 Tensor 不行吗,tuple 还得一个一个遍历,这多麻烦?答案是,不行。因为多层 RNN 并不需要每一层都一样大,例如有可能最底层维度比较高,隐层单元数较大,越往上则隐层维度越小。这样一来,每一层的状态维度都不一样,没法 concat 成一个 Tensor 啊!);而这个大的 RNN 单元的输出则只有原先的最上层 RNN 的输出,即整体的
yt=y(l)t=h(l)t
y
t
=
y
t
(
l
)
=
h
t
(
l
)
。
在这个例子里,大 RNN 单元的输出和状态显然不一样。在这种视角下,多层 RNN 和单层 RNN 可以用一个统一的视角来看待,世界清爽了许多。事实上,在 TensorFlow 里,MultiRNNCell 就是 RNNCell 的一个子类,它把多层的 RNN 当成一个整体、当成一个内部结构更复杂的单层 RNN 来看待。我在文章最开始提到的代表 RNN 内部计算的函数 f,其实就是 RNNCell 的 _call_ 方法。
四、最后-多层LSTM
再来看最后一个例子,多层 LSTM:
和之前的例子类似,把多层 LSTM 看成一个整体,这个整体的输出就是最上层 LSTM 的输出: yt=ht(l) y t = h t ( 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 呢?或者说 yT y T 等不等于 sT s T 呢?看一下上面四个图就可以知道,当且仅当使用单层 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多层网络的最后输出