写在前面
在本文中，我们将介绍使用PyTorch构建一个深度学习模型，并将其集成到backtrader回测框架中。具体地，我们将使用PyTorch来实现一个长短期记忆神经网络（LSTM）模型，并将其应用于股票价格预测。由于backtrader目前没有原生支持深度学习的模块，因此我们需要自己先实现一个深度学习模型，对其先进行训练与测试，然后将保存的模型与backtrader集成，以便进行回测。
1
前言
Backtrader是一个开源的Python框架，用于快速设计、测试和部署交易策略。它是基于向量化的计算方法，提供了丰富的工具和数据结构，可以方便地进行回测和交易策略的开发。使用Backtrader，可以轻松地获取、处理和分析金融市场数据，编写和优化交易策略，并进行可视化和回测。Backtrader提供了许多内置的交易指标和模拟交易器，可以帮助快速测试和评估不同的策略。如果想进一步了解Backtrader可以通过其官方网站（https://www.backtrader.com/），获取Backtrader的api文档进行学习。
2
环境配置
本地环境：
Python 3.7
IDE:Pycharm库版本：
numpy 1.18.1
pandas 1.0.3
sklearn 0.22.2
matplotlib 3.2.1
torch 1.10.1
tushare 1.2.60
backtrader 1.9.76.1233
代码实现
总体设计
为了实现这个基于深度学习模型的backtrader回测框架，我们可以将其分为以下模块：
1. 数据获取模块：使用tushare库获取股票历史数据，并对数据进行预处理
2. 深度学习模型模块：使用PyTorch创建一个基本的LSTM模型，通过滑动窗口的形式对股票历史数据进行训练以及测试，然后将训练好的模型进行保存，以便于回测框架的调用。
3. 量化策略模块：基于Backtrader框架实现一个基于LSTM模型的简单交易策略。这个策略会在每天收盘时调用训练好的LSTM模型，预测后面的行情是否会上涨。如果预测上涨，那么就在明天以开盘价买入，如果下跌，就在明天以开盘价卖出。
数据获取
接下来，我们将实现一个函数来获取股票历史数据，请将tushare API token替换到代码中的YOUR_API_TOKEN处。接下来，可以使用get_stock_data函数来获取指定股票的历史数据，然后将数据保存到本地，这里以招商银行两年的历史数据为例。
def get_stock_data(code, start_date, end_date, token):
ts.set_token(token)
pro = ts.pro_api()
df = pro.daily(ts_code=code, start_date=start_date, end_date=end_date)
df = df.sort_values(by="trade_date", ascending=True) # 对数据进行排序，以便滑动窗口操作
df.set_index("trade_date", inplace=True)
return df
stock_code = "600036.SH"
start_date = "20200101"
end_date = "20220101"
api_token = "YOUR_API_TOKEN"
data = get_stock_data(stock_code, start_date, end_date, api_token)
data.to_csv('./data.csv')
print(data.head())模型实现
这里用到了简单的LSTM模型进行测试，模型也没有进行进一步的调优，为了使模型具有更好的预测效果，以下是一些可能提高LSTM模型效果的方法：更改网络结构：增加层数或者增加隐藏单元数可以提高LSTM模型的表达能力。但是，太多的层数或者隐藏单元数也可能导致过拟合，所以需要在训练集和测试集上做出合理的选择。加入正则化：LSTM模型也可以使用L2正则化等方法来避免过拟合。加入更多的特征：除了开盘价之外，也可以考虑加入其他的特征，例如最高价、最低价、成交量等，以提高模型的表达能力。调整超参数：可以通过网格搜索等方法来寻找最佳的超参数组合，例如学习率、batch size、滑动窗口大小等。用到的LSTM模型代码如下：
class SimpleLSTM(nn.Module):
def __init__(self, input_size, hidden_size, num_layers, num_classes, dropout_rate=0.2):
super(SimpleLSTM, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
self.fc1 = nn.Linear(hidden_size, hidden_size)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(dropout_rate)
self.bn = nn.BatchNorm1d(hidden_size)
self.fc2 = nn.Linear(hidden_size, num_classes)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
out, _ = self.rnn(x, h0)
out = self.fc1(out[:, -1, :])
out = self.relu(out)
out = self.dropout(out)
out = self.bn(out)
out = self.fc2(out)
out = self.sigmoid(out)
return out接下来，我们需要对数据集进行划分，这里只用到了股票数据的收盘价来构建数据集。首先，先对原始数据进行归一化处理，然后使用滑动窗口的形式输入过去一段时间的收盘价，以预测未来三天的收盘价是否会上涨，最后，我们需要将数据转换成适用于模型训练的形式：
def create_dataset(stock_data, window_size):
X = []
y = []
scaler = MinMaxScaler()
stock_data_normalized = scaler.fit_transform(stock_data.values.reshape(-1, 1))
for i in range(len(stock_data) - window_size - 2):
X.append(stock_data_normalized[i:i + window_size])
if stock_data.iloc[i + window_size + 2] > stock_data.iloc[i + window_size - 1]:
y.append(1)
else:
y.append(0)
X, y = np.array(X), np.array(y)
X = torch.from_numpy(X).float()
y = torch.from_numpy(y).long()
return X, y, scaler之后，划分训练集跟测试集并对模型进行训练与测试，并对训练好的模型进行保存，以便于后面在backtrader策略中进行调用：
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
train_data = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
model = SimpleLSTM(input_size, hidden_size, num_layers, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
num_epochs = 200
# 训练模型
for epoch in range(num_epochs):
for i, (batch_X, batch_y) in enumerate(train_loader):
outputs = model(batch_X)
loss = criterion(outputs, batch_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 10 == 0:
print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')
print('Finished Training')
torch.save(model.state_dict(), 'lstm_model.pth')
model.eval()
with torch.no_grad():
correct = 0
total = 0
test_data = TensorDataset(X_test, y_test)
test_loader = DataLoader(test_data, batch_size=32, shuffle=False)
for batch_X, batch_y in test_loader:
outputs = model(batch_X)
_, predicted = torch.max(outputs.data, 1)
total += batch_y.size(0)
correct += (predicted == batch_y).sum().item()
print(f'Accuracy of the model on the test data: {100 * correct / total}%')backtrader策略实现
下面构建backtrader的策略，首先在Strategy中加载保存的模型，然后在next中每次收盘时对模型进行调用。需要注意的是这里通过滑动窗口的形式进行预测，所以定义了一个counter变量用来计算是否收集到了足够的数据。之后将窗口的数据进行归一化输入模型，并根据模型的预测结果来决定下一个交易的交易行为。这里的交易规则简单的定为，如果预测未来会上涨且没有仓位就在下一交易日开盘买入，如果预测未来会下跌且持有仓位就在下一交易日开盘卖出。回测时本金10000，每次交易只进行一手，佣金设置为万五。
# 构建策略
class LSTMStrategy(bt.Strategy):
def __init__(self):
self.data_close = self.datas[0].close
self.model = SimpleLSTM(input_size, hidden_size, num_layers, num_classes)
self.model.load_state_dict(torch.load('lstm_model.pth'))
self.model.eval()
self.scaler = scaler
self.counter = 1
def next(self):
if self.counter < window_size:
self.counter += 1
return
previous_close_prices = [self.data_close[-i] for i in range(0, window_size)]
X = torch.tensor(previous_close_prices).view(1, window_size, -1).float()
X = self.scaler.transform(X.numpy().reshape(-1, 1)).reshape(1, window_size, -1)
prediction = self.model(torch.tensor(X).float())
max_vals, max_idxs = torch.max(prediction, dim=1)
predicted_prob, predicted_trend = max_vals.item(), max_idxs.item()
if predicted_trend == 1 and not self.position: # 上涨趋势
self.order = self.buy() # 买入股票
elif predicted_trend == 0 and self.position: # 如果预测不是上涨趋势且持有股票，卖出股票
self.order = self.sell()
# Load test data
test_data = pd.read_csv('data.csv', index_col=0, parse_dates=True)
# Create a cerebro entity
cerebro = bt.Cerebro(runonce=False)
# Add data to cerebro
data = bt.feeds.PandasData(
dataname=test_data,
datetime=None,
open=1,
high=2,
low=3,
close=4,
volume=8,
openinterest=-1)
cerebro.adddata(data)
# Add strategy to cerebro
cerebro.addstrategy(LSTMStrategy)
# 本金10000，每次交易100股
cerebro.broker.setcash(10000)
cerebro.addsizer(bt.sizers.FixedSize, stake=100)
# 万五佣金
cerebro.broker.setcommission(commission=0.0005)
# Print out the starting conditions
print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
# Run over everything
cerebro.run()
# Print out the final result
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
# Plot the result
cerebro.plot()策略运行效果
首先，对模型进行训练跟测试，经过多个epoch的迭代，训练的模型在测试集实现了66%的分类准确性。
Finished Training
Accuracy of the model on the test data: 66.3157894736842%之后调用backtrader回测引擎进行回测。回测结果的可视化如下图所示，可以看出每次交易一手，回测结束后的资金是11686.92，前期有多次亏损，中间模型捕捉到了一次大的上涨趋势，后面也是多次正的收益。
4
总结
本文构建的交易策略使用了深度学习模型来构建交易信号，并通过backtrader框架实现量化回测。相比传统技术分析方法，使用深度学习模型可以更好地利用历史数据的信息，丰富交易策略。同时，使用backtrader框架可以简化回测的流程，自动化交易决策，并且提供丰富的可视化工具，方便用户进行回测结果的分析和优化。这个框架只是简单将backtrader框架用于深度学习模型的历史回测，所以还有很多可以改进的地方，例如加入过滤条件，进行样本外测试，更换其他模型，引入更多特征等。总之，本文基于backtrader提供了一种基于深度学习构建回测框架的思路，感兴趣的读者可以基于此框架，对更多深度学习、机器学习模型进行测试。
本文内容仅仅是技术探讨和学习，并不构成任何投资建议。
获取完整代码与数据以及其他历史文章完整源码与数据可加入《人工智能量化实验室》知识星球。
《人工智能量化实验室》知识星球
加入人工智能量化实验室知识星球，您可以获得：（1）定期推送最新人工智能量化应用相关的研究成果，包括高水平期刊论文以及券商优质金融工程研究报告，便于您随时随地了解最新前沿知识；（2）公众号历史文章Python项目完整源码；（3）优质Python、机器学习、量化交易相关电子书PDF；（4）优质量化交易资料、项目代码分享；（5）跟星友一起交流，结交志同道合朋友。（6）向博主发起提问，答疑解惑。