【量化交易笔记】8.基于深度学习(LSTM)预测股票价格

前言

前一章节，已作随机森林来预测股票价格，也是一种比较常见的方法，本章基于深度学习算法来处理时间序列，来预测股票未来的价格。LSTM是一种特殊类型的循环神经网络（RNN），在自然语言处理和时间序列数据分析等任务中取得了显著成果。LSTM通过处理序列数据中的长期依赖关系，能够更好地捕捉时间序列数据的特征和模式。这使得它成为预测股票价格这类时间相关数据的有力工具。关于LSTM 在之前的文章中也略作介绍。
我们仍以上一章的数据，采用类似于上一章的处理方式进行处理。

获取数据

本章我们采用 tensorflow框架的keras 来实现LSTM。

# 加载相应的库
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus']=False

from keras.models import Sequential
from keras.layers import Dense ,LSTM, Dropout

from sklearn.preprocessing import MinMaxScaler

%matplotlib inline

这部分内容，仍以sh.60000为例，从2019年1月1日到至今天(2023-5-31)。

# 加载数据
df=pd.read_csv("data/sh.600000.csv",parse_dates=["date"],index_col=[0])
df.head()

date	code	open	high	low	close	preclose	volume	amount	adjustflag	turn	tradestatus	pctChg
2019-01-02	sh.600000	8.079311	8.120785	7.946591	8.046131	8.129080	23762822	229625669.0	2	0.084554	1	-1.020412
2019-01-03	sh.600000	8.046131	8.145670	8.012951	8.137375	8.046131	18654262	181975985.0	2	0.066376	1	1.134027
2019-01-04	sh.600000	8.071016	8.294980	8.046131	8.261800	8.137375	27172844	268964563.0	2	0.096688	1	1.529048
2019-01-07	sh.600000	8.369635	8.369635	8.228620	8.278390	8.261800	23597376	235440197.0	2	0.083965	1	0.200798
2019-01-08	sh.600000	8.319865	8.319865	8.220325	8.261800	8.278390	15104933	150501650.0	2	0.053747	1	-0.200396

分离数据

由于是时间序列，特征选 'open','high','low','close','volume','turn'，考虑到volume得范围比较大，而股票价格，换手率比较小，采用MinMaxScaler对数据进行归一化处理，进行统一缩放到相同大小。

cols=['open','high','low','close','volume','turn']
df=df[cols]

scaler = MinMaxScaler(feature_range=(0,1))
df_scaled = scaler.fit_transform(df)

数据集处理

我们想用前30天数据预测第二天收盘价，这里的30天，即所有数据，由于LSTM 模型的特殊性，采用createXY函数生成数据。
具体这个函数

def createXY(dataset,n_past):
    j=0
    dataX = []
    dataY = []
    for i in range(n_past, len(dataset)):       
        x=dataset[i - n_past:i, 0:dataset.shape[1]]
        if (i+n_past>=len(dataset)):
            y=0
        else:
            y=dataset[i-1+n_past,3]
        dataX.append(x) 
        dataY.append(y)    
    return np.array(dataX),np.array(dataY) 
dataX,dataY=createXY(df_scaled,30)

让我们看看上面的代码中做了什么：
n_past是我们在预测下一个目标值时将在过去查看的步骤数。
这里使用30，意味着将使用过去的30个值(包括目标列在内的所有特性)来预测第31个目标值。
因此，在trainX中我们会有所有的特征值，而在trainY中我们只有目标值。
让我们分解for循环的每一部分
对于训练，dataset = df_for_training_scaled, n_past=30
当i= 30:
data_X.addend (df_for_training_scaled[i - n_past:i, 0:df_for_training.shape[1]])
从n_past开始的范围是30，所以第一次数据范围将是-[30 - 30,30,0:6] 相当于 [0:30,0:6]
因此在dataX列表中，df_for_training_scaled[0:30,0:6]数组将第一次出现。
现在, dataY.append(df_for_training_scaled[i,3])

i = 30，所以它将只取第30行开始的close(因为在预测中，我们只需要close列，所以列范围仅为3，表示close列)。
第一次在dataY列表中存储df_for_training_scaled[30,3]值。
所以包含5列的前30行存储在dataX中，只有close列的第31行存储在dataY中。然后我们将dataX和dataY列表转换为数组，它们以数组格式在LSTM中进行训练。

将数据集拆分为训练集、验证集和测试集。由于这个数据集是时间序列，以2023年前的数据作为训练集，之后数据为验证集。

npreddata_X=dataX[-30:]
npreddata_Y=dataY[-30:]
ddf_X=dataX[:-30]
ddf_Y=dataY[:-30]
test_split=68 #这里是从2023-1-1开始计时
trainX=ddf_X[:-test_split]
trainY=ddf_Y[:-test_split]

testX=ddf_X[-test_split:]
testY=ddf_Y[-test_split:]

看一下数据结构

trainX.shape,trainY.shape,testX.shape,testY.shape

((942, 30, 6), (942,), (68, 30, 6), (68,))

看到这里大家有没有看明白了，如果还不明白，我再给大伙解释一下

如果查看 trainX[1] 值，会发现到它与 trainX[0] 中的数据相同（第一列除外），因为我们将看到前 30 个来预测第 31 列，在第一次预测之后它会自动移动到第 2 列并取下一个 30 值来预测下一个目标值。

让我们用一种简单的格式来解释这一切——

trainX — — →trainY  
[0 : 30,0:6] → [30,3]  
[1:31, 0:6] → [31,3]  
[2:32,0:6] →[32,3]

这下应该看明白了。

建模

以一般的 LSTM 模式，用Adam优化器，用mse作为损失函数，采用二层结构进行建模。

grid_model = Sequential()
grid_model.add(LSTM(50,return_sequences=True,input_shape=(30,6)))
grid_model.add(LSTM(50))
grid_model.add(Dropout(0.2))
grid_model.add(Dense(1))
grid_model.compile(loss = 'mse',optimizer = 'adam')

grid_model.summary()

Model: "sequential_4"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 lstm_8 (LSTM)               (None, 30, 50)            11400     
                                                                 
 lstm_9 (LSTM)               (None, 50)                20200     
                                                                 
 dropout_4 (Dropout)         (None, 50)                0         
                                                                 
 dense_4 (Dense)             (None, 1)                 51        
                                                                 
=================================================================
Total params: 31,651
Trainable params: 31,651
Non-trainable params: 0
_________________________________________________________________

训练

这里用 batch_size 用16 ，epochs =40来进行训练，在实际情况一下，数据集的数据量大的话，机器内存在或采用GPU等，可以用更大的参数，epoch 也可以有更大的参数。

history=grid_model.fit(
   trainX, trainY,
   batch_size = 16,
   epochs =40,
   validation_data=(testX,testY)
)

_________________________________________________________________
Output exceeds the size limit. Open the full output data in a text editor
Epoch 1/40
59/59 [==============================] - 1s 21ms/step - loss: 0.0088 - val_loss: 0.0030
Epoch 2/40
59/59 [==============================] - 1s 22ms/step - loss: 0.0089 - val_loss: 0.0036
Epoch 3/40
59/59 [==============================] - 2s 26ms/step - loss: 0.0084 - val_loss: 0.0099
Epoch 4/40
59/59 [==============================] - 1s 19ms/step - loss: 0.0082 - val_loss: 0.0129
Epoch 5/40
59/59 [==============================] - 1s 18ms/step - loss: 0.0079 - val_loss: 0.0059
Epoch 6/40
59/59 [==============================] - 1s 19ms/step - loss: 0.0078 - val_loss: 0.0061
Epoch 7/40
59/59 [==============================] - 1s 20ms/step - loss: 0.0078 - val_loss: 0.0051
Epoch 8/40
59/59 [==============================] - 1s 19ms/step - loss: 0.0075 - val_loss: 0.0113
Epoch 9/40
59/59 [==============================] - 1s 19ms/step - loss: 0.0074 - val_loss: 0.0075
Epoch 10/40
59/59 [==============================] - 1s 22ms/step - loss: 0.0070 - val_loss: 0.0045
Epoch 11/40
59/59 [==============================] - 1s 20ms/step - loss: 0.0078 - val_loss: 0.0088
Epoch 12/40
59/59 [==============================] - 1s 20ms/step - loss: 0.0073 - val_loss: 0.0090
Epoch 13/40
...
Epoch 39/40
59/59 [==============================] - 1s 19ms/step - loss: 0.0041 - val_loss: 0.0058
Epoch 40/40
59/59 [==============================] - 1s 19ms/step - loss: 0.0038 - val_loss: 0.0056

由于训练数据和测试数据是经过归一化的，因此要查看结果，需要将数据逆缩放过程。
先看训练集数据。

tprediction=grid_model.predict(trainX)
tprediction_copies_array = np.repeat(tprediction,6, axis=-1)
tpred=scaler.inverse_transform(np.reshape(tprediction_copies_array,(len(tprediction),6)))[:,0]

toriginal_copies_array = np.repeat(trainY,6, axis=-1)
toriginal=scaler.inverse_transform(np.reshape(toriginal_copies_array,(len(trainY),6)))[:,0]

plt.figure(figsize=(10, 8))
plt.plot(toriginal,  label = '真实')
plt.plot(tpred,  label = '预测')
plt.title(' 股票价格预测')
plt.xlabel('Time')
plt.ylabel('Stock Price')
plt.legend()
plt.show()

采用相同的方法，看验证集数据

prediction=grid_model.predict(testX)
prediction_copies_array = np.repeat(prediction,6, axis=-1)
pred=scaler.inverse_transform(np.reshape(prediction_copies_array,(len(prediction),6)))[:,0]

original_copies_array = np.repeat(testY,6, axis=-1)
# original_copies_array.shape
original=scaler.inverse_transform(np.reshape(original_copies_array,(len(testY),6)))[:,0]
plt.figure(figsize=(10, 8))
plt.plot(original,  label = '真实')
plt.plot(pred,  label = '预测')
plt.title(' 股票价格预测')
plt.xlabel('Time')
plt.ylabel('Stock Price')
plt.legend()
plt.show()

评估

from sklearn.metrics import make_scorer,mean_squared_error,mean_absolute_error
print('MSE:',mean_squared_error(toriginal,tpred),mean_squared_error(original,pred))
print('MAE:',mean_absolute_error(toriginal,tpred),mean_absolute_error(original,pred))

MSE: 0.05473229063101591 0.12244576326985654
MAE: 0.17944593014201451 0.24734961573477243

从MSE和 MAE来看，值并不大。从数值上看并不大，可从图形上来看预测效果并不理想。

作图

见上图

总结

以上是深度学习中RNN中的LSTM来作股票价格预测，从结果来看效果并不理想，作为一种方法，需要我们掌握的。除了LSTM之外，还有GAN和ANN等方法，处理数据方面大同小异，GAN 是一种比较特殊的方法。
由于在实际应用中效果不理解，很少被采用，因此不作过多的介绍。
总之，我们学习其方法以及原理，决不能作为投资的依据。
以后可以通过机器学习来生成投资策略，那还是比较靠谱的。那是机器学习的另一个应用。

在此警告：文章中的所有内容，不能给你构成投资的理由。