tf.nn.dynamic_rnn和tf.nn.static_rnn
为什么会有tf.nn.dynamic_rnn和tf.nn.static_rnn，首先理解time_step是干什么的。
1. 首先理解time_step
举例说明：
- 文字数据
如果数据有1000段时序的句子，每句话有25个字，对每个字进行向量化，每个字的向量维度为300，那么batch_size=1000，time_steps=25，input_size=300。
解析：time_steps一般情况下就是等于句子的长度，input_size等于字量化后向量的长度。 - 图片数据
拿MNIST手写数字集来说，训练数据有6000个手写数字图像，每个数字图像大小为28*28，batch_size=6000，time_steps=28，input_size=28，我们可以理解为把图片图片分成28份，每份shape=(1, 28)。
2. 解释为什么出现dynamic_rnn和static_rnn
在tensorflow中，可以通过tf.nn.rnn_cell.BasicLSTMCell构建LSTM，最常使用的参数是num_units，表示的是LSTM中隐含状态的维度。
lstm_cell=tf.nn.rnn_cell.BasicLSTMCell(num_units=hidden_size)
LSTM的输入不仅有数据输入，还有前一个时刻的状态输入，因此需要初始化输入状态。
initial_state=lstm_cell.zero_state(batch_size,dtype=tf.float32)
构建多层LSTM,其中hidden_layer_num为LSTM的层数
cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_num)
构建LSTM完整代码如下：
import tensorflow as tf
import numpy as np
batch_size=2
hidden_size=64
num_steps=10
input_dim=8
input=np.random.randn(batch_size,num_steps,input_dim)
input[1,6:]=0
x=tf.placeholder(dtype=tf.float32,shape=[batch_size,num_steps,input_dim],name='input_x')
lstm_cell=tf.nn.rnn_cell.BasicLSTMCell(num_units=hidden_size)
initial_state=lstm_cell.zero_state(batch_size,dtype=tf.float32)
outputs=[]
with tf.variable_scope('RNN'):
for i in range(num_steps):
if i > 0 :
# print(tf.get_variable_scope())
tf.get_variable_scope().reuse_variables()
output=lstm_cell(x[:,i,:],initial_state)
outputs.append(output)
从上面可以看出，要想获得num_steps后的output结果，需要for循环进行迭代。此时可以通过dynamic_rnn和static_rnn两个函数进行简化，让他们去做循环的工作。
tf.nn.static_rnn(
cell,
inputs,
initial_state=None,
dtype=None,
sequence_length=None,
scope=None
)
tf.nn.dynamic_rnn(
cell,
inputs,
sequence_length=None,
initial_state=None,
dtype=None,
parallel_iterations=None,
swap_memory=False,
time_major=False,
scope=None
)
总结：基础的RNNCell有一个很明显的问题：对于单个的RNNCell，使用它的call函数进行运算时，只是在序列时间上前进了一个step。比如使用x1、h0得到h1，通过x2、h1得到h2等。这样的话，如果序列长度为10，就要调用10次call函数，比较麻烦。对此，TensorFlow提供了一个tf.nn.dynamic_rnn和tf.nn.static_rnn函数，使用该函数就相当于调用了n次call函数。即通过{h0,x1, x2, …., xn}直接得{h1,h2…,hn}。
3. dynamic_rnn和static_rnn对比
| dynamic_rnn | static_rnn | |
|---|---|---|
| input shape | 【batch_size,time_step(序列长度)，input-dim】 | 【time_steps,batch_size,input_dim】 |
| output shape | 【batch_size,n_steps,n_hidden】 | 【n_steps,batch_size,n_hidden |
| time_step是否可以不同 | 可以 | 不可以 |
其中，需要注意
- tf.nn.dynamic_rnn对应最后的输出shape是【batch_size,n_steps,n_hidden】，因此若要输出对应最后的output，我们必须要进行转置，即tf.transpose(output,[1,0,2])。此时对应输出output[-1]才是对应最终的输出。
特别注意：对应dyanmic_rnn里有个参数是time_major，如果设置对应为true，则我们对应输入为【time_step,batch_size,input_dim】,对应输出也是如此；而如果设置为false，则对应我们如下的代码不需要改动。
#在此假设输入的mnist数据X_in对应为【batch_size,time_steps,input_dim】,则对应lstm的构建为
cell = tf.nn.rnn_cell.BasicLSTMCell(n_hidden_units,forget_bias=1.0,state_is_tuple=True)
init_state = cell.zero_state(batch_size,dtype=tf.float32)
outputs,final_state = tf.nn.dynamic_rnn(cell,X_in,initial_state=init_state,time_major=False)
#对应若是要取最后的数据，则需要进行转置，将n_steps维度提到前面来
outputs = tf.transpose(outputs,[1,0,2])
last_output = outputs[-1]
- tf.nn.static_rnn的input输入
需要是一个list，也就是说是一个【】形式，每个list对应的都是一个time_steps（序列）。输出shape对应为【n_steps,batch_size,n_hidden】,因此对应输出最后一个output[-1]即为我们需要的值。
'''还有一种方法，可以转换为list（忽略其中的加入输入层部分）
_X = tf.transpose(_X, [1, 0, 2]) # permute n_steps and batch_size
_X = tf.reshape(_X, [-1, n_inputs]) # (n_steps*batch_size, n_input)
_X = tf.matmul(_X, weights['in']) + biases['in']
lstm_cell =tf.nn.rnn_cell.BasicLSTMCell(n_hidden_unis, forget_bias=1.0) _init_state=lstm_cell.zero_state(batch_size,dtype=tf.float32)
_X = tf.split(_X, n_step,0 ) # n_steps * (batch_size, n_hidden) #得到我们对应想要的list
##上方的axis 默认是为0的 所以可写可不写
outputs, states =tf.nn.static_rnn(lstm_cell, _X, initial_state=_init_state)
'''
input=tf.unstack(x ,time_steps,1)
lstm_layer=rnn.BasicLSTMCell(num_units,forget_bias=1)
outputs,_=rnn.static_rnn(lstm_layer,input,dtype="float32")