Tensorflow实现RNN隐藏层状态持久化

什么是隐藏层参数

RNN 是包含循环的网络，解决了传统的神经网络不能捕捉序列化数据中动态信息这个问题。RNN可以保存一种上下文的状态，允许信息的持久化。

下图中的RNN网络结构图也是随处可见，基本的RNN网络由输入层、隐藏层、输出层组成，通过隐藏层节点周期性的循环连接，可以使得信息从当前步传递到下一步。无论是广泛使用成熟算法LSTM与BRNN等，都会通过将隐藏层的状态参数传入下一次网络中再运算，实现时序信息的传递。

RNN基本结构

理论描述众多，不做复述，在此重点讲讲Tensorflow框架下的隐藏层参数的持久化实现

Tensorflow中RNN的实现

基本的RNN网络

# 一次给定的迭代中的输入占位符.
words = tf.placeholder(tf.int32, [batch_size, num_steps])

lstm = rnn_cell.BasicLSTMCell(lstm_size)
# 初始化 LSTM 存储状态.
initial_state = state = tf.zeros([batch_size, lstm.state_size])

for i in range(len(num_steps)):
    # 每处理一批词语后更新状态值.
    output, state = lstm(words[:, i], state)

    # LSTM 输出可用于产生下一个词语的预测
    logits = tf.matmul(output, softmax_w) + softmax_b
    probabilities = tf.nn.softmax(logits)
    loss += loss_function(probabilities, target_words)

final_state = state

此段代码看似隐藏层的状态借助变量state，在定义时用全0的Tensor初始化，并在序列迭代过程中进行了更新并依次传入下一次序列迭代中。

但是，Tensorflow的运行模式是先定义网路结构，分配存储空间（并未执行运算），然后在seesion中加载网络结构运算。

上述代码定义的RNN网络，要计算模型损失函数loss，必须调用

session.run([final_state, loss], feed_dict={words: current_batch_of_words})

每次调用session.run()计算时都会完整执行险情定义的网络结构，并对state初始化，并不能实现多个batch间state传递

多个 LSTM 层堆叠

为提高模型的表达能力，可以添加多层 LSTM 来处理数据。类 MultiRNNCell 可以无缝的将其实现：

lstm = rnn_cell.BasicLSTMCell(lstm_size)
stacked_lstm = rnn_cell.MultiRNNCell([lstm] * number_of_layers)

initial_state = state = stacked_lstm.zero_state(batch_size, tf.float32)
for i in range(len(num_steps)):
    # 每次处理一批词语后更新状态值.
    output, state = stacked_lstm(words[:, i], state)

    # 其余的代码.
    # ...

final_state = state

此时state更是个维度是[number_of_layers, batch_size, state_size]的由(c,h)组成的tuple参数

State持久化传递实现

State持久化意义

1. 时序信息传递模型需要借助state保持时序关系
2. 内存空间有限，不可能一次性把所有长时序信息全部存入tensorflow，需要分成多个batch依次执行，而state需要连续传递

state持久化方法

1. tf.nn.dynamic_rnn动态增加时间步长
2. tf.placeholder分配state存储空间，每次更新batch同时给state赋值
3. 序列开始前执行session.run(init_state)

1. tf.nn.dynamic_rnn动态增加时间步长

动态增加步长通过给定每个batch不同的时序输入数量，一次seesion执行运算所有的时序state传递

words = tf.placeholder(tf.int32, [batch_size, num_steps])
lstm = rnn_cell.BasicLSTMCell(lstm_size)
stacked_lstm = rnn_cell.MultiRNNCell([lstm] * number_of_layers)
initial_state = stacked_lstm.zero_state(batch_size, tf.float32)
outputs, state = tf.nn.dynamic_rnn(stacked_lstm, inputs= words, initial_state = init_state)

tf.nn.dynamic_rnn自动完成了state的传递，但此方法缺点内存空间有限导致是不能表示较长时序

2. tf.placeholder分配state存储空间

为state使用tf.placeholder提前分配存储空间的方法，Tensorflow的开发者Eugene Brevdo给出的方法见此

c_state = tf.placeholder(...)
h_state = tf.placeholder(...)
initial_state = tf.nn.rnn_cell.LSTMStateTuple(c_state, h_state)

sess.run(..., feed_dict={c_state: ..., h_state: ...})

LSTM的隐藏层状态是两组参数，所以分别定义两块占位符分别赋值，再组合成tf.nn.rnn_cell.LSTMStateTuple的state结构

但此方法也存在问题，当计算中有多个batch的数据，或者LSTM的网络层数大于1，c_state h_state会存在多组参数，不便赋值操作。
且从前一序列得到的state封装结构中不易解析出各参数赋值给对应的c_state``h_state

3. 序列开始前执行session.run(init_state)

lstm = rnn_cell.BasicLSTMCell(lstm_size)
stacked_lstm = rnn_cell.MultiRNNCell([lstm] * number_of_layers)
# 初始化 LSTM 存储状态.
initial_state = stacked_lstm.zero_state(batch_size, tf.float32)
# 更新状态值.
output, final_state = stacked_lstm(input, initial_state)

...

state = session.run(initial_state)  # 或者 initial_state.eval()
cost, state = session.run([output, final_state],
                                 {input: x,
                                  initial_state: state})

借助tensorflow先定义后执行的原理：

1. 在会话中进行序列循环之前，执行Tensor运算 session.run(initial_state)，将会仅仅执行网络模型定义中对计算initial_state有关联的这部分结构,并返回用0初始化的结果存入state

initial_state = stacked_lstm.zero_state(batch_size, tf.float32)

2. 后续序列循环执行 session.run([output, final_state], {input: x, initial_state: state})的过程中不会调用stacked_lstm.zero_state()重新计算initial_state，而是从会话执行命令中对initial_state直接赋值，通过控制会话传入值来达到初始化隐藏层状态的初始化或者持久化
3. 序列循环开始后，第一次传入的state是在执行session.run(initial_state)得到的初始值，后续传入的state的将是RNN上一序列计算后输出的更新值