RNN与LSTM

RNN网络是在传统神经网络的基础上加入了记忆的成分。对于RNN模型来说，序列被看做一系列随着时间步长递进的事件序列。这里的时间步长并不是真实世界中所指的时间，而是指序列中的位置。RNN模型的特殊结构可以让他处理相互依赖的时间序列及变长数据。长期依赖对于文本理解是不可回避的问题，但普通RNN结构并不能很好的处理这个问题，由于RNN的参数共享，在状态传递的过程中会发生梯度消失或爆炸的问题。LSTM就是为了解决长期依赖问题而产生的。与普通RNN相比，最主要的改进就是多出了三个门控制器：输入门、输出门、遗忘门。

有关RNN与LSTM的具体数学推导可见相关技术博客，这里不做详细阐述。

分类

这里用mnist数据集来做RNN的分类。RNN通常的输入是三维张量[batch_size, step_time, cell.input_size]，这里把28*28的图片的每一行作为输入，28行作为step_time,用128张图片作为一个batch。

首先导入mnist数据集，设置超参数和占位符。

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)

lr = 0.001
n_input = 28
n_step = 28
n_digit = 10
n_cell = 128
n_batch = 128
train_times = 100000

x = tf.placeholder(tf.float32, [None, n_step, n_input])
y = tf.placeholder(tf.float32, [None, n_digit])

这里设计LSTM网络来对图片分类，LSTM的核心是一个隐藏的神经层cell，包括各种门的参数和激活函数，在cell的前后，还各需要输入和输出的网络层。由于输入是三维的张量，在进行输入时，需要将其reshape成二维张量[batch_size*step_time, cell.input_size],再进行权重计算。

x_new = tf.reshape(x, [-1, n_input])
cell_in = tf.layers.dense(x_new, n_cell)
cell_in = tf.reshape(cell_in, [-1, n_step, n_cell])

现在TensorFlow1.2将隐层网络的设计进行了封装，可以直接调用tf.layers.dense.如下：

dense(
    inputs,
    units,
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    trainable=True,
    name=None,
    reuse=None
)

inputs是输入的张量，units是神经元的个数，activation是激活函数，默认没有激活函数。这里只需要将输入进行线性组合，所以不需要激活函数。

然后设计LSTM cell。

cell = tf.contrib.rnn.BasicLSTMCell(n_cell)
# Args:

# num_units: int, The number of units in the LSTM cell.
# forget_bias: float, The bias added to forget gates (see above).
# state_is_tuple: If True, accepted and returned states are 2-tuples of the c_state and m_state.
#   If False, they are concatenated along the column axis. The latter behavior will soon be deprecated.
# activation: Activation function of the inner states. Default: tanh.
# reuse: (optional) Python boolean describing whether to reuse variables
# in an existing scope. If not True, and the existing scope already has
# the given variables, an error is raised.

init_state = cell.zero_state(n_batch, dtype=tf.float32)
output, state = tf.nn.dynamic_rnn(
    cell, cell_in, initial_state=init_state, time_major=False)

调用tf.contrib.rnn.BasicLSTMCell设计cell。num_units是cell中神经元的个数，forget_bias默认为1，表示遗忘门的初始值为1，表示遗忘之前的输入联系。state_is_tuple默认为true，表示输出的state是一个tuple，包含两个list，state[0]是cell中的状态，cell[1]是输出的状态。开始时需要初始化状态，如第二行代码，然后调用tf.nn.dynamic_rnn得到RNN层的结果，output的shape是[batch_size, step_time, cell]，state的shape是[batch_size, cell],cell表示RNN中的神经元个数。

cell后再设计一个输出层，与上类似

cell_out = tf.layers.dense(state[1], n_digit)

这里，使用的是state[1],也可以使用output，但是output是三维张量，对应了每个step的输出，所以需要shape之后再用output[-1].

网络层设计好之后，就是模型的代价函数设计，训练和评估了。

loss = tf.reduce_mean(
    tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=cell_out))
train = tf.train.AdamOptimizer(lr).minimize(loss)

acc = tf.reduce_mean(
    tf.cast(tf.equal(tf.argmax(y, 1), tf.argmax(cell_out, 1)), tf.float32))

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    # print(sess.run(output, {x: mnist.train.images[
    #       :128].reshape([128, n_step, n_input])}).shape)
    # output.shape:n_batch,n_step,n_cell >>= time_major=False

    # print(sess.run(state[1], {x: mnist.train.images[
    #        :128].reshape([128, n_step, n_input])}).shape)
    # state[1].shape:n_batch,n_cell

    for i in range(train_times):
        xs, ys = mnist.train.next_batch(n_batch)
        xs = xs.reshape([n_batch, n_step, n_input])
        sess.run(train, {x: xs, y: ys})
        if i % 200 == 0:
            print(sess.run(acc, {x: xs, y: ys}))

note

• 在图片分类时，由于每一张图片前后没有联系，所以在初始化状态，使初始状态为0后，并不需要改变，但在一些时间序列问题上，每一个batch相互联系，所以在第一次batch初始化状态后，使后一次的状态是前一次的输出状态state。
• RNN的输入是[batch_size, step_time, cell.input_size]，在每一次batch后得到一个输出结果[batch_size,output],若选择dynamic_rnn return的output进行下一步计算，则输出结果为[batch_size, step_time, output]，选择output[-1]时，结果与用state[1]一致。