Machine learning 基于tensorflow和python的价值预测

我有一个包含股票价格列表的数据集。我需要使用tensorflow和python来预测收盘价

Q1：我有以下代码，将前2000条记录作为训练，2001到20000条记录作为测试，但我不知道如何更改代码来预测今天和1天后的收盘价？？？请告知

#!/usr/bin/env python2

import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt

def feature_scaling(input_pd, scaling_meathod):
    if scaling_meathod == 'z-score':
       scaled_pd = (input_pd - input_pd.mean()) / input_pd.std()
    elif scaling_meathod == 'min-max':
       scaled_pd = (input_pd - input_pd.min()) / (input_pd.max() - 
    input_pd.min())
    return scaled_pd

def input_reshape(input_pd, start, end, batch_size, batch_shift, n_features):
    temp_pd = input_pd[start-1: end+batch_size-1]
    output_pd = map(lambda y : temp_pd[y:y+batch_size], xrange(0, end-start+1, batch_shift))
    output_temp = map(lambda x : np.array(output_pd[x]).reshape([-1]), xrange(len(output_pd)))
    output = np.reshape(output_temp, [-1, batch_size, n_features])
    return output

def target_reshape(input_pd, start, end, batch_size, batch_shift, n_step_ahead, m_steps_pred):
    temp_pd = input_pd[start+batch_size+n_step_ahead-2: end+batch_size+n_step_ahead+m_steps_pred-2]
    print temp_pd
    output_pd = map(lambda y : temp_pd[y:y+m_steps_pred], xrange(0, end-start+1, batch_shift))
    output_temp = map(lambda x : np.array(output_pd[x]).reshape([-1]), xrange(len(output_pd)))
    output = np.reshape(output_temp, [-1,1])
    return output

def lstm(input, n_inputs, n_steps, n_of_layers, scope_name): 
    num_layers = n_of_layers
    input = tf.transpose(input,[1, 0, 2])
    input = tf.reshape(input,[-1, n_inputs])  
    input = tf.split(0, n_steps, input)
    with tf.variable_scope(scope_name):
    cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=n_inputs) 
    cell = tf.nn.rnn_cell.MultiRNNCell([cell]*num_layers)
    output, state = tf.nn.rnn(cell, input, dtype=tf.float32)    yi1
    output = output[-1] 
    return output    

    feature_to_input = ['open price', 'highest price', 'lowest price', 'close price','turnover', 'volume','mean price']
    feature_to_predict = ['close price']
    feature_to_scale = ['volume']
    sacling_meathod = 'min-max'

    train_start = 1 
    train_end = 1000
    test_start = 1001
    test_end = 20000

    batch_size = 100
    batch_shift = 1
    n_step_ahead = 1
    m_steps_pred = 1
    n_features = len(feature_to_input)

    lstm_scope_name = 'lstm_prediction'
    n_lstm_layers = 1
    n_pred_class = 1
    learning_rate = 0.1
    EPOCHS = 1000
    PRINT_STEP = 100

    read_data_pd = pd.read_csv('./stock_price.csv')
    temp_pd = feature_scaling(input_pd[feature_to_scale],sacling_meathod)
    input_pd[feature_to_scale] = temp_pd
    train_input_temp_pd = input_pd[feature_to_input]
    train_input_nparr = input_reshape(train_input_temp_pd, 
    train_start, train_end, batch_size, batch_shift, n_features)

    train_target_temp_pd = input_pd[feature_to_predict]
    train_target_nparr = target_reshape(train_target_temp_pd, train_start, train_end, batch_size, batch_shift, n_step_ahead, m_steps_pred)

    test_input_temp_pd = input_pd[feature_to_input]
    test_input_nparr = input_reshape(test_input_temp_pd, test_start, test_end, batch_size, batch_shift, n_features)

    test_target_temp_pd = input_pd[feature_to_predict]
    test_target_nparr = target_reshape(test_target_temp_pd, test_start, test_end, batch_size, batch_shift, n_step_ahead, m_steps_pred)

    tf.reset_default_graph()

    x_ = tf.placeholder(tf.float32, [None, batch_size, n_features])
    y_ = tf.placeholder(tf.float32, [None, 1])
    lstm_output = lstm(x_, n_features, batch_size, n_lstm_layers, lstm_scope_name)

    W = tf.Variable(tf.random_normal([n_features, n_pred_class]))                                                                                                    
    b = tf.Variable(tf.random_normal([n_pred_class]))
    y = tf.matmul(lstm_output, W) + b
    cost_func = tf.reduce_mean(tf.square(y - y_))
    train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost_func)

    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
    init = tf.initialize_all_variables()        
    with tf.Session() as sess:
        sess.run(init)
        for ii in range(EPOCHS):
            sess.run(train_op, feed_dict={x_:train_input_nparr, y_:train_target_nparr})
            if ii % PRINT_STEP == 0:
               cost = sess.run(cost_func, feed_dict={x_:train_input_nparr, y_:train_target_nparr})
               print 'iteration =', ii, 'training cost:', cost

很简单，预测（也称为得分或推断）来自于仅通过向前传球运行输入，并收集每个输入向量的得分。这与测试的流程相同。不同之处在于模型使用的四个阶段：

培训：从培训数据集中学习；根据需要调整重量

测试：评估模型的性能；如果精度已经收敛，停止训练

验证：评估训练模型的准确性。如果它不符合验收标准，则更改某些内容并重新开始培训

预测：您已经通过了验证——发布模型供预期应用程序使用

所有四个步骤遵循相同的正向逻辑流程；培训包括反向传播；其他人没有。只需遵循“只向前”的流程，就可以得到所需的结果

---

我担心您的数据分区：只有10%用于培训，90%用于测试，没有用于验证。更典型的分割是50-30-20，或者一般区域中的某个值。

Q-1：您应该更改LSTM参数，以返回大小为2的序列，该序列将在当天和后天进行预测

---

Q-2很明显，你的模型就是数据，这在你10%的训练90%的测试数据中非常明显！您应该按照上一个答案中的建议，选择更均衡的比率。

非常感谢您的回答。因为我是tensorflow的新手。请您编辑代码以进行预测，例如3天后？如何进行验证？否；堆栈溢出不是代码编写服务。我给了你方法；你应该自己动手。如果它不起作用，发布一个关于特定编程问题的问题。谢谢你的评论。由于时间列被代码删除，我如何预测1天后的值？另一个问题是代码使用参数_to_input=[‘开盘价’、‘最高价’、‘最低价’、‘收盘价’、‘成交量’、‘平均价’]中的参数来预测a列的值，如未来的收盘价。但是，如果没有这些参数值，我怎么能预测未来的收盘价呢？显然，你不会：你训练你的模型预测未来两天的收盘价，作为一对值。首先，90是用于培训，10是用于测试。这个问题是一个很好的例子，说明像tensorflow这样的大型库对机器学习社区造成的损害。它们使库变得如此强大，以至于每个人都希望只需5行代码就能预测人类的未来（如果你知道怎么做，你也可以）。一个无所不知的人（即知道怎么做的人）甚至不需要5行代码就能预测人类的未来：）