tensorflow seq2seq 预测sin（x）

问题定义：seq2seq是否可以找到时序数据中的周期性呢？说实话刚开始感觉应该是不可以的。但实验结果表明还好。
定义：

T=np.arange(2000)*0.05
X=np.sin(T)*10

这样X大概长这样：

image.png

为了增加挑战的趣味性，我们让训练集的trainX的长度是不固定的：为[1000，1600)的随机数。trainY就是trainX接下来的200个。

我们的目标就是看看，通过这样的训练，能否让神经网络以X的前1800个数为输入，来预测出之后的200个。

直接上代码

'''
Created on 2019年2月25日

@author: xiezhipu
'''

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.layers import core as layers_core
import sonnet as snt

config = tf.ConfigProto()
 
# 配置GPU内存分配方式，按需增长，很关键
config.gpu_options.allow_growth = True
 
# 配置可使用的显存比例
config.gpu_options.per_process_gpu_memory_fraction = 0.1

T=np.arange(2000)*0.05
X=np.sin(T)*10

YLEN=200

print(YLEN)

def generateTrain(records=1000):
    trainXs=[]
    trainYs=[]
    XLens=[]
    YLens=[]
    for i in range(records):
        xi=X[:1800].copy()
        sepre=np.random.randint(1000,1600)
        xi[sepre::]=0
        yi=X[sepre:sepre+YLEN].copy()
        trainXs.append(np.expand_dims(xi,axis=0))
        trainYs.append(np.expand_dims(yi,axis=0))
        XLens.append(sepre)
        YLens.append(YLEN)
    trainX=np.concatenate(trainXs,axis=0)
    trainY=np.concatenate(trainYs,axis=0)
    seqLen=np.array(XLens)
    outLen=np.array(YLens)
    return (trainX,trainY,seqLen,outLen)

def generateTest():
    xi=X[:1800].copy()
    yi=X[1800:1800+YLEN].copy()
    testX=np.expand_dims(xi, axis=0)
    testY=np.expand_dims(yi, axis=0)
    seqLen_test=np.array([1800])
    outLen_test=np.array([YLEN])
    return (testX,testY,seqLen_test,outLen_test)

x=tf.placeholder(tf.float32, [None,1800])

yTrue=tf.placeholder(tf.float32,[None,YLEN])

seq_len=tf.placeholder(tf.float32,[None,])

out_len=tf.placeholder(tf.int32,[None,])

cell = tf.contrib.rnn.BasicLSTMCell(num_units=8)

x_exp=tf.expand_dims(x,-1)

outputs, encoder_state = tf.nn.dynamic_rnn(
    cell=cell,
    dtype=tf.float32,
    sequence_length=seq_len,
    inputs=x_exp)

# Build RNN cell
decoder_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=8)

#output_layer = layers_core.Dense(self.num_emb, use_bias=False)

decoder_emb_inp=tf.expand_dims(yTrue,-1)

#decoder_lengths=tf.ones(1000)*200

output_layer = layers_core.Dense(1, use_bias=True)

# Helper
helper = tf.contrib.seq2seq.TrainingHelper(
    outputs, out_len)
# Decoder
decoder = tf.contrib.seq2seq.BasicDecoder(
    decoder_cell, helper, encoder_state,
    output_layer=output_layer)
# Dynamic decoding

outputs = tf.contrib.seq2seq.dynamic_decode(decoder)

outputs = tf.squeeze(outputs[0][0])

lossfun=tf.reduce_mean(tf.square(outputs-yTrue))

train_step=tf.train.AdamOptimizer(learning_rate=0.015).minimize(lossfun)

#logits = outputs.rnn_output

testX,testY,seqLen_test,outLen_test=generateTest()

plt.ion() #开启interactive mode
plt.plot(testY[0])
plt.pause(1)
#plt.show()

with tf.Session(config = config) as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    for i in range(int(1e5)):
        trainX,trainY,seqLen,outLen=generateTrain()
        _,loss = sess.run([train_step,lossfun],feed_dict={x:trainX,yTrue:trainY,seq_len:seqLen,out_len:outLen})
        print(loss)
        if i%100==99:
            res,loss=sess.run([outputs,lossfun],feed_dict={x:testX,yTrue:testY,seq_len:seqLen_test,out_len:outLen_test})
            print(res.shape)
            print(res)
            print(loss)
            plt.figure()
            plt.plot(testY[0])
            plt.plot(res)
            plt.pause(1)
            plt.savefig('res'+str(i)+'.png')

效果图：

image.png

蓝的是真实值，橙色是预测值。

各位帮忙看看，代码有问题，或者设定有问题，请指出来，多谢