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

我在尝试设置多层感知器神经网络以使用 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) 

我也尝试了不同的成本函数，但没有用。我知道我可能遗漏了一些非常愚蠢的东西，所以非常感谢你的帮助。

谢谢。

请您参考如下方法:

来自您的代码:

out_layer = tf.nn.tanh(out_layer) 

tanh 只能输出(-1.0, 1.0)之间的值，去掉这一行会更好。