使用MLP和Tensorflow预测时间序列值

Question

我很难设置一个多层感知器神经网络来预测使用Tensorflow的时间序列的下一个值。

我从文件中读取时间序列，将其分解为三个数组，并使用这些数组来训练，测试和验证网络。不幸的是，我的网络对我给它的每个输入都回答0.9999。

下图显示的值我希望我的网络的结果，请注意，它们的范围从2.8到4.2

现在，这些都是我的网络预测值。虽然它们看起来都是一样的，但它们实际上是0.9999 ...（并且在小数点后9位有一些差异）。

import csv 
import numpy as np 

from statsmodels.tsa.tsatools import lagmat 
import tensorflow as tf 

# Data split (values represent percentage) 
perc_train = 0.5 
perc_test = 0.4 
perc_eval = 0.1 

# Parameters 
learning_rate = 10 ** -3 
min_step_size_train = 10 ** -5 
training_epochs = 250 
display_step = 1 

# Network Parameters 
n_input = 15 
n_classes = 1 
n_hidden = (n_input + n_classes)/2 


def get_nn_sets(pmX, pmY): 
    ''' 
    Splits data into three subsets 
    ''' 
    trainningIndex = int(len(pmX) * perc_train) 
    validationIndex = int(len(pmX) * perc_test) + trainningIndex 

    pmXFit = pmX[:trainningIndex, :] 
    pmYFit = pmY[:trainningIndex] 

    pmXTest = pmX[trainningIndex:validationIndex, :] 
    pmYTest = pmY[trainningIndex:validationIndex] 

    pmxEvaluate = pmX[validationIndex:, :] 
    pmYEvaluate = pmY[validationIndex:] 

    return pmXFit, pmYFit, pmXTest, pmYTest, pmxEvaluate, pmYEvaluate 


def read_dollar_file(clip_first = 4000): 
    ''' 
    Reads the CSV file containing the dollar value for Brazilian real during the years 
    ----- 
    RETURNS: 
     A matrix with the file contents 
    ''' 

    str_vals = [] 
    with open('dolar.csv', 'rb') as csvfile: 
     spamreader = csv.reader(csvfile, delimiter=',') 
     for row in spamreader: 
      # retrieving the first column of the file (the dollar value) 
      str_vals.append(row[1]) 

    # removing title 
    str_vals = str_vals[1:] 
    # removing the empty strings (sunday and holidays have no values) 
    y = filter(None, str_vals) 
    # converting from string to float values 
    y = np.array(y).astype(np.float) 

    # checking if initial elements should be discarded 
    if (clip_first > 0): 
     y = y[clip_first:] 
    return y 

# Create model 
def get_multilayer_perceptron(x): 
    # Store layers weight & bias 

    weights = { 
     'h1': tf.Variable(tf.random_normal([n_input, n_hidden], dtype=tf.float64)), 
     'out': tf.Variable(tf.random_normal([n_hidden, n_classes], dtype=tf.float64)) 
    } 
    biases = { 
     'b1': tf.Variable(tf.random_normal([n_hidden], dtype=tf.float64)), 
     'out': tf.Variable(tf.random_normal([n_classes], dtype=tf.float64)) 
    } 
    # Hidden layer with relu activation 
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1']) 
    layer_1 = tf.nn.relu(layer_1) 
    # Output layer with tanh activation 
    out_layer = tf.matmul(layer_1, weights['out']) + biases['out'] 
    out_layer = tf.nn.tanh(out_layer) 
    return out_layer 

def run_mlp(inp, outp): 

    pmXFit, pmYFit, pmXTest, pmYTest, pmXEvaluate, pmYEvaluate = get_nn_sets(inp, outp) 

    # tf Graph input 
    x = tf.placeholder("float64", [None, n_input]) 
    y = tf.placeholder("float64", [None, n_classes]) 

    # Construct model 
    pred = get_multilayer_perceptron(x)  

    # Define loss and optimizer 
    cost = tf.nn.l2_loss(tf.sub(pred, y))   
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 

    # Initializing the variables 
    init = tf.initialize_all_variables() 

    # Launch the graph 
    with tf.Session() as sess: 
     sess.run(init) 

     # Training cycle 
     last_cost = min_step_size_train + 1 
     for epoch in range(training_epochs): 

      # Trainning data 
      for i in range(len(pmXFit)): 
       batch_x = np.reshape(pmXFit[i,:], (1, n_input)) 
       batch_y = np.reshape(pmYFit[i], (1, n_classes)) 

       # Run optimization 
       sess.run(optimizer, feed_dict={x: batch_x, y: batch_y}) 


      # Calculating data error 
      c = 0.0 
      for i in range(len(pmXTest)): 
       batch_x = np.reshape(pmXTest[i,:], (1, n_input)) 
       batch_y = np.reshape(pmYTest[i], (1, n_classes)) 

       # Run Cost function     
       c += sess.run(cost, feed_dict={x: batch_x, y: batch_y}) 

      c /= len(pmXTest) 
      # Display logs per epoch step 
      if epoch % display_step == 0: 
       print("Epoch:", '%04d' % (epoch+1), "cost=", \ 
        "{:.30f}".format(c))    

      if abs(c - last_cost) < min_step_size_train: 
       break 
      last_cost = c 

     nn_predictions = np.array([])   
     for i in range(len(pmXEvaluate)): 
      batch_x = np.reshape(pmXEvaluate[i,:], (1, n_input)) 
      nn_predictions = np.append(nn_predictions, sess.run(pred, feed_dict={x: batch_x})[0]) 

     print("Optimization Finished!") 

    nn_predictions.flatten() 
    return [pmYEvaluate, nn_predictions] 

inp = lagmat(read_dollar_file(), n_input, trim='both') 
outp = inp[1:, 0] 
inp = inp[:-1] 

real_value, predicted_value = run_mlp(inp, outp) 

我也尝试过不同的成本函数，并没有奏效。我知道我可能会错过一些非常愚蠢的事情，所以我非常感谢你的帮助。

感谢。

Answer 1

从代码：

out_layer = tf.nn.tanh(out_layer) 

tanh只能（-1.0,1.0）之间的输出值，删除此行会让它做的更好。