Tensorflow构建RNN做时间序列预测

最近比较空闲，刚好学习下Tensorflow和python，于是想写一个Tensorflow的小应用。

时间序列预测在预估企业营收，指标等方面使用的非常多。以前用R写过一个shiny的应用，就是用指数平滑、stl分解等方法做时间序列预测。RNN也是很早之前就接触过理论，是用来处理序列数据的利器。放一个普通RNN的示意图：

可以看到，t时刻RNN单元的输出是由t-1时刻单元的输出St-1和t时刻的训练数据xt共同决定的，用公式表示就是St=f(U*Xt+W*S(t?1))

现在比较常用的RNN单元是LSTM、GRU这些，上面那个原始的RNN使用不太多。为什么呢？

从直观的理解来看：1，原始的RNN记忆容量有限，随着时间间隔不断增大时，RNN会丧失学习到远处单元信息的能力。2，原始RNN是全盘接受了输入的信息，但有的信息可能是无用的。于是针对原始RNN的缺点发展出了LSTM——长短期记忆网络。先放一张它的结构示意图：

通常把LSTM单元成为细胞。LSTM使用”门“来选择性的让信息通过，遗忘或增加到细胞状态。还增加了长期记忆机制，就是图中细胞上面的那条横线。LSTM具体的工作原理可以参考这个讲的很详细点击打开链接。

Tensorflow中使用的需要关注的是LSTM的输入输出。输入就是训练数据（x，y）。LSTM的输出有两个h、c。h是真正的输出状态用来做后续的预测等等，c是细胞的记忆状态。

不说太多理论，直接上代码吧。这边训练数据使用的sin函数产生1000个点，time_step=5

1, 生成训练数据

import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.contrib import layers as tflayers
 
def generator(x):
 return [np.sin(i*0.06) for i in range(x)]
 
def rnn_data_format(data,timestep=7,label=False):
 data=pd.DataFrame(data)
 rnn_data=[]
 if label: ###label是二维数组，[样本数，1]
 for i in range(len(data) - timestep):
 rnn_data.append([x for x in data.iloc[i+timestep].as_matrix()])
 else: ###样本是3维数组[样本数，time_step，1]
 for i in range(len(data) - timestep):
 rnn_data.append([x for x in data.iloc[i:(i+timestep)].as_matrix()])
 return np.array(rnn_data,dtype=np.float32)
class DataSet(object):
 def __init__(self, x,y):
 self._data_size = len(x)
 self._epochs_completed = 0
 self._index_in_epoch = 0
 self._data_index = np.arange(len(x))
 self.x=x
 self.y=y
 
 def next_batch(self,batch_size):
 start=self._index_in_epoch
 if start+batch_size>=self._data_size :
 np.random.shuffle(self._data_index)
 self._index_in_epoch=0
 start=self._index_in_epoch
 end=self._index_in_epoch+batch_size
 self._index_in_epoch=end
 else:
 end = self._index_in_epoch + batch_size
 self._index_in_epoch = end
 batch_x,batch_y=self.get_data(start,end)
 return np.array(batch_x,dtype=np.float32),np.array(batch_y,dtype=np.float32)
 
 def get_data(self,start,end):
 batch_x=[]
 batch_y=[]
 for i in range(start,end):
 batch_x.append(self.x[self._data_index[i]])
 batch_y.append(self.y[self._data_index[i]])
 return batch_x,batch_y
 
##生成数据
x=generator(1000)
X=rnn_data_format(x,5)
y=rnn_data_format(x,5,label=True)
trainds = DataSet(X,y)

上面的代码用来生产训练数据，用sin函数生成了1000个数据点。rnn_data_format是为了生成[time_step, input]维度的数据。这里吧time_step设为5。因此可知，X的每一个样本是shape为[5,1]的矩阵，用来预测y，y的每一个样本shape为[1,1]。

上面还定义了一个做minibatch的class DataSet，为了生成训练的数据格式，其实就是比原来的X，y多了一个batchsize。trainds由两部分组成，x是shape=[batchsize,time_step, input]的矩阵在这里就是[batchsize,5,1]，y是shape=[batchsize,1]的矩阵。这个就是训练的时候需要输入的数据格式。

对应到前面的LSTM卡通图，也就是会有5个LSTM单元，分别接受输入的5个时序位点上的X。需要的结果是最后一个LSTM单元的输出。但一般不会直接用LSTM的结果作为预测值，LSTM的结果是一个[batchsize, hiddensize]的Tensor，所以后面至少需要加一个回归得到预测值。我在是加了2个全连接和1个回归，用来预测y。

2，构建网络

构建多层LSTM，LSTM的输出接全连接层，然后回归计算得到结果

def weight_variable(shape): ###这里定义的是全连接的参数w
 initial = tf.truncated_normal(shape, stddev=0.1)
 return tf.Variable(initial)
 
def bias_variable(shape): ###这里定义的是全连接的参数b
 initial = tf.constant(0.1, shape=shape)
 return tf.Variable(initial)
 
def lstm_cell3(model='lstm',rnn_size=[128,128],keep_prob=0.8): ###定义LSTM层
 if model=='lstm':
 cell_func=tf.contrib.rnn.BasicLSTMCell
 elif model=='gru':
 cell_func=tf.contrib.rnn.GRUCell
 elif model=='rnn':
 cell_func=tf.contrib.rnn.BasicRNNCell
 cell=[]
 for unit in rnn_size: ###定义多层LSTM
 cell.append(tf.contrib.rnn.DropoutWrapper(cell_func(unit, state_is_tuple = True),output_keep_prob=keep_prob)) ###使用的dropout
 return tf.contrib.rnn.MultiRNNCell(cell,state_is_tuple=True)
 
def dnn_stack(input,layers): ###全连接层使用tflayers里面的stack，这样不用自己手动写连接
 if layers and isinstance(layers, dict):
 dnn_out=tflayers.stack(input, tflayers.fully_connected,
 layers['layers'],
 activation_fn=layers.get('activation')
 )
 elif layers:
 dnn_out= tflayers.stack(input, tflayers.fully_connected, layers)
 W_fc1 = weight_variable([layers['layers'][-1], 1])
 b_fc1 = bias_variable([1])
 pred=tf.add(tf.matmul(dnn_out,W_fc1),b_fc1,name='dnnout') ###dnn的输出结果和label对应是一个数字
 return pred

在构建网络的过程中对于我这个新手来说有不少的坑，这里说几个印象深刻的：

1，构建多层LSTM的方式。我这里使用的是for循环，每一层单独设置rnn_size也就是隐含层的结点数。一开始参考网上的代码是另一种写法。就是每一层的节点数都一样，要设计几层就用num_layers参数。构建的时候直接用LSTM单元*num_layers。

def lstm_cell(model = 'lstm', rnn_size = 128, num_layers = 2, keep_prob=0.8):
 if model=='lstm':
 cell_func=tf.contrib.rnn.BasicLSTMCell
 elif model=='gru':
 cell_func=tf.contrib.rnn.GRUCell
 elif model=='rnn':
 cell_func=tf.contrib.rnn.BasicRNNCell
 cell=cell_func(rnn_size, state_is_tuple = True)
 return tf.contrib.rnn.MultiRNNCell(
 [tf.contrib.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)]*num_layers,
 state_is_tuple=True)

看起来这样的方式也没问题，可是一运行就报错，维度不匹配。后来google之，有人碰到过同样的问题点击打开链接

大概的意思是[LSTM单元]*layers的方式是将LSTM单元做复制，所以参数维度是完全一致的。而for循环构建的多层LSTM是独立的每层有自己的参数。在我构建时间序列数据的时候，第一个LSTM单元的输入数据是[5,1]，输出[5,hiddensize]。第二个单元的输入就变成了[5,hiddensize]，输出[5,hiddensize]。明显输入的参数维度是不一样的，所以会报错。除非把第一个LSTM单元的输入也改成[5,hiddensize]

2，全连接的构建。使用tflayers还是挺方便的，用法和keras很像，是一个比较高级的API。使用的时候只需要把注意放在输入输出和function的参数上。不过非核心的Tensorflow函数不同的版本变化挺大的（其实要说起来Tensorflow中基础的函数变化也挺大的。。。）。一开始也是参考网上的代码，发现好多参数都不能用了，activation，dropout什么的都不能用。然后看源代码，stack是调用了layer函数，layer函数能用的参数是下面截图的那些。所以activation现在的参数名字变成了activation_fn。可是dropout呢？还是不在参数里面啊，后来发现dropout变成了一个单独的函数。这个估计也是模仿keras？

3，定义损失函数，梯度

input_data=tf.placeholder("float", shape=[None, 5,1])
input_label=tf.placeholder("float", shape=[None, 1])
###定义LSTM
rnncell=lstm_cell() 
initial_state = rnncell.zero_state(batch_size, tf.float32)
output, state = tf.nn.dynamic_rnn(rnncell, inputs=input_data, initial_state=initial_state, time_major=False) ##LSTM的结果
###LSTM结果输入dnn
dnn_out=dnn_stack(output[:,-1,:],layers={'layers':[32,16]}) ##
loss=tf.reduce_sum(tf.pow(dnn_out-input_label,2)) ##平方和损失
learning_rate = tf.Variable(0.0, trainable = False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(loss, tvars), 5) ##计算梯度
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.apply_gradients(zip(grads, tvars))

构建好LSTM后需要给它一个初始值，一般用0有一些特别的模型会把初始值放进模型里做训练。需要注意的是初始值需要参数batch_size，这个玩意坑了我一把。在训练的时候我是设了batchsize=32的，后来拿训练好的模型做预测是没有batchsize的，然后没把batchsize改过来于是一直报错。不过initial_state这个参数在tf.nn.dynamic_rnn不是必需的，可以不设置这样就避免出现我上面的尴尬了。

这里比较重要的是要弄清楚LSTM的输出，这里使用的是tf.nn.dynamic_rnn。在别人的代码里可能还会看到tf.contrib.rnn.static_rnn。这个函数在最新的Tensorflow中已经没有了，在1.1版本里是有的。tf.nn.dynamic_rnn默认的输入数据tensor就是上面我们定义的[batchsize,timestep,input]，参数time_major可以用来控制输入形式，True时输入tensor为[timestep,batchsize,input]。有说法timestep放再第一维训练速度会更快，我没有验证不知道真假。

上面在介绍LSTM的时候说了输入有h（单元的输出），c（长期记忆）两个。h就是对应代码里面的output。output里面保存着的是最后一层LSTM每一个单元的输出结果，shape为[batchsize,timestep,hiddensize]，state里面保存的是最后一个单元的输出和长期记忆状态，shape均为[batchsize,hiddensize]。官网上也有介绍：

所以要取出最后一个LSTM单元的输出结果的话就是output[:,-1,:]或者state[-1][1]。需要注意的是state会存下每一层LSTM的最后一个单元的状态，所以构建了多少层LSTM就有多少层的状态，state[-1]就是最后一层的状态。而output只有输出层也就是最后一层的输出结果。

需要做回归所以选了平方和损失，然后tf.gradient计算梯度，在tf.gradient前面还套了一层clip_by_global_norm，它的作用是将梯度限制在一个范围内，防止出现梯度消失或者梯度爆炸。使用了clip_by_global_norm的更新公式：

t_list[i] * clip_norm /max(global_norm, clip_norm)

clip_norm是人为设置的一个参数，上面的代码里面设置为5，global_norm是所有参数梯度平方和开根号。从公式来看它最大的作用其实是防止梯度太大的时候引起震荡。梯度越大t_list乘以的缩放因子越小，而当梯度小于clip_norm的时候其实就是直接更新梯度，缩放因子等于1了。

训练和预测过程下一篇写吧。

第二篇链接，训练和预测：https://blog.csdn.net/zhxchstc/article/details/79268839