Seq2seq LSTM тензор потока Impl

Question

Я пытаюсь реализовать базовый seq2seq rnn, используя lstm в Tensorflow.

Я знаю, что в Интернете существует множество учебных пособий, но большинство из них содержат результаты.
Эта модель должна прогнозировать следующий набор результатов n_predictions.
В качестве обучающих данных я предоставляю следующую последовательность:
[1,2,3,4] [5,6,7,8],...
в качестве выхода
[2,3,4,5][6,7,8,9], ...
Я хочу предсказать волну греха.
правильный вывод Но я получаю что-то вроде этого: мой вывод Где красная линия мои прогнозы

Я пытался изменить данные поезда на [1,2,3,4], [2,3,4,5] и вывести [2,3,4,5], [3,4,5,6], но модель ничего не изучает. MSE была похожа на случайные значения.

Что можно сделать, чтобы улучшить модель, чтобы она работала?

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import tensorflow.contrib.rnn as rnn

class Generator(object):
def __init__(self, funcY, funcZ, predict: int = 50, samples: int = 100, min: float = 0, max: float = 4):
  max *= np.pi*2
  step = (max-min)/(samples+predict)
  t = np.float32(np.arange(min, max, step))
  y = np.float32(funcY(t))
  z = np.float32(funcZ(t))
  self.t = t[0:samples]
  self.y = y[0:samples]
  self.ft = t[samples:samples+predict]
  self.fy = y[samples:samples+predict]
  self.batch_id = 0
def normalize(self, t):
  out = []
  for i in range(len(t)):
    out.append((t[i] - min(t))/(max(t)-min(t)))
  return np.asarray(out)
"""
As a train data function provided two sets of data, first and next
e.g.
current_data = [1,2,3,4,5],[6,7,8,9,10]
next_data = [2,3,4,5,6],[7,8,9,10,11]
"""
def getTrainData(self, steps, inputs, outputs, f_horizon):
  data = self.y
  data = np.asarray(data)
  current_data = data[:len(data)-f_horizon].reshape(-1, steps, inputs)
  next_data = data[f_horizon:len(data)].reshape(-1, steps, outputs)
  return current_data, next_data
"""
get the last steps of data
"""
def getTestData(self, steps, inputs):   
  return self.y[-steps:].reshape(-1,steps,inputs)
#network param
steps = 40
n_prediction = 80
n_samples = 800
n_inputs = 1
n_outputs = 1
n_layers = 2
f_horizon = 1
n_iterations = 2000
learning_rate = 0.001
n_hidden_units = 400
display_steps = 100

tf.reset_default_graph()

inputs = tf.placeholder(tf.float32, [None, steps, n_inputs])
outputs = tf.placeholder(tf.float32, [None,steps, n_outputs])

lstm_cells = [rnn.LSTMCell(num_units = n_hidden_units, forget_bias = 1.0, activation = tf.nn.leaky_relu) for _ in range(n_layers)]
stacked_lstm = rnn.MultiRNNCell(lstm_cells)
rnn_output, states = tf.nn.dynamic_rnn(cell = stacked_lstm, inputs = inputs, dtype=tf.float32)

stacked_rnn_output = tf.reshape(rnn_output, [-1,steps, n_hidden_units])
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_outputs)
output = tf.reshape(stacked_outputs, [-1, steps, n_outputs])

cost = tf.reduce_mean(tf.reduce_sum(tf.square(output - outputs)))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
training_op = optimizer.minimize(cost)

init = tf.global_variables_initializer()

    #generate data
generator = Generator(funcY = np.sin, funcZ = np.cos, predict = n_prediction, samples = n_samples + f_horizon, min = 1.0, max = 21.0)
#show data
plt.plot(generator.t, generator.y)
plt.plot(generator.ft, generator.fy, color='red', linestyle=':')
plt.show()
#generate test data
test_data = generator.getTestData(steps = steps, inputs = n_inputs)
print(test_data.shape)
#generate train data
current_data, next_data = generator.getTrainData(steps = steps, inputs = n_inputs, outputs = n_outputs, f_horizon = f_horizon)
print(current_data.shape)





with tf.Session() as sess:
  init.run()
  for i in range(0,n_iterations):
    sess.run(training_op, feed_dict={inputs: current_data, outputs: next_data})
    if i % display_steps == 0:
      mse = sess.run(cost, feed_dict={inputs: current_data, outputs: next_data})
      print(i,"\tMSE:",mse)
  prediction = []
  print(test_data.shape)
  for _ in range(0, n_prediction):
    test_data = sess.run(output, feed_dict={inputs: test_data})
    prediction = np.append(prediction, test_data.reshape(-1)[-1])

  prediction = np.asarray(prediction)
  print(prediction.shape)
  y_pred = prediction.reshape(-1)

  plt.plot(generator.t, generator.y, color='blue')
  plt.plot(generator.ft, generator.fy, color = 'cyan')
  plt.plot(generator.ft, y_pred, color='red', linestyle=":")
  plt.show()