【Python】基于动态残差学习的堆叠式LSTM模型和传统BP在股票预测中的应用
1. 前言
本论文探讨了长短时记忆网络（LSTM）和反向传播神经网络（BP）在股票价格预测中的应用。首先，我们介绍了LSTM和BP在时间序列预测中的基本原理和应用背景。通过对比分析两者的优缺点，我们选择了LSTM作为基础模型，因其能够有效处理时间序列数据中的长期依赖关系，在基础LSTM模型的基础上，我们引入了动态残差学习（dynamic skip connection）的概念，通过动态调整残差连接，提高了模型的长期记忆能力和预测准确性。实验证明，动态残差的引入在股票价格预测任务中取得了显著的改进效果。进一步地，我们探讨了堆叠式LSTM的改进方法，通过增加模型的深度来捕捉更复杂的时间序列模式。我们详细阐述了堆叠式LSTM的结构和训练过程，并通过实验证实其在股票价格预测中的优越性。结果表明，堆叠式LSTM在处理多层次的时间序列信息上具有更强的表达能力，提高了模型的泛化性能。综合而言，本论文通过对LSTM和BP在股票价格预测中的应用进行研究，进一步引入了动态残差学习和堆叠式LSTM的改进方法，提高了模型的性能和稳健性。这些方法为金融领域的时间序列预测提供了有效的工具和思路，对于投资决策和风险管理具有重要的实际意义。
 |
 |
|---|---|
| Colab Notebook | Github Rep |
2. 数据集和方法选用
随着信息技术的不断发展和大数据的涌现，研究者们越来越倾向于利用高频、多维的金融数据来提升预测模型的性能。在这一趋势中，长短时记忆网络（LSTM）作为一种强大的时序建模工具，凭借其对长期依赖关系的出色捕捉能力，引起了广泛的关注。同时，动态残差学习和堆叠式LSTM等改进方法的引入进一步提高了模型的复杂性和性能。本研究在这一背景下，以中国股票市场为研究对象，旨在利用这些先进的深度学习技术，提高对系统性风险的识别和预测能力。
2.1 数据集描述
为了确保时间序列的稳定性，我们选择了这些具有相对较长历史的股票。我们的数据集来源于 investing.com、Yahoo Finance、Yahoo Finance等，通过网络爬虫爬取和网站直接下载的方式，获取了中国股票市场中时间较长的四只股票的日频数据。这些股票的历史数据涵盖多年，每日记录超过7000条。
2.2 数据获取过程
在使用网络爬虫获取金融数据时，主要步骤包括选择数据源、确定数据获取的方法、编写爬虫代码、处理数据并保存。首先我们确定了要获取数据的来源，就是上面所说的几个股票网站，随后我们确定了数据获取的方法，查看数据源是否提供API接口和直接下载的链接。如果有，就可以使用API或者直接下载方式来更加方便和规范地获取数据。如果没有API，则能需要考虑使用爬虫技术从网页中提取数据。到了编写爬虫代码的步骤， 我们选择使用爬虫，于是编写代码来模拟浏览器行为，请求网页并解析HTML内容。具体使用的Python中的requests库来用于发送HTTP请求，除此之外还使用了BeautifulSoup和lxml等库用于解析所获取到HTML。最后我们进行了处理数据并保存，提取了后面再进行特征工程时所需要的信息，然后进行简单的数据清理和处理。最后，将数据保存到本地文件或数据库中。最后我们保存了四只符合条件的股票。
| 序号 | 记录开始时间 | 记录结束时间 | 记录条数 |
|---|---|---|---|
| 000001 | 1991-01-29 | 2020-04-14 | 6936 |
| 000002 | 1991-01-29 | 2020-04-18 | 6940 |
| 000004 | 1991-01-14 | 2020-04-14 | 6820 |
| 000006 | 1992-04-27 | 2020-04-18 | 6603 |
import requests
from bs4 import BeautifulSoup
import pandas as pd
import yfinance as yf
from tiingo import TiingoClient
# 函数：爬取 investing.com 的历史股价数据
def scrape_investing(stock_code):
url = f'https://www.investing.com/equities/{stock_code}-historical-data'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
data_table = soup.find('table', {'id': 'curr_table'})
data = pd.read_html(str(data_table))[0]
return data
# 函数：爬取 Yahoo Finance 的历史股价数据
def scrape_yahoo_finance(stock_code):
stock_data = yf.download(stock_code, start="1991-01-01")
return stock_data
# 函数：爬取 Tiingo 的历史股价数据
def scrape_tiingo(stock_code, api_key):
config = {
'session': True,
'api_key': api_key
}
client = TiingoClient(config)
stock_data = client.get_ticker_price(stock_code, fmt='json', startDate='2000-01-01')
data = pd.DataFrame(stock_data)
return data
# 函数：筛选至少有6800条记录的数据
def filter_data(data, min_records=6800):
if len(data) >= min_records:
return data
else:
return None
# 股票代码
stock_code = 'xxxx' # 示例伪代码
# 爬取数据
investing_data = scrape_investing(stock_code)
yahoo_finance_data = scrape_yahoo_finance(stock_code)
tiingo_data = scrape_tiingo(stock_code, 'TIINGO_API_KEY') # 真实的Tiingo API 密钥
# 筛选数据
investing_data = filter_data(investing_data)
yahoo_finance_data = filter_data(yahoo_finance_data)
tiingo_data = filter_data(tiingo_data)
# 清洗数据...
# 保存文件...
在数据获取的过程中，我们也遇到一些困难，有网站有反爬虫机制，它们采取反爬虫机制来防止爬虫访问。我们用设置合适的请求头，使用代理IP解决了这个问题，还有动态加载的问题， 一些网页如新三板网站（xinsanban.eastmoney.com）使用JavaScript进行动态加载数据，这样爬虫可能无法直接获取到所有的信息。解决办法是我们使用Docker部署一个splash来爬取数据。
2.3 选股标准：
在选股时，我们考虑了这四只股票在中国股票市场中的代表性、其历史数据的时间跨度，以及它们的交易活跃度。这种选股标准的应用旨在使我们的研究更具有代表性，能够更全面地反映中国股票市场的整体波动。
2.4 机器学习方法：
我们采用了深度学习方法，主要是长短时记忆网络（LSTM）。并且与BP神经网络进行了一个对比实验，LSTM作为一种递归神经网络，在捕捉时间序列数据中的长期依赖关系方面表现出色。通过对股票价格的历史数据进行训练，我们预期的是LSTM能够有效地建模和预测未来的价格趋势。
2.5 改进方法：
在基础的LSTM模型上，我们引入了动态残差学习和堆叠式LSTM的改进方法。动态残差学习旨在通过调整残差连接，提升模型的长期记忆能力。而堆叠式LSTM通过增加模型的深度，更好地捕捉时间序列中的复杂模式。这些改进方法旨在提高模型对系统性风险的识别和预测能力，使其更适用于金融领域的时间序列预测任务。
3. 反向神经网络以及短期记忆网络的数学表达
反向传播（BP）神经网络是一类人工神经网络，在机器学习和模式识别领域非常受欢迎。这些网络属于监督学习算法家族，尤其以其学习输入和输出数据之间复杂映射的能力而闻名。术语“反向传播”是指误差通过网络向后传播的训练过程，从而能够调整权重以最小化预测输出和实际输出之间的差异。
3.1 反向传播原理的概念
3.1.1 神经网络结构
BP神经网络由输入层、一个或多个隐藏层和输出层组成。每层都包含互连的节点，每个连接都与一个权重相关联。
3.1.2 前馈过程
在前馈过程中，输入数据在网络中逐层传播，通过每个节点中的加权连接和激活函数进行转换。此过程生成网络的输出。如下公式(1)，前馈的过程是通过网络传播输入以使用激活函数生成输出。
a j ( l ) = g ( z j ( l ) ) （ 1 ） a_j^{(l)} = g(z_j^{(l)}) （1） aj(l)=g(zj(l))（1）
3.1.3 误差计算：
将网络生成的输出与实际目标值进行比较，并计算误差。常见的误差函数包括均方误差 (MSE) 或交叉熵。如下公式(2)，误差计算是计算预测 a k ( L ) a_k^{(L)} ak(L)和实际 y k y_k yk输出之间的差异。
E = 1 2 ∑ k ( y k − a k ( L ) ) （ 2 ） E=\frac{1}{2}\sum_{k}(y_{k}-a_{k}^{(L)})（2） E=21k∑(yk−ak(L))（2）
3.1.4 反向传播算法
反向传播算法涉及权重的迭代调整以最小化误差。首先进行梯度计算（公式3）用微积分的链式法则计算误差相对于每个权重的梯度。然后更新权重（公式4），权重以梯度的相反方向更新，目的是减少误差。再引入学习率，以此来控制权重更新期间的步长。它可以防止超调或收敛问题。然后是激活函数（公式5），它向网络引入非线性，使其能够学习复杂的关系。最后训练迭代前馈和反向传播步骤重复多次迭代或历元，直到网络收敛到误差最小化的状态。
∂ E ∂ ω i j ¨ ( 1 ) = δ j ( l + 1 ) ∗ a i ( l ) （ 3 ） \frac{\partial E}{\partial\omega_{\ddot{\mathrm{ij}}}^{(1)}}=\delta_{j}^{(l+1)}*a_{i}^{(l)} （3） ∂ωij¨(1)∂E=δj(l+1)∗ai(l)（3）
ω i j ( l ) = ω i j ( l ) − α ∂ E ∂ ω i j ( l ) （ 4 ） \omega_{\mathrm{ij}}^{(l)}=\omega_{\mathrm{ij}}^{(l)}-\alpha\frac{\partial E}{\partial\omega_{ij}^{(l)}}（4） ωij(l)=ωij(l)−α∂ωij(l)∂E（4）
g ( z ) = 1 1 + e − z O R g ( z ) = max ( 0 , Z ) （ 5 ） g(z)=\dfrac{1}{1+e^{-z}}ORg(z)=\max(0,Z)（5） g(z)=1+e−z1ORg(z)=max(0,Z)（5）
3.2 LSTM的原理以及概念
长短期记忆 (LSTM) 网络是一种特殊类型的循环神经网络 (RNN)，旨在克服传统 RNN 中的梯度消失问题。 LSTM 通过捕获远程依赖关系，在建模和预测顺序数据方面特别有效。由于这些网络能够长时间学习和记住信息，因此在自然语言处理、语音识别和时间序列预测中得到了广泛的应用。
3.2.1 细胞状态和门
LSTM 引入了贯穿整个序列的单元状态 概念，允许信息随着时间的推移而持续存在。门控制信息流入和流出细胞状态。
3.2.2 三种门
第一种是忘记门，用于决定应丢弃或保留细胞状态中的哪些信息。符号表示为 ( f i ) (f_i) (fi)，第二种是输入门，用于确定应将哪些新信息添加到单元状态中。符号表示为 ( i t ) (i_t) (it)，第三种是输出门，用于记录控制单元状态中的哪些信息应输出到序列中的下一层。符号表示为 ( o t ) (o_t) (ot)
3.2.3 细胞状态更新
细胞状态通过以下三种步骤来更新。一种是忘记门操作（公式6），一种是输入门操作（公式7），还有一种是细胞状态更新操作（公式8）
f t = σ ( W f ∗ [ h t − 1 , x t ] + b f ) （ 6 ） \quad f_t=\sigma({W_f}*[h_{t-1},x_t]+b_f)（6） ft=σ(Wf∗[ht−1,xt]+bf)（6）
i t = σ ( W f ∗ [ h t − 1 , x t ] + b i ) （ 7 ） i_t=\sigma(W_f*[h_{t-1},x_t]+b_i) （7） it=σ(Wf∗[ht−1,xt]+bi)（7）
C ~ = tanh ( W C ∗ [ h t − 1 , x t ] + b C ) （ 7 ） \widetilde{C}=\tanh(W_C*[h_{t-1},x_t]+b_C)（7） C =tanh(WC∗[ht−1,xt]+bC)（7）
C t = f t ∗ C t − 1 + i t ∗ C ~ t （ 8 ） C_{t}=f_{t}*C_{t-1}+i_{t}*\tilde{C}_{t}（8） Ct=ft∗Ct−1+it∗C~t（8）
3.2.4 隐藏状态更新
隐藏状态使用输出门更新（公式9）
o t = σ ( W o ∗ [ h t − 1 , x t ] + b o ) h t = o t ∗ tanh ( C t ) ( 9 ) \begin{aligned}o_t&=\sigma(W_o*[h_{t-1},x_t]+b_o)\\h_t&=o_t*\tanh(C_t)\end{aligned} (9) otht=σ(Wo∗[ht−1,xt]+bo)=ot∗tanh(Ct)(9)
3.2.5 训练和反向传播
LSTM 使用随时间反向传播 (BPTT) 进行训练，其中计算损失相对于参数的梯度并用于更新权重。
4. 用堆叠式和动态残差来改进短期记忆网络
4.1 堆叠式 LSTM的原理以及概念
堆叠式长短期记忆 (LSTM) 网络，即Stacked Long Short-Term Memory Networks是传统 LSTM 架构的扩展，旨在捕获顺序数据中更复杂和分层的模式。通过将多个 LSTM 层相互堆叠，这些网络增强了表示学习能力，从而可以对时间序列数据中复杂的依赖关系进行建模。堆叠架构能够提取分层特征，使其在时间序列预测、自然语言处理和语音识别等任务中特别有效。 它相对于传统的LSTM有顺序信息流、层次特征提取、分层结构、随时间的训练和反向传播的特点。
4.1.1 分层结构
堆叠 LSTM 由多个 LSTM 层组成，其中每层都包含自己的一组 LSTM 单元。信息按层次结构流过这些层，使网络能够学习复杂的表示。
h t ( 1 ) = L S T M 1 ( x t , h t − 1 ( 1 ) , C t − 1 ( 1 ) ) h t ( 2 ) = L S T M 2 ( h t , h t − 1 ( 2 ) , C t − 1 ( 2 ) ) （ 10 ） \begin{aligned}h_t^{(1)}&=LSTM1(x_t,h_{t-1}^{(1)},C_{t-1}^{(1)})\\h_t^{(2)}&=LSTM2(h_t,h_{t-1}^{(2)},C_{t-1}^{(2)})\end{aligned}（10） ht(1)ht(2)=LSTM1(xt,ht−1(1),Ct−1(1))=LSTM2(ht,ht−1(2),Ct−1(2))（10）
4.1.2 顺序信息流
每个 LSTM 层处理顺序输入数据，一层的输出作为堆栈中下一层的输入。这种顺序信息流使模型能够捕获不同抽象级别的依赖关系。
4.1.3 层次特征提取
堆叠 LSTM 层可以提取分层特征。较低层可以捕获简单的时间模式，而较高层可以根据较低层的输出学习更抽象和复杂的表示。
4.1.4 随时间的训练和反向传播
与传统 LSTM 类似，堆叠 LSTM 使用 BPTT 算法进行训练。在反向传播期间通过整个堆栈计算梯度，从而允许考虑整个层次结构的权重更新。
4.2 动态残差 LSTM的原理以及概念
4.2.1 Residual Learning(剩余学习)
受 ResNets 启发，动态残差 LSTM 集成了残差学习的概念。这涉及引入跳跃连接，允许网络直接学习残差映射，从而缓解梯度消失问题。
4.2.2 Dynamic Skip Connections(动态跳跃连接)
与跳跃连接是固定的传统残差网络不同，动态残差 LSTM 引入了基于输入数据的跳跃连接的可变性（公式11）。跳跃连接在训练过程中动态调整，使模型能够适应输入序列的不同复杂性。因此LSTM的单元操作也需要做出相应的更改（公式12）
s t = D y n a m i c S k i p C o n n e c t i o n ( x t , h t − 1 ) （ 11 ） s_t=DynamicSkipConnection(x_t,h_{t-1})（11） st=DynamicSkipConnection(xt,ht−1)（11）
h t = L S T M ( x t + s t , h t − 1 ( 1 ) , C t − 1 ( 1 ) ) （ 12 ） h_{t}=LSTM(x_{t}+s_{t},h_{t-1}^{(1)},C_{t-1}^{(1)}) （12） ht=LSTM(xt+st,ht−1(1),Ct−1(1))（12）
4.2.3 增强的长期依赖处理
动态跳跃连接通过为梯度流提供快捷路径来增强 LSTM 处理长期依赖关系的能力。这有助于缓解反向传播过程中与梯度消失相关的问题。
4.2.4 训练和反向传播
动与传统 LSTM 类似，动态残差 LSTM 使用随时间反向传播 (BPTT) 进行训练。然而，动态跳跃连接的存在引入了需要在训练期间学习的额外参数。
5. 实证分析和实验设计
5.1 数据集部分展示以及说明
5.2 传统 LSTM构建展示
# 传统LSTM模型
from keras.models import Sequential
from keras.layers import LSTM, Dropout, Dense
d = 0.0001
model = Sequential() # 建立层次模型
model.add(LSTM(64, input_shape=(window, feanum), return_sequences=True)) # 建立LSTM层
model.add(Dropout(d)) # 建立的遗忘层
model.add(LSTM(16, return_sequences=False)) # 建立LSTM层，不需要再次指定input_shape
model.add(Dropout(d)) # 建立的遗忘层
model.add(Dense(4, activation='relu')) # 建立全连接层，移除init参数
model.add(Dense(1, activation='relu')) # 建立全连接层，移除init参数
model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=200, batch_size=256) # 训练模型，使用epochs代替nb_epoch
5.3 堆叠式LSTM构建展示
# 堆叠式LSTM模型
from keras.models import Sequential
from keras.layers import LSTM, Dropout, Dense
d = 0.0001
model_stack = Sequential() # 建立层次模型
model_stack.add(LSTM(64, input_shape=(window, feanum), return_sequences=True)) # 建立LSTM层
model_stack.add(Dropout(d)) # 建立的遗忘层
model_stack.add(LSTM(32, return_sequences=True)) # 建立LSTM层，不需要再次指定input_shape
model_stack.add(Dropout(d)) # 建立的遗忘层
model_stack.add(LSTM(16, return_sequences=False)) # 建立LSTM层，不需要再次指定input_shape
model_stack.add(Dropout(d)) # 建立的遗忘层
model_stack.add(Dense(4, activation='relu')) # 建立全连接层，移除init参数
model_stack.add(Dense(1, activation='relu')) # 建立全连接层，移除init参数
model_stack.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
model_stack.fit(X_train, y_train, epochs=200, batch_size=256) # 训练模型，使用epochs代替nb_epoch
5.4 动态残差+LSTM构建展示
from keras.layers import LSTM, Dropout, Dense, Lambda, Layer, Input
from keras.models import Sequential
from keras import Model
from keras.layers import GlobalAveragePooling1D
import keras.backend as K
# 自定义动态残差层
class DynamicResidualLayer(Layer):
def __init__(self, **kwargs):
super(DynamicResidualLayer, self).__init__(**kwargs)
def build(self, input_shape):
super(DynamicResidualLayer, self).build(input_shape)
def call(self, inputs, **kwargs):
x, skip_connection = inputs
return K.concatenate([x, skip_connection], axis=-1)
def compute_output_shape(self, input_shape):
return input_shape[0][0], input_shape[0][1], input_shape[0][2] * 2
# 堆叠式LSTM + 动态残差模型
inputs = Input(shape=(window, feanum))
x = LSTM(64, return_sequences=True)(inputs)
x = Dropout(d)(x)
# 第一个动态残差层
skip_connection1 = LSTM(64, return_sequences=True)(x)
x = DynamicResidualLayer()([x, skip_connection1])
# 第二个动态残差层
skip_connection2 = LSTM(32, return_sequences=True)(x)
x = DynamicResidualLayer()([x, skip_connection2])
# 第三个动态残差层
skip_connection3 = LSTM(16, return_sequences=True)(x)
x = DynamicResidualLayer()([x, skip_connection3])
x = GlobalAveragePooling1D()(x)
x = Dropout(d)(x)
x = Dense(4, activation='relu')(x)
outputs = Dense(1, activation='relu')(x)
model_dynamic = Model(inputs=inputs, outputs=outputs)
model_dynamic.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
model_dynamic.fit(X_train, y_train, epochs=200, batch_size=256) # 训练模型，使用epochs代替nb_epoch
5.5 三种模型信息展示
5.6 三种模型在训练集和测试集上的结果图
5.7 三种模型的详细指标结果
| 模型 | MAE | MSE | 准确率 | MAPE |
|---|---|---|---|---|
| LSTM | 0.90 | 0.82 | 0.01 | inf |
| 堆叠式LSTM | 0.016 | 0.00044 | 0.43 | 1.84 |
| 堆叠式LSTM+动态残差 | 0.019 | 0.00071 | 0.43 | 2.16 |
| 模型 | MAE | MSE | 准确率 | MAPE |
|---|---|---|---|---|
| LSTM | 0.90 | 0.82 | 0.01 | inf |
| 堆叠式LSTM | 0.013 | 0.00034 | 0.43 | 1.84 |
| 堆叠式LSTM+动态残差 | 0.014 | 0.00038 | 0.43 | 1.63 |
5.8 实验结论
在这个实验中，我们使用了三种不同的LSTM模型来预测
股票价格：传统的LSTM，堆叠式LSTM，以及堆叠式LSTM+动态残差。每种模型都有其独特的特点和优势。
- 传统的LSTM模型是最简单的模型，它只有一个LSTM层。尽管这个模型的结构相对简单，但它仍然能够捕捉到时间序列数据中的长期依赖关系，从而进行有效的预测。
- 堆叠式LSTM模型在传统的LSTM模型的基础上增加了更多的LSTM层。这使得模型能够学习到数据中更复杂的模式。然而，这也使得模型的训练变得更加困难，并且可能导致过拟合。
- 堆叠式LSTM+动态残差模型在堆叠式LSTM模型的基础上添加了动态残差层。这个模型的优势在于它能够同时学习到数据中的高级特征和低级特征，从而进行更准确的预测。
在我们的实验中，我们发现堆叠式LSTM+动态残差模型在预测股票价格上的综合表现最好。特别是当迭代次数增加时，它学习的效率比堆叠式LSTM高出很多。这可能是因为这个模型能够同时捕捉到数据中的复杂模式和简单模式，从而进行更准确的预测。然而，这并不意味着这个模型在所有情况下都会表现最好。在不同的任务和数据集上，不同的模型可能会有不同的表现。因此，选择最适合的模型需要根据具体的任务和数据来决定。
结束语
如果有疑问欢迎大家留言讨论，你如果觉得这篇文章对你有帮助可以给我一个免费的赞吗？我们之间的交流是我最大的动力！