循环神经网络（RNN）基础案例_void rnn::train

本文采用一个较为简单的例子，来介绍循环神经网络。 文中的代码按顺序复制下来可以运行，并得出结果。

关于循环神经网络的原理，后续会专门再介绍，详细关注我的博客。对于大多数程序员来说，通过程序来理解，可能更为直观。

例子： 输入3行4列的矩阵数据，如

         [1,  2,  5,  6],
         [5,  7,  7,  8],
         [3,  4,  5,  7]

          输出： 

          [1,   3,   7,  11], 
          [5, 12, 14,  15],
          [3,   7,   9,  12]     

    分析规律： 输出第1列为输入的第1列， 输出第2列为输入的第1列和第2列之和， 输出的第3列为输入的第2列和第3列之和，依次类推。那么如何通过神经网络来训练这个模型呢？ 可以看到里面有LSTM（长短文本分析）的特征，所以，我们很自然的想到用循环神经网络来训练。因为数据量不多，这个地方用一层网络就可以了。 下面请看代码

首先导入依赖包：

import tensorflow as tf
from tensorflow.contrib import rnn
tf.reset_default_graph()

创建一个模型类， 这个类中包含RNN训练参数初始化，损失函数及优化器的构建，模型生成方法，模型训练方法，以及测试方法

class SeriesPredictor:
    def __init__(self, input_dim, seq_size, hidden_dim=10):
        # 网络参数
        self.input_dim = input_dim  # 输入维度
        self.seq_size = seq_size # 时序长度
        self.hidden_dim = hidden_dim  # 隐藏层维度
 
        # 权重参数W与输入X及标签Y
        self.W_out = tf.Variable(tf.random_normal([hidden_dim, 1]), name="W_out")
        self.b_out = tf.Variable(tf.random_normal([1]), name='b_out')
        self.x = tf.placeholder(tf.float32, [None, seq_size, input_dim])
        self.y = tf.placeholder(tf.float32, [None, seq_size])
 
        # 均方误差求损失值，并使用梯度下降
        self.cost = tf.reduce_mean(tf.square(self.model() - self.y))
        self.train_op = tf.train.AdamOptimizer().minimize(self.cost)
 
        self.saver = tf.train.Saver()
 
    def model(self):
        '''
        :param x: inpouts of size [T, batch_size, input_size]
        :param W: matrix of fully-connected output layer weights
        :param b: vector of fully-connected output layer biases
        '''
        # BasicLSTMCell基本的RNN类， 建立hidden_dim个CELL
        cell = rnn.BasicLSTMCell(self.hidden_dim)
        # dynamic_rnn 动态RNN， cell生成好的cell类对象， self.x是一个张量， 一般是三维张量[Batch_size, max_time(序列时间X0-Xt), X具体输入]
        outputs, states = tf.nn.dynamic_rnn(cell, self.x, dtype=tf.float32)  # (?, seq_size, hidden_dim)
        num_examples = tf.shape(self.x)[0]
        tf_expand = tf.expand_dims(self.W_out, 0)
        tf_tile = tf.tile(tf_expand, [num_examples, 1, 1])  # 将第一维扩大为num_examples维  (?, hidden_dim, 1)
        out = tf.matmul(outputs, tf_tile) + self.b_out  # (?, seq_size, 1)
        print(out)
        out = tf.squeeze(out)
        return out
 
    def train(self, train_x, train_y):
        with tf.Session() as sess:
            tf.get_variable_scope().reuse_variables()  # 变量可重复利用
            sess.run(tf.global_variables_initializer())
            for i in range(1000):
                _, mse = sess.run([self.train_op, self.cost], feed_dict={self.x: train_x, self.y: train_y})
                if i % 100 == 0:
                    print(i, mse)
            save_path = self.saver.save(sess, './model')
            print('Model saved to {}'.format(save_path))
 
    def test(self, test_x):
        with tf.Session() as sess:
            tf.get_variable_scope().reuse_variables()
            self.saver.restore(sess, './model')
            output = sess.run(self.model(), feed_dict={self.x: test_x})
            return output

最后写一个main函数，用训练数据训练网络，并用测试数据测试

if __name__ == '__main__':
    predictor = SeriesPredictor(input_dim=1, seq_size=4, hidden_dim=10)
    train_x = [[[1], [2], [5], [6]],
               [[5], [7], [7], [8]],
               [[3], [4], [5], [7]]]
 
    train_y = [[1, 3, 7, 11],
               [5, 12, 14, 15],
               [3, 7, 9, 12]]
 
    predictor.train(train_x, train_y)
 
    test_x = [[[1], [2], [3], [4]],
              [[4], [5], [6], [7]]]
    test_y = [[[1], [3], [5], [7]],
              [[4], [9], [11], [13]]]
    pred_y = predictor.test(test_x)
 
    print("\n开始测试!\n")
 
    for i, x in enumerate(test_x):
        print("当前输入{}".format(x))
        print("应该输出{}".format(test_y[i]))
        print("训练模型的输出{}".format(pred_y[i]))

查看运行结果：

可以看到模型预测的结果与应该输入的结果是比较接近的。 在实际运用中，经常会调整一些参数，在不导致过拟合和欠拟合的条件下，使得网络模型更精确，比如加减神经元、调整网络层数、调整训练次数等。