证券数据集下使用LSTM模型预测A股走势¶

# 安装mplfinance绘制K线图
!pip install mplfinance==0.12.9b7 -i https://pypi.tuna.tsinghua.edu.cn/simple/ --trusted-host pypi.tuna.tsinghua.edu.cn

%matplotlib inline
import numpy as np
import pandas as pd
import re
from matplotlib import pyplot as plt
from matplotlib.ticker import MultipleLocator
import mplfinance as mpl
import matplotlib.dates as mpdates
from sklearn.preprocessing import MinMaxScaler

# 导入 paddle
import paddle
import paddle.nn.functional as F

print(paddle.__version__)

import warnings

warnings.filterwarnings("ignore")

2.4.0

class LSTM(paddle.nn.Layer):
    def __init__(self, num_classes, input_size, hidden_size, num_layers):
        super(LSTM, self).__init__()

        self.num_classes = num_classes
        self.num_layers = num_layers
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.seq_length = seq_length
        self.lstm = paddle.nn.LSTM(
            input_size=input_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
        )
        # self.relu = paddle.nn.ReLU()
        self.fc = paddle.nn.Linear(hidden_size, num_classes)
        # self.relu = paddle.nn.ReLU()
        # self.head = paddle.nn.Linear(int(hidden_size/2), out_features=num_classes)

    def forward(self, x):
        x, (h, c) = self.lstm(x)
        # print(h)
        # x = x[:,-1,:]
        h = h[-1]
        x = self.fc(h)
        # x = self.head(x)
        # print(out)
        return x

# 打印网络结构
model = LSTM(128, 18, 300, 1)
paddle.summary(model, (30, 796, 18))

W1216 14:17:20.358139  4248 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 11.2
W1216 14:17:20.361869  4248 gpu_resources.cc:91] device: 0, cuDNN Version: 8.2.


-----------------------------------------------------------------------------------------------------
 Layer (type)       Input Shape                       Output Shape                      Param #    
=====================================================================================================
    LSTM-2        [[30, 796, 18]]    [[30, 796, 300], [[1, 30, 300], [1, 30, 300]]]     384,000    
   Linear-1         [[30, 300]]                        [30, 128]                        38,528     
=====================================================================================================
Total params: 422,528
Trainable params: 422,528
Non-trainable params: 0
-----------------------------------------------------------------------------------------------------
Input size (MB): 1.64
Forward/backward pass size (MB): 54.82
Params size (MB): 1.61
Estimated Total Size (MB): 58.08
-----------------------------------------------------------------------------------------------------






{'total_params': 422528, 'trainable_params': 422528}

# 自定义Callback 需要继承基类 Callback
class LossCallback(paddle.callbacks.Callback):
    def __init__(self):
        self.losses = []

    def on_train_begin(self, logs={}):
        # 在fit前 初始化losses，用于保存每个batch的loss结果
        self.losses = []

    def on_train_batch_end(self, step, logs={}):
        # 每个batch训练完成后调用，把当前loss添加到losses中
        self.losses.append(logs.get("loss"))


loss_log = LossCallback()

from paddle.static import InputSpec

# 参数设置
num_epochs = 15
learning_rate = 5e-4

input_size = train_df.shape[1] - 1  # 输入的变量指标数量
hidden_size = 300  # 隐藏状态 h 大小
num_layers = 1  # 循环网络的层数

num_classes = 1  # 输出的特征数
batch_size = 8

model = paddle.Model(LSTM(num_classes, input_size, hidden_size, num_layers))

lr_schedual = paddle.optimizer.lr.CosineAnnealingDecay(
    learning_rate=learning_rate, T_max=num_epochs, verbose=False
)
# 设置优化器，学习率，并且把模型参数给优化器
opt = paddle.optimizer.Adam(
    learning_rate=learning_rate,
    parameters=model.parameters(),
    beta1=0.9,
    beta2=0.999,
)

model.prepare(opt, paddle.nn.MSELoss(), paddle.metric.Accuracy())

model.fit(
    train_dataset,
    eval_dataset,
    epochs=num_epochs,
    batch_size=batch_size,
    eval_freq=10,
    save_freq=10,
    save_dir="lstm_checkpoint",
    verbose=1,
    drop_last=False,
    shuffle=False,
    callbacks=[loss_log],
)

The loss value printed in the log is the current step, and the metric is the average value of previous steps.
Epoch 1/15
step 4/4 [==============================] - loss: 1.0933 - acc: 0.3000 - 22ms/step
save checkpoint at /home/aistudio/lstm_checkpoint/0
Eval begin...
step 4/4 [==============================] - loss: 0.4172 - acc: 0.4667 - 4ms/step
Eval samples: 30
Epoch 2/15
step 4/4 [==============================] - loss: 0.9002 - acc: 0.3000 - 21ms/step
Epoch 3/15
step 4/4 [==============================] - loss: 1.0754 - acc: 0.3000 - 21ms/step
Epoch 4/15
step 4/4 [==============================] - loss: 1.1614 - acc: 0.3000 - 19ms/step
Epoch 5/15
step 4/4 [==============================] - loss: 0.9959 - acc: 0.3000 - 19ms/step
Epoch 6/15
step 4/4 [==============================] - loss: 0.9359 - acc: 0.3000 - 19ms/step
Epoch 7/15
step 4/4 [==============================] - loss: 0.9251 - acc: 0.3000 - 19ms/step
Epoch 8/15
step 4/4 [==============================] - loss: 0.9358 - acc: 0.3000 - 19ms/step
Epoch 9/15
step 4/4 [==============================] - loss: 0.9616 - acc: 0.3000 - 19ms/step
Epoch 10/15
step 4/4 [==============================] - loss: 0.9845 - acc: 0.3000 - 19ms/step
Epoch 11/15
step 4/4 [==============================] - loss: 0.9746 - acc: 0.3000 - 19ms/step
save checkpoint at /home/aistudio/lstm_checkpoint/10
Eval begin...
step 4/4 [==============================] - loss: 0.2339 - acc: 0.4667 - 4ms/step
Eval samples: 30
Epoch 12/15
step 4/4 [==============================] - loss: 0.9414 - acc: 0.3000 - 20ms/step
Epoch 13/15
step 4/4 [==============================] - loss: 0.9167 - acc: 0.3000 - 20ms/step
Epoch 14/15
step 4/4 [==============================] - loss: 0.9058 - acc: 0.3000 - 19ms/step
Epoch 15/15
step 4/4 [==============================] - loss: 0.8950 - acc: 0.3000 - 19ms/step
save checkpoint at /home/aistudio/lstm_checkpoint/final

# 可视化 loss
log_loss = [loss_log.losses[i] for i in range(0, len(loss_log.losses), 10)]
plt.figure()
plt.plot(log_loss)

[<matplotlib.lines.Line2D at 0x7fa0908fee10>]

model.load("lstm_checkpoint/final")
# 用 evaluate 在测试集上对模型进行验证
eval_result = model.evaluate(eval_dataset, batch_size=batch_size, verbose=1)
print(eval_result)

Eval begin...
step 4/4 [==============================] - loss: 0.2282 - acc: 0.4667 - 4ms/step
Eval samples: 30
{'loss': [0.22817002], 'acc': 0.4666666666666667}

model.load("lstm_checkpoint/final")
test_result = model.predict(eval_dataset)
# 由于模型是单一输出，test_result的形状为[1, N]，N是测试数据集的数据量。这里打印第一个数据的预测结果。
print(len(test_result))
print(test_result[0][0])
print(
    "预测值:{0}, 实际值:{1}".format(test_result[0][0][0], eval_dataset[0][1][0])
)

Predict begin...
step 30/30 [==============================] - 2ms/step          
Predict samples: 30
1
[[0.54194236]]
预测值:[0.54194236], 实际值:Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [1.])