Python实现LSTM股票预测阶段⼼得笔记
前⾔
large的反义词尝试阶段，本科课设，简易实现，应付期末，还在探索，欢迎交流
实现框架
TensorFlow
实验数据
来⾃⽼师给的CSV⽂件，共3000多⾏，每⾏包含字段如下：
avg_price clo amp_rate factor high_limit low_limit open quote_rate turnover turnover_rate volume 本次预测是就是基于上述字段，预测之后某⼀天的股票平均价格。
前置知识
LSTM
TensorFlow
tf.wiki/
TensorFlow中的张量、变量、占位
神经⽹络训练过程中的⼀些术语
Epoch：当⼀个完整的数据集通过了神经⽹络⼀次并且返回了⼀次，这个过程称为⼀个 epoch，epoch的数量表⽰对训练集迭代执⾏了多少次。
Batch：在不能将数据⼀次性通过神经⽹络的时候，就需要将数据集分成⼏个 batch。BATCH SIZE表⽰⼀个 batch 中的样本总数。
通常是在⼀个epoch中，有多个Batch通过神经⽹络模型，在⼀个Batch中，同时输⼊了多个样本进⼊神经⽹络模型。同时loss函数也是针对⼀批样本⽽⾔，也就是说神经⽹络通常是考虑令⼀批数据整体的误差最低。
Time Step：对于LSTM预测股票来说，时间步的⼤⼩决定了考虑多少天之前的数据进⾏训练和预测，例如Time Step设置为10，则表⽰⽤过去10天进⾏预测，此时每⼀批内的每⼀组样本应该包含10天的信息
关于tf.nn.dynamic_rnn与不同批的状态是否应该传递下去的问题
output_rnn,final_dynamic_rnn(cell, input_rnn,initial_state=init_state, dtype=tf.float32)
#output_rnn是记录lstm每个输出节点的结果，final_states是最后⼀个cell的结果
#dynamic_rnn是⼀套循环操作，输⼊初始和值和状态，返回最终的值和状态
#输⼊初始的值的shape=(batch_size,time_step,rnn_unit)，初始状态是h(batch_size,rnn_unit),c(batch_size,rnn_unit)，每批的每组都有对应的状态
#输出值:shape=(batch_size,time_step,rnn_unit)，因为每⼀组、每⼀个时间步、每⼀个细胞中都会有⼀个输出值
#输出状态:h(batch_size,rnn_unit),c(batch_size,rnn_unit) 每⼀组中的每⼀个细胞最后会得出⼀个状态值（h和c）,
#output_rnn与final_states的关系：output_rnn是每个时间步的输出组成的矩阵，对于output_rnn中⼀个时间步内的数据h来说，经过⼀次y=wh+b变化得到这个时间步输出的结果y
#output_rnn中每个时间步的输出就是这个时间步的状态h，这个h还将⽤于下⼀个时间步的输出与状态的计算，也就是说每⼀个时间步的状态(c,h)都由上⼀个时间步的输出h和本次时间步的输⼊x计算得到
#output_rnn最后⼀个时间步的输出等于final_states中的h
#对于⼀批数据⽽⾔(⼀批有好多组)，不同组数据的状态值是独⽴的，但是⼤家⽤的都是⼀套权重参数
#负向反馈的⽬标，是让loss尽可能低，这个loss是对⼀批数据(⼀批有很多组)的综合评价，修改后的权重参数并⾮让每⼀组的结果变的更好,⽽是让⼀批数据整体的结果变得更好
#如果不同批次内，同⼀组号的数据连接在⼀起结果是延时间的连续的，则final_states也应该feed进去，不考虑负向反馈的话，假如⼀共有n批数据，这样做等价于使⽤第⼀批数据并把时间步扩充了n倍的效果
#考虑负向反馈的话，这样做等价于，时间步扩充了n倍，但每次过固定数⽬的时间步就对之前⼀定数⽬的结果整体评估⼀下，然后更新权重参数
#相⽐于直接将时间步扩充了n倍，这样做准确度可能不如直接扩充，但是某⼀瞬间消耗的内存应该是⼩于直接扩充的，毕竟每次负向反馈的处理的权重参数少了很多
完整代码
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
#训练和预测
only_prediction=0
#数据常量
colnums=21
output_size=10
rows=3000
#神经⽹络常量
rnn_unit=20#hidden layer units
input_size=colnums-output_size
batch_size=5
time_step=10
epoch=2000
lr=0.0006#学习率
#其他常数
# model_path='./model'
model_path='./model2'
data_path='./datat.csv'
# 定义输⼊输出的w和b
wi = tf.Variable(tf.random_normal([input_size, rnn_unit]))
bi = tf.Variable(tf.random_normal(shape=[rnn_unit,], mean=0.0, stddev=1.0))
wo = tf.Variable(tf.random_normal([rnn_unit, output_size]))
bo = tf.Variable(tf.random_normal(shape=[output_size,], mean=0.0, stddev=1.0))
#导⼊数据
def import_data():
f=open(data_path)
ad_csv(f)#读⼊股票数据
data=df.iloc[:rows,:colnums].values
return data
#获取训练集广州西点培训
def get_train_data(data,train_begin=0,train_end=500):
batch_index=[]
data_train=data[train_begin:train_end]
train_x,train_y=[],[]#训练集
train_x,train_y=[],[]#训练集
for i in range(int(len(data_train)/time_step)):
if i % batch_size==0:
batch_index.append(i)
data = data_train[i*time_step:(i+1)*time_step,:]# 对每批中每组数据进⾏标准化
x=data[:,:colnums-output_size]
mean_an(x, axis=0)
std_x=np.std(x, axis=0)+0.1
x =(x - mean_x)/ std_x
y=data[:,colnums-output_size:colnums]
showgirl什么意思mean_an(y, axis=0)
std_y=np.std(y, axis=0)+0.1
y =(y - mean_y)/ std_y
train_x.list())
train_y.list())
return batch_index,train_x,train_y
#获取测试集
def get_test_data(data,test_begin=0,test_end=20):
data_test=data[test_begin:test_end]
test_x,test_y,mean,std=[],[],[],[]
for i in range(int(len(data_test)/time_step)):
x=data_test[i*time_step:(i+1)*time_step,:colnums-output_size]
mean_x = np.mean(x, axis=0)
std_x = np.std(x, axis=0)+0.1
x =(x - mean_x)/ std_x
mean_y, std_y =[],[]
for j in(range(output_size)):
mean_y.append(mean_x[0])
std_y.append(std_x[0])
mean.append(mean_y)
std.append(std_y)
高考答案
test_x.list())
test_y=data_test[:,0]
return test_x,test_y,mean,std
#定义模型
def RNN(cell,X,init_state):
#定义隐藏层的运算
shape(X,[-1,input_size])
input_rnn=tf.matmul(input,wi)+bi
input_shape(input_rnn,[-1,time_step,rnn_unit])
output_rnn,final_dynamic_rnn(cell, input_rnn,initial_state=init_state, dtype=tf.float32)#output_rnn是记录lstm每个输出节点的结果，final_stat es是最后⼀个cell的结果
shape(output_rnn,[-1,rnn_unit])#作为输出层的输⼊
pred=tf.matmul(output,wo)+bo
return pred,final_states
#开始训练
def train_data(train_begin=500,train_end=2500):
#读数据集，设置神经⽹络模型，准备X和Y，初始状态
batch_index, train_x, train_y = get_train_data(import_data(), train_begin, train_end)
cell = _cell.BasicLSTMCell(rnn_unit)
X = tf.placeholder(tf.float32, shape=[None, time_step, input_size])
Y = tf.placeholder(tf.float32, shape=[None, time_step, output_size])
init_state = _state(batch_size, dtype=tf.float32)
#构建计算图结点
pred, final_states=RNN(cell,X,init_state)
loss = tf.reduce_mean(tf.shape(pred,[-1,])- tf.reshape(Y,[-1,])))
train_op = tf.train.AdamOptimizer(lr).minimize(loss)
#声明保存模型需要⽤的对象
saver = tf.train.Saver(tf.global_variables(), max_to_keep=15)
#开始训练
ss = tf.Session()
ss.run(tf.global_variables_initializer())
for i in range(epoch):
for step in range(len(batch_index)-1):
feed_dict ={X: train_x[batch_index[step]:batch_index[step +1]],
Y: train_y[batch_index[step]:batch_index[step +1]]}
_, loss_, states = ss.run([train_op, loss, final_states],timeaftertime
feed_dict=feed_dict)
print( i, loss_)
if i %20==0:
print("保存模型：", saver.save(ss, model_path+'/del', global_step=i))
print("保存模型：", saver.save(ss, model_path, global_step=i))
ss.clo()会计培训班要多少钱
#预测
def prediction(test_begin=0,test_end=500):
#读数据集，配置X和初始状态
test_x, test_y,mean,std = get_test_data(import_data(), test_begin, test_end)
X=tf.placeholder(tf.float32, shape=[None,time_step,input_size])
cell = _cell.BasicLSTMCell(rnn_unit)
init_state = _state(1, dtype=tf.float32)
#构建计算图结点
pred, final_states=RNN(cell,X,init_state)
#配置读取模型需要⽤的对象
ain.Saver(tf.global_variables())
disciplines#开始预测
ss=tf.Session()
module_file = tf.train.latest_checkpoint(model_path)
test_predict=[]
for step in range(len(test_x)):
prob=ss.run(pred,feed_dict={X:[test_x[step]]})
test_predict.append(prob[len(prob)-1])
ss.clo
# acc = np.average(np.abs(test_predict - test_y) / test_y) # 偏差
# print(acc)
#以折线图表⽰结果
real=[]
pred=(np.array(test_predict)*std)+mean
plt.figure()
plt.plot(list(range(len(test_y))), test_y, color='r')
for step in range(0,len(test_predict)-1):
real.append(test_y[(step+1)* time_step:(step+1)* time_step + output_size])
plt.plot(list(range((step+1)* time_step,(step+1)* time_step + output_size)), pred[step], color='b', marker="v") acc = np.average(np.abs( pred[:len(real)]-np.array(real))/ np.array(real))# 偏差
print("acc", acc)
plt.show()
if only_prediction==0:
with tf.variable_scope('train'):
train_data(500,2000)
train_data(500,2000)
with tf.variable_scope('train', reu=True):
prediction(2500,3000)
el:生活大爆炸电视剧
with tf.variable_scope('train'):
韩国留学条件prediction(2500,3000)
经历与⼼得
起因
multipurpo
⼤三下学期软件⼯程的课设就是要求尝试使⽤RNN进⾏股票预测，我之前从未接触过Python和神经⽹络的相关知识，这次课设算是给了我⼀个学习的动⼒。
经过
我的学习路线是bp神经⽹络，RNN神经⽹络，Python，TensorFlow。bp神经⽹络是开启我神经⽹络⼤门的钥匙，我学习的过程中，我曾对神经⽹络持有⼀种怀疑的态度，原因是，我对神经⽹络的认知是采⽤了⼀种特殊的数据结构，运⽤逐步接近最优的算法，通过⼤量输⼊与输出样本，模拟输⼊与输出中的某种规律，这种数据结构就是神经元，所采⽤的算法就是构造误差函数，使⽤梯度下降令误差函数达到最⼩。
梯度下降是其实并不难理解，假设y=f(x)是⼀元连续函数，梯度下降就是不断令x=x+ny’，假如y是某定义域内的凹函数，我们知
道，y’=0的点是，该函数的极⼩值点，极⼩值点的左侧y’<0，⽽右侧y’>0，所以如果x梯度下降的起点在极⼩值点的左边，那么可见x 在逐步增加的，如果起点在在极⼩值点右边，则x会逐步减少，且这种变化的幅度会随函数导数⼤⼩⽽改变，导数⼤变化幅度也⼤，导数⼩，变化幅度也⼩，可以想象，对于凹函数给定任意起点，不断使⽤梯度下降，最终x会收敛在极⼩值点。
我们可以求出误差函数对某⼀参数的偏导数，然后不断⽤梯度下降修正这个参数，当这个误差函数收敛到⼀个值时，则说明误差函数的极⼩值点(并⾮严谨定义上的极⼩值)时，参数应该接近的当前值，此时输出结果与预期结果相差的最⼩。神经⽹络⽤它独有的数据结构定义了⼤量参数，对这些参数求偏导并梯度下降，使误差函数收敛到⼀个值。
RNN和LSTM也是⽤的这个道理，只不过RNN和LSTM把⼀组运算的输出也作为输⼊的⼀部分进⾏运算，通常这两组数据具有时间先后关系，RNN是将之前的数据全部作为参考，⽽LSTM⼜引⼊了⼀组参数，可以令之前部分参数作为参考，即模型具备了遗忘能⼒。
学完Python后，我开始学习Python，Python我感觉从某个⾓度来说，和JavaScript很像，虽然是第⼀次接触Python，但是对于软件⼯程的学⽣来说，只做到能读懂代码还是很轻松的，我很快就完成了Python学习阶段，只学会了基础的语法和特性，Python的代码真的很简洁，写起来⽐Java得劲多了，但是Python还有很多进阶技巧我没来得及学，这个⽇后⼀定要补上。
TensorFlow框架把模型都封装好了，不改模型的话，只需要⽤它的api把运算图构建出来就好了，这个过程还好，理解神经⽹络后很快就上⼿了，但是⼀些机器学习领域的术语很让我困扰，不过还是在不断实践和查阅资料的过程中搞明⽩了。
结果
课设完成了，准确率还⾏，只预测后⼀天的价格情况还好，越往后越跑偏，但是考虑到本⾝股票⼀天之内就没多⼤变化，所以这个准确率虽然⾼，但多少给⼈⼀点⾃欺欺⼈的感觉，说实话我不认为股票有什么规律可以⽤神经⽹络来模拟，股票作为⼀个多⼈博弈的过程，它很多影响因素在于外界，我认为单从历史数据预测未来不是很把握，所以对于这个准确率我还是蛮惊讶的，期末⼜和⽼师以及其他同学交流过，我这套代码只能说是实现了，在数据预处理和超参数调整⽅⾯还有进步空间，马上要考研了，近期可能不会有很多时间来改进了，待以后慢慢摸索学习吧
相对误差的平均值 0.03125852369012719
