LSTM模型简介
LSTM是循环神经网络的一种，它具有长短时记忆的能力，克服了传统RNN在输入序列较长时产生的遗忘问题（即梯度消失）。LSTM通过三个分别称为遗忘门、输入门和输出门的结构控制信息的输入输出。LSTM有两个状态h(隐藏状态)和c(细胞状态)，h控制短期记忆，c控制长期记忆。
其结构示意图为：
其各个门的数学表达为：
其中小圆圈表示哈达玛乘积。
最后，再总结一下各个门的客观意义：
遗忘门：控制上个细胞状态有多少信息被保留
输入门：控制当前的输入信息有多少被保留
输出门：控制当前输出有多少信息值得保留
数据集
股票数据总共有九个维度，分别是
由于本人对经济学没有太多研究，所以这些各个维度所代表的信息我也不是很清楚，但在我眼里，它们就是一堆时序数据，而长短时记忆时序模型LSTM处理时序数据具有很强的优势。
项目数据(存储格式是excel)：https://pan.baidu.com/s/1qcqCDAATaHapMOs2I_qr6A
提取码：1346
然后我们来简单观察一下数据集的分布。使用pandas库读取excel文件后，将其转换为numpy数组，简单剔除掉代号、日期之类的无用数据后，利用绘图库matplotlib将各个维度的数据分布绘制出来，程序如下：
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
#check train data and test data
train_data = pd.read_excel('train_data.xlsx',index_col=0)
train_arrs = np.array(train_data.iloc[:,:])
trains = train_arrs[:,-9:].astype('float32')
test_data = pd.read_excel('test_data.xlsx',index_col=0)
test_arrs = np.array(test_data.iloc[:,:])
tests = test_arrs[:,-9:].astype('float32')
dim_names = ['open','high','low','close','pre_close','change','pct_chg','vol','amount']
#normalize
for dim in range(trains.shape[1]):
trains[:,dim] = (trains[:,dim] - trains[:,dim].min()) / (trains[:,dim].max() - trains[:,dim].min())
for dim in range(tests.shape[1]):
tests[:,dim] = (tests[:,dim] - tests[:,dim].min()) / (tests[:,dim].max() - tests[:,dim].min())
#visualization of train data
for dim in range(trains.shape[1]):
plt.subplot(3,3,dim+1)
plt.plot(trains[:,dim])
plt.title('%s'%(dim_names[dim]))
plt.show()
#visualization of test data
for dim in range(tests.shape[1]):
plt.subplot(3,3,dim+1)
plt.plot(tests[:,dim])
plt.title('%s'%(dim_names[dim]))
plt.show()
效果如下：
对于训练集：
对于测试集：
可以简单看出，各个维度并不是相互独立的，有些分布具有很强的相似性。
接着，我们来创建train_batches和test_batches以训练模型。这里用到的技巧其实不多，有一点提一下，对于数据集使用归一化能加快模型的收敛以及抑制梯度爆炸。然后要注意这是预测模型，不是回归模型，模型的输入是前n个time step的由各个维度构成的向量组，输出的是下个time step的包含各个维度的向量，说起来有点绕，我作了一个简单的示意图，希望能理清你们的思路：
从shape的角度理解的话，那么输入数据的shape为[BATCH_SIZE,TIME_STEP,INPUT_DIM]。输出数据的shape为[BATCH_SIZE,INPUT_DIM]
说明一下，该项目的预测只是对于开盘价，也就是’open’这个维度，所以实际的输出数据的shape为[BATCH_SIZE,1]
创建train/test batches的代码如下：
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
#读取训练数据
train_data = pd.read_excel('train_data.xlsx',index_col=0)
train_arrs = np.array(train_data.iloc[:,:])
train_xs = train_arrs[:,-8:].astype('float32')
train_ys = (np.array(train_data['open'],dtype='float32')).reshape(-1,1)
#读取测试数据
test_data = pd.read_excel('test_data.xlsx',index_col=0)
test_arrs = np.array(test_data.iloc[:,:])
test_xs = test_arrs[:,-8:].astype('float32')
test_ys = (np.array(test_data['open'],dtype='float32')).reshape(-1,1)
#归一化
train_ys = (train_ys-train_ys.min()) / (train_ys.max() - train_ys.min())
test_ys = (test_ys-test_ys.min()) / (test_ys.max() - test_ys.min())
for dim in range(train_xs.shape[1]):
train_xs[:,dim] = (train_xs[:,dim] - train_xs[:,dim].min()) / (train_xs[:,dim].max() - train_xs[:,dim].min())
for dim in range(test_xs.shape[1]):
test_xs[:,dim] = (test_xs[:,dim] - test_xs[:,dim].min()) / (test_xs[:,dim].max() - test_xs[:,dim].min())
#由于是预测任务，那么数据的第一个维度会少掉一个time_step-1
time_step = 8
input_dim = 8
aranged_train_xs = np.zeros(shape=(train_xs.shape[0]-time_step+1,time_step,input_dim))
for idx in range(aranged_train_xs.shape[0]):
aranged_train_xs[idx] = train_xs[idx:idx+8]
aranged_test_xs = np.zeros(shape=(test_xs.shape[0]-time_step+1,time_step,input_dim))
for idx in range(aranged_test_xs.shape[0]):
aranged_test_xs[idx] = test_xs[idx:idx+8]
aranged_train_ys = train_ys[time_step-1:]
aranged_test_ys = test_ys[time_step-1:]
#保存数据
np.save(r'train_x_batch.npy',aranged_train_xs)
np.save(r'train_y_batch.npy',aranged_train_ys)
np.save(r'test_x_batch.npy',aranged_test_xs)
np.save(r'test_y_batch.npy',aranged_test_ys)
搭建/训练模型
在整理得到数据集后，我们就可以开始建模了。
建模流程（建议大家都多花时间提升下建模能力）：
①定义超参数（batch_size、学习率、epochs、神经元数量等）
②定义待训练参数（从什么分布取样，需要做什么正则化）
③ 定义一个load_data函数，从之前创建的数据集中读取数据
④定义LSTM单元，注意默认的激活函数是tanh，同时可以利用 tf.contrib.rnn.DropoutWrapper增加dropout层。
⑤定义LSTM网络，LSTM接受的是时序数据，所以需要将输入变成一个列表，列表的长度及时间步数。然后使用列表推导技巧（官方的办法）定义多层LSTM网络，建议都使用这个技巧，据了解别的方式BUG很多。最后使用tf.contrib.rnn.static_rnn得到网络输出，注意static和dynamic的区别，前者的时间步数是固定的，而后者是可变的，对于我们创造的数据集，每个Batch的时间步数都相同，所以我们使用static（静态）方式。
⑥训练模型，对于Tensorflow框架，其训练模型的方式大家都应该烂熟于心了。定义placeholder，定义预测函数、损失函数、优化函数等等。然后启动Session（交互式或非交互式），最后迭代进行训练。
整个过程的代码如下：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
plt.rcParams['font.sans-serif']=['SimHei']#显示中文
plt.rcParams['axes.unicode_minus']=False#显示负号
#Hyperparams
batch_size = 128
lr = 1e-6
epochs = 600
num_neurons = [32,32,64,64,128,128]
kp = 1.0
#定义输出层的weight和bias
w = tf.Variable(tf.random_normal([num_neurons[-1],1]))
b = tf.Variable(tf.random_normal([1]))
def load_data():
train_x_batch = np.load(r'train_x_batch.npy',allow_pickle=True)
train_y_batch = np.load(r'train_y_batch.npy',allow_pickle=True)
return (train_x_batch,train_y_batch)
#定义lstm单元
def lstm_cell(units,keep_prob):
cell = tf.contrib.rnn.BasicLSTMCell(num_units=units,forget_bias=0.9)#activation默认为tanh
return tf.contrib.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)
#定义lstm网络
def lstm_net(x,w,b,num_neurons,keep_prob):
#将输入变成一个列表，列表的长度及时间步数
inputs = tf.unstack(x,8,1)
cells = [lstm_cell(units=n,keep_prob = keep_prob) for n in num_neurons]
stacked_lstm_cells = tf.contrib.rnn.MultiRNNCell(cells)
outputs,_ = tf.contrib.rnn.static_rnn(stacked_lstm_cells,inputs,dtype=tf.float32)
return tf.matmul(outputs[-1],w) + b
if __name__ == '__main__':
#载入数据
(train_x,train_y) = load_data()
#定义placeholder
x = tf.placeholder(shape=(None,8,8),dtype=tf.float32)
y = tf.placeholder(shape=(None,1),dtype=tf.float32)
keep_prob = tf.placeholder(tf.float32,[])
#定义预测函数、损失函数、优化函数、初始函数、保存函数
pred = lstm_net(x,w,b,num_neurons,keep_prob)
cost = tf.reduce_mean(tf.reshape(tf.pow((pred-y),2),[-1]))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=lr).minimize(cost)
init = tf.global_variables_initializer()
saver = tf.train.Saver(tf.global_variables())
#启动交互式Session
sess = tf.InteractiveSession()
#训练模型
sess.run(init)
losses = []#记录每个epoch结束时的损失值
for epoch in range(epochs):
for step in range(train_x.shape[0]//batch_size+1):
batch_x = train_x[step*batch_size:(step+1)*batch_size]
batch_y = train_y[step*batch_size:(step+1)*batch_size]
sess.run(optimizer,feed_dict={x:batch_x,y:batch_y,keep_prob:kp})
loss = sess.run(cost,feed_dict={x:batch_x,y:batch_y,keep_prob:1.0})
losses.append(loss)
print('Epoch[{}/{}]，Loss = {:.4f}\n'.format(epoch+1,epochs,loss))
#可视化训练过程
plt.plot(losses)
plt.ylim(0,1.2*max(losses))
plt.title('损失值随迭代周期的改变')
plt.xlabel('Epoch')
plt.ylabel('损失值')
plt.show()
#保存模型
#saver.save(sess,r'model_data\my_model.ckpt')
#关闭会话
sess.close()
训练过程的损失曲线为：
使用模型进行预测
重头戏来了，所谓是骡子还是马，拉出来遛一遛就知道了，你的建模能力再强，数据处理能力再好，如果模型最终效果不行，都白搭。
要做预测，就要写个predictor脚本，方式其实更建模差不多，区别就是不用训练参数，而是加载已经训练好的参数，代码如下：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
plt.rcParams['font.sans-serif']=['SimHei']#显示中文
plt.rcParams['axes.unicode_minus']=False#显示负号
def load_data():
test_x_batch = np.load(r'test_x_batch.npy',allow_pickle=True)
test_y_batch = np.load(r'test_y_batch.npy',allow_pickle=True)
return (test_x_batch,test_y_batch)
#定义lstm单元
def lstm_cell(units):
cell = tf.contrib.rnn.BasicLSTMCell(num_units=units,forget_bias=0.0)#activation默认为tanh
return cell
#定义lstm网络
def lstm_net(x,w,b,num_neurons):
#将输入变成一个列表，列表的长度及时间步数
inputs = tf.unstack(x,8,1)
cells = [lstm_cell(units=n) for n in num_neurons]
stacked_lstm_cells = tf.contrib.rnn.MultiRNNCell(cells)
outputs,_ = tf.contrib.rnn.static_rnn(stacked_lstm_cells,inputs,dtype=tf.float32)
return tf.matmul(outputs[-1],w) + b
#超参数
num_neurons = [32,32,64,64,128,128]
#定义输出层的weight和bias
w = tf.Variable(tf.random_normal([num_neurons[-1],1]))
b = tf.Variable(tf.random_normal([1]))
#定义placeholder
x = tf.placeholder(shape=(None,8,8),dtype=tf.float32)
#定义pred和saver
pred = lstm_net(x,w,b,num_neurons)
saver = tf.train.Saver(tf.global_variables())
if __name__ == '__main__':
#开启交互式Session
sess = tf.InteractiveSession()
saver.restore(sess,r'D:\股票预测\model_data\my_model.ckpt')
#载入数据
test_x,test_y = load_data()
#预测
predicts = sess.run(pred,feed_dict={x:test_x})
predicts = ((predicts.max() - predicts) / (predicts.max() - predicts.min()))#数学校准
#可视化
plt.plot(predicts,'r',label='预测曲线')
plt.plot(test_y,'g',label='真实曲线')
plt.xlabel('第几天/days')
plt.ylabel('开盘价(归一化)')
plt.title('股票开盘价曲线预测(测试集)')
plt.legend()
plt.show()
#关闭会话
sess.close()
最终效果如图所示：
后话
在训练过程中，本人遇到过两个问题，我将它们命名为颠倒性和超前/滞后性。前者是指，最终的预测曲线的趋势与真实曲线完完全全相反，比如真实曲线上升达到极大值，预测曲线就下降达到极小值，然而，在将预测曲线上下颠倒后，其与真实曲线又能很好吻合！在经过仔细地研究和排查后，发现这种现象貌似不是来源于程序，而是具有随机性，或者用哲学的话来说，感觉这是时序模型的一个种属（就像欲望之于人类）。后者是所有时序模型的通病，就是说预测模型会永远多多少少比真实模型超前或者滞后。怎么说呢，这两点的存在，使得预测和现实总是有个无法逾越的鸿沟。希望未来能看到能够完美预测的时序模型。
743
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
