RNN之seq2seq模型_rnn seq2seq

1.RNN模型概述

RNN大致可以分为4种,输出和输入序列不同数量rnn可以有多种不同的结构，不同结构自然就有不同的引用场合。

如下图所示：

one to one 结构: 仅仅只是简单的给一个输入得到一个输出，此处并未体现序列的特征，例如图像分类场景。
one to many 结构:给一个输入得到一系列输出，这种结构可用于生产图片描述的场景。
many to one 结构: 给一系列输入得到一个输出，这种结构可用于文本情感分析，对一些列的文本输入进行分类，看是消极还是积 极情感。
many to many 结构: 给一些列输入得到一系列输出，这种结构可用于翻译或聊天对话场景，对输入的文本转换成另外一些列文本。
同步 many to many 结构: 它是经典的rnn结构，前一输入的状态会带到下一个状态中，而且每个输入都会对应一个输出，我们最熟悉的就是用于字符预测了，同样也可以用于视频分类，对视频的帧打标签。

2.seq2seq 简介

     seq2seq是一个重要的RNN变种，属于many to many。同时这种结构又叫Encoder-Decoder模型。原始的N vs N RNN要求序列等长，然而我们遇到的大部分问题序列都是不等长的，如机器翻译中，源语言和目标语言的句子往往并没有相同的长度。

    为此，我们先用Encoder 将输入编码映射到语义空间(下图左侧部分)，得到一个个固定维数的向量（下图C），这个向量就表示输入的语义。然后我们使用Decoder进行解码，便获得所需的输出。

  它的特点很明显，就是不限制输入输出，故有很广泛的应用。如机器翻译，智能对话等。

3. seq2seq预测股票

我们利用seq2seq对股票收盘价进行了预测，关于代码的详细说明，参见注释，需要数据的同学可以加我qq,请备注csdn_seq2seq。

# -*- coding: utf-8 -*-
"""
seq2seq  stock
"""
        
import tensorflow as tf 
import numpy as np
import matplotlib.pyplot as plt  
import pandas as pd
 
 
 
'''
1.样本数据产生
'''
#pandas 链式赋值警告：a=b=c=1,凡事出现链式赋值的情况，
#pandas都是不能够确定到底返回的是一个引用还是一个拷贝。 所以遇到这种情况就干脆报warning
pd.options.mode.chained_assignment = None  # default='warn'
def loadstock(window_size):
    names = ['date', #日期
         'code', #股票代码
         'name', #名字
         'Close', # 收盘价
         'top_price', #最高价
         'low_price', #最低价
         'opening_price', #开盘价
         'bef_price',
         'floor_price',
         'floor',
         'exchange',
         'Volume',
         'amount',
         '总市值',
         '流通市值']
    data = pd.read_csv('600000.csv', names=names, header=None,encoding = "gbk")
    #predictor_names = ["Close",'top_price',"low_price","opening_price"]
    predictor_names = ["Close"] #预测收盘价，当然可以用来预测多个
    training_features = np.asarray(data[predictor_names], dtype = "float32")#asarray,不占内存等同于array
    kept_values = training_features[1000:] #取1000以后的
 
    X = [] ##  x ；前window_size天，输入数据
    Y = [] #y后window_size天 作为标注结果
    for i in range(len(kept_values) - window_size * 2):
        X.append(kept_values[i:i + window_size]) #每一组40个
        Y.append(kept_values[i + window_size:i + window_size * 2])
 
    X = np.reshape(X,[-1,window_size,len(predictor_names)]) #len(predictor 可能是要预测多个时候有用
    Y = np.reshape(Y,[-1,window_size,len(predictor_names)])
    print(np.shape(X))
    return X, Y
 
X_train = []
Y_train = []
X_test = []
Y_test = []
 
def generate_data(isTrain, batch_size):        
    # 生成40个样本，预测后40个样本  
    seq_length = 40     #window_size
    seq_length_test = 80
 
    global Y_train
    global X_train
    global X_test
    global Y_test
    # 训练集
    if len(Y_train) == 0:       
        X, Y= loadstock( window_size=seq_length)
        #X, Y = normalizestock(X, Y)
        # Split 80-20:
        X_train = X[:int(len(X) * 0.8)]
        Y_train = Y[:int(len(Y) * 0.8)]
 
    #测试集
    if len(Y_test) == 0:
        X, Y  = loadstock( window_size=seq_length_test) #测试集为什么用80？
        #X, Y = normalizestock(X, Y)
        X_test = X[int(len(X) * 0.8):]
        Y_test = Y[int(len(Y) * 0.8):]
 
    if isTrain:
        return do_generate_x_y(X_train, Y_train, batch_size)
    else:
        return do_generate_x_y(X_test,  Y_test,  batch_size)
 
 
def do_generate_x_y(X, Y, batch_size):
    #在没完善一个程序之前，我们不知道程序在哪里会出错，与其让它在运行最崩溃，
    #不如在出现错误条件时就崩溃，这时候就需要assert断言的帮助。能起到提前报错的作用
    assert X.shape == Y.shape, (X.shape, Y.shape) #如果这里不等于，则直接报错就不执行下去了
    idxes = np.random.randint(X.shape[0], size=batch_size) #产生随机整数，不相等的
    X_out = np.array(X[idxes]).transpose((1, 0, 2))  #0,1，列互换,输出数据：[batch_size，windows_size,value]
    Y_out = np.array(Y[idxes]).transpose((1, 0, 2))  # ------->[windows_size,batch_szie,value ]
    return X_out, Y_out    #是训练需要吗？
 
    
        
sample_now, sample_f = generate_data(isTrain=True, batch_size=3)
print("training examples : ")
print(sample_now.shape)
print("(seq_length, batch_size, output_dim)")
 
 
 
'''
2. 定义模型框架
'''
seq_length = sample_now.shape[0]
batch_size = 100
 
output_dim = input_dim = sample_now.shape[-1] #decoder输出维度，需要预测一个就输出一个就好了，需要预测的就一个
hidden_dim = 12  #每一层有12个gru
layers_num = 2 #两层
 
 
#Optmizer:
learning_rate =0.04
nb_iters = 10000
lambda_l2_reg = 0.003  # L2正则化系数
        
tf.reset_default_graph()
encoder_input = [] #encoder 输入
expected_output = [] #中间，在feed_dict中间输入进去
decode_input =[] #decode输出
 
#占位符，encoder,middle,decode
for i in range(seq_length):#windows_size个占位符，每个占位符里面是数据
    encoder_input.append( tf.placeholder(tf.float32, shape=( None, input_dim))) #[40,bacht_size,1]的占位符
    expected_output.append( tf.placeholder(tf.float32, shape=( None, output_dim)) )
    decode_input.append( tf.placeholder(tf.float32, shape=( None, input_dim)) )
 
#定义网络结构 ，seq2seq   
tcells = [] #定义了两层循环网络，每层12个GRUcell
for i in range(layers_num):
    tcells.append(tf.contrib.rnn.GRUCell(hidden_dim))
 
#多层RNN实现    
Mcell = tf.contrib.rnn.MultiRNNCell(tcells)
dec_outputs, dec_memory = tf.contrib.legacy_seq2seq.basic_rnn_seq2seq(encoder_input,decode_input,Mcell)
 
#最后结果全连接输出???? 没看太懂
reshaped_outputs = []
for ii in dec_outputs :
    reshaped_outputs.append( tf.contrib.layers.fully_connected(ii,output_dim,activation_fn=None))
 
#损失函数计算，均方差（x-y）^2
output_loss = 0
for _y, _Y in zip(reshaped_outputs, expected_output):
    output_loss += tf.reduce_mean( tf.pow(_y - _Y, 2) )
 
# 正则项,l2正则项
reg_loss = 0
for tf_var in tf.trainable_variables():
    if not ("fully_connected" in tf_var.name ):
        #print(tf_var.name)
        reg_loss += tf.reduce_mean(tf.nn.l2_loss(tf_var))
loss = output_loss + lambda_l2_reg * reg_loss
train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss)   
 
 
'''
3.训练模型，可视化loss
'''
#seq_2_seq的输入是一个list,需要构建一个list(encoder_input,except_input,decode_input)，
#按照这个时间顺序放入，可以不抢位置
sess = tf.InteractiveSession()       
def train_batch(batch_size):
    
    X, Y = generate_data(isTrain=True, batch_size=batch_size) #[40,100.1]
    #这里是赋值操作
    feed_dict = {encoder_input[t]: X[t] for t in range(len(encoder_input))} # 40 组 每一组长100个
    feed_dict.update({expected_output[t]: Y[t] for t in range(len(expected_output))}) #80组
    #dict.update(dict2) dict.update(dict) 用法
    #decode_input的输入重要说明，将其第一列输入变为零，做为初始输入的标记，接上未来序列。
    #Y的最后一列并没有作为decoder的输入
    c =np.concatenate(( [np.zeros_like(Y[0])],Y[:-1]),axis = 0)#c [40,100,1]
    feed_dict.update({decode_input[t]: c[t] for t in range(len(c))}) #decoder数据喂入 #100组
    _, loss_t = sess.run([train_op, loss], feed_dict)
    return loss_t
 
 
def test_batch(batch_size):
    X, Y = generate_data(isTrain=True, batch_size=batch_size)
    feed_dict = {encoder_input[t]: X[t] for t in range(len(encoder_input))} #encoder_input
    feed_dict.update({expected_output[t]: Y[t] for t in range(len(expected_output))})#实际值
    
    #[np.zeros_like(Y[0])],100个0，其他Y分别往后面移动一位,构成新的c
    c =np.concatenate(( [np.zeros_like(Y[0])],Y[:-1]),axis = 0)
    feed_dict.update({decode_input[t]: c[t] for t in range(len(c))})    
    output_lossv,reg_lossv,loss_t = sess.run([output_loss,reg_loss,loss], feed_dict)
    print("-----------------")    
    print(output_lossv,reg_lossv)
    return loss_t
 
 
# Training
train_losses = []
test_losses = []
 
sess.run(tf.global_variables_initializer())
for t in range(nb_iters + 1):
    train_loss = train_batch(batch_size)
    train_losses.append(train_loss)
    if t % 200 == 0:
        test_loss = test_batch(batch_size)
        test_losses.append(test_loss)
        print("Step {}/{}, train loss: {}, \tTEST loss: {}".format(t,nb_iters, train_loss, test_loss))
print("Fin. train loss: {}, \tTEST loss: {}".format(train_loss, test_loss))        #最终结果
        
              
# 画损失函数
#test 损失
plt.figure(figsize=(12, 6))#画布大小
plt.plot(np.array(range(0, len(test_losses))) /
    float(len(test_losses) - 1) * (len(train_losses) - 1), 
    #应为test_loss并不是每次都进行了计算，整200的计算，故把横坐标映射到那么长去
    np.log(test_losses),label="Test loss")
 
#训练损失，随着时间迭代
plt.plot(np.log(train_losses),label="Train loss")
plt.title("Training errors over time (on a logarithmic scale)")
plt.xlabel('Iteration')#横坐标迭代次数
plt.ylabel('log(Loss)')#纵坐标对数误差
plt.legend(loc='best')
plt.show()        
 
 
'''              
#4.用训练好的模型， 随机选取5次进行预测，并且可视化结果
'''
nb_predictions = 5
print("visualize {} predictions data:".format(nb_predictions))
 
preout =[]
X, Y = generate_data(isTrain=False, batch_size=nb_predictions)
print(np.shape(X),np.shape(Y))
for tt in  range(seq_length):
    feed_dict = {encoder_input[t]: X[t+tt] for t in range(seq_length)}
    feed_dict.update({expected_output[t]: Y[t+tt] for t in range(len(expected_output))})
    c =np.concatenate(( [np.zeros_like(Y[0])],Y[tt:seq_length+tt-1]),axis = 0)  #从前15个的最后一个开始预测  
 
    feed_dict.update({decode_input[t]: c[t] for t in range(len(c))})
    outputs = np.array(sess.run([reshaped_outputs], feed_dict)[0])
    preout.append(outputs[-1])
 
print(np.shape(preout)) #将每个未知预测值收集起来准备显示出来。
preout =np.reshape(preout,[seq_length,nb_predictions,output_dim])
 
for j in range(nb_predictions):
    plt.figure(figsize=(12, 3))
    for k in range(output_dim):
        past = X[:, j, k]
        expected = Y[seq_length-1:, j, k]#对应预测值的打印
 
        pred = preout[:, j, k]
 
        label1 = "past" if k == 0 else "_nolegend_"
        label2 = "future" if k == 0 else "_nolegend_"
        label3 = "Pred" if k == 0 else "_nolegend_"
        plt.plot(range(len(past)), past, "o--b", label=label1)
        plt.plot(range(len(past), len(expected) + len(past)),
                 expected, "x--b", label=label2)
        plt.plot(range(len(past), len(pred) + len(past)),
                 pred, "o--y", label=label3)
 
    plt.legend(loc='best')
    plt.title("Predictions vs. future")
    plt.show()
 
      
        
        
        
        
        
        
        
        
        
        
        
        
        

4.结果展示

图 一

图1为训练中loss值的变化，当然，在可视化时，我们取了对数。

图二

图二，我们使用训练好的模型，随机抽取了一部分数据，用来它的预测股票收盘价，并了相关对比。发现预测还是相对准确的。

在上面代码中，我们画了5张图，这里只上传了一张。