超详细的RNN代码实现(tensorflow)

一、学习单步的RNN：RNNCell

如果要学习TensorFlow中的RNN，第一站应该就是去了解“RNNCell”，它是TensorFlow中实现RNN的基本单元，每个RNNCell都有一个call方法，使用方式是：(output, next_state) = call(input, state)。
也就是说，每调用一次RNNCell的call方法，就相当于在时间上“推进了一步”，这就是RNNCell的基本功能。

在代码实现上，RNNCell只是一个抽象类，我们用的时候都是用的它的两个子类BasicRNNCell和BasicLSTMCell。顾名思义，前者是RNN的基础类，后者是LSTM的基础类。

找到源码中BasicRNNCell的调用函数实现：

def调用（self，inputs，state）：
   “”“最基本的RNN：output = new_state = act（W * input + U * state + B）。”“”
   output = self._activation（_linear（[inputs，state] ，self._num_units，True））
   return 输出，输出

"return输出，输出”说明在BasicRNNCell中，输出其实和隐状态的值是一样的。因此还需要额外对输出定义新的变换才能得到真正的输出y。由于输出和隐状态是一回事，所以在BasicRNNCell中，state_size永远等于output_size

除了call方法外，对于RNNCell，还有两个类属性比较重要：

state_size
output_size
前者是隐层的大小，后者是输出的大小。比如我们通常是将一个batch送入模型计算，设输入数据的形状为(batch_size, input_size)，那么计算时得到的隐层状态就是(batch_size, state_size)，输出就是(batch_size, output_size)。

对于单层RNN：

import tensorflow as tf
import numpy as np

cell = tf.nn.rnn_cell.BasicRNNCell(num_units=) # state_size =
print(cell.state_size) # 

inputs = tf.placeholder(np.float32, shape=(, )) #  是 batch_size，100是input_size  shape = (batch_size, input_size)
h0 = cell.zero_state(, np.float32) # 通过zero_state得到一个全0的初始状态，形状为(batch_size, state_size)
output, h1 = cell.call(inputs, h0) #调用call函数

print(h1.shape) # (, )

对于多层RNN：

import tensorflow as tf
import numpy as np

 num_layers = 2  #层数
hidden_size = [128,256] #每一层的隐节点个数(可以不一样)
rnn_cells = [] #包含所有层的列表

for i in range(num_layers):
    # 构建一个基本rnn单元(一层)
    rnn_cell = tf.nn.rnn_cell.BasicRNNCell(lstm_size[i])
        # 可以添加dropout
    drop_cell = tf.nn.rnn_cell.DropoutWrapper(rnn_cell , output_keep_prob=keep_prob)
        rnn_cells.append(drop_cell)
    # 堆叠多个LSTM单元
    cell = tf.nn.rnn_cell.MultiRNNCell(rnn_cells)
    initial_state = cell.zero_state(batch_size, tf.float32)
    return cell, initial_state

'''
注：对于老版本的tensorflow,堆叠多层RNN（或LSTM）：
cell = tf.nn.rnn_cell.MultiRNNCell([rnn_cell for _ in
range(num_layers)])

'''

对于BasicLSTMCell，情况有些许不同，因为LSTM可以看做有两个隐状态h和c，对应的隐层就是一个Tuple，每个都是(batch_size, state_size)的形状：

import tensorflow as tf
import numpy as np
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=)
inputs = tf.placeholder(np.float32, shape=(, )) #  是 batch_size
h0 = lstm_cell.zero_state(, np.float32) # 通过zero_state得到一个全0的初始状态
output, h1 = lstm_cell.call(inputs, h0) #h1包含两个隐状态

print(h1.h)  # shape=(, )
print(h1.c)  # shape=(, )

二、学习如何一次执行多步：tf.nn.dynamic_rnn

基础的RNNCell有一个很明显的问题：对于单个的RNNCell，我们使用它的call函数进行运算时，只是在序列时间上前进了一步。比如使用x1、h0得到h1，通过x2、h1得到h2等。这样的h话，如果我们的序列长度为10，就要调用10次call函数，比较麻烦。对此，TensorFlow提供了一个tf.nn.dynamic_rnn函数，使用该函数就相当于调用了n次call函数。即通过{h0,x1, x2, …., xn}直接得{h1,h2…,hn}。

具体来说，设我们输入数据的格式为(batch_size, time_steps, input_size)，其中time_steps表示序列本身的长度，如在Char RNN中，长度为10的句子对应的time_steps就等于10。最后的input_size就表示输入数据单个序列单个时间维度上固有的长度。另外我们已经定义好了一个RNNCell，调用该RNNCell的call函数time_steps次，对应的代码就是：

# inputs: shape = (batch_size, time_steps, input_size)
# cell: RNNCell
# initial_state: shape = (batch_size, cell.state_size)。初始状态。一般可以取零矩阵

# inputs: shape = (batch_size, time_steps, input_size)
# cell: RNNCell
# initial_state: shape = (batch_size, cell.state_size)。初始状态。一般可以取零矩阵

import tensorflow as tf

tf.reset_default_graph()
batch_size = 32 # batch大小
input_size = 100 # 输入向量xt维度
state_size = 128 # 隐藏状态ht维度
time_steps = 10 # 序列长度

inputs = tf.random_normal(shape=[batch_size, time_steps, input_size], dtype=tf.float32)
print("inputs.shape:",inputs.shape) #(32,10,100）

lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units = state_size)
print(lstm_cell.state_size) #(c=128,h=128)

initial_state = lstm_cell.zero_state(batch_size, dtype = tf.float32)
print(initial_state.h, initial_state.c)  #(32,128),(32,128)

outputs, state = tf.nn.dynamic_rnn(lstm_cell, inputs, initial_state = initial_state)

print(outputs)  #(32,10,128)
print(state)    #(32,128) state是最终(最后一个time_step）的状态
print(state.h, state.c) #(32,128),(32,128)

转自知乎：https://zhuanlan.zhihu.com/p/28196873