Backtrader 文档学习- 架构功能分析理解
1. 概述
backtrader是一个用于开发和执行交易策略的Python框架。它提供了一套完整的工具和功能，使得用户可以方便地进行策略回测、实盘交易以及数据分析。
backtrader的入口为Cerebro类，该类将所有输入(Data Feeds)、策略 (Strategy)、观察者(Observers)、策略评估(Analyzers) 、经纪人（Broker）、订单（Order）、交易（Trade）和日志记录(Writers)整合起来，实现回测以及交易，并返回结果和图表。
backtrader优缺点，先说缺点：
（1）缺点：
- 在于使用元类编程技术，使用了大量的类，调试的时候会比较难。
- 对于python的要求高，需要掌握pandas，matplotlib ，有基础上手更容易。
- 对环境存在兼容性， 使用pandas ，numpy ，matplotlib 的版本不能太高。
- 对回测结果分析，需定制化做大量工作，比如需要将各类策略的测试结果，除了能打印日志外，需要保存到数据库中，便于后期对比分析，比如周期参数，5天、10天、20天同一个策略不同的周期，执行的绩效记录处理。
（2）优点：
- 功能非常完善，支持多品种、多策略、多周期的回测和交易，编写策略简单，上手容易。
- 交易的品种非常丰富(股票、期货、期权、外汇等)。
- 详细的文档，提供的用例比较多，可以学习和根据需求改进 。
- 在量化框架上，收费的居多，优矿，米筐，聚宽，不能本地化部署。免费开源的少。
- 支持内部方法的重写，可以方便定制化策略。
- 内置多个指标参数，很丰富，包括Talib 。
（3）使用目标：
- 以研究策略为主，验证策略效果，选择标的股票。
- 不需要太多的参数因子，基于通用指标，可以灵活组合。
- 不做实盘高频交易。
- 适合个人学习使用，探索基本量化方向，避免盲目交易，有数据支撑。
2.架构理解
backtrader的整体架构可以分为以下主要组件：
（1）数据源(Data Feeds)：
backtrader支持多种数据源，包括CSV文件、Pandas DataFrame、实时数据源等。用户可以根据自己的需求选择适合的数据源，并通过数据加载器将数据加载到backtrader中进行处理。
backtrader回测的数据类型是由一系列的点组成的Lines，通常包括以下类别的数据：Open（开盘价）、High（最高价）、Low（最低价）、 Close（收盘价）、Volume（成交量）、OpenInterest（未平仓权益）。Data Feeds（数据加载）、Indicators（技术指标）和Strategies（策略）都会生成 Lines。价格数据中的所有的开盘价按时间组成一条 Line，因此一组含有以上6个类别的价格数据，共有6条 Lines。如果算上DateTime（时间，可以看作是一组数据的主键），一共有7条 Lines。Lines根据需要是可以扩展的。
核心概念：
Line的概念和Python中的list索引不同，Python List中索引-1，表示最后一个数据。
一条Line数据的下标为0表示访问当前时刻数据，-1表示访问下一个数据。在回测过程中，无需知道已经处理了多少条/分钟/天/月，”0”一直指向当前值，下标 -1 来访问下一个值，下标 -2 访问下下一个值。
在backtrader中，-1指的是当前处理数据（索引为0）的上一个数据。
Lines是随时变化的，run的时候，next不断改变Lines的长度，在数据载入，策略，指示器应用中，需要测量Lines的长度。
两个长度函数：len和buflen之间的区别：
- len已处理了Lines
- buflen为数据加载Lines的总数
（2）策略(Strategies)：
backtrader提供了一个基类Strategy，用户可以继承该类并实现自己的交易策略。策略类中定义了一系列的回调函数，用户可以在回测函数中编写具体的交易逻辑。
该模块是回测系统最核心的部分，需要设计交易决策，得出买入/卖出信号。策略类代码包含重要的参数和用于执行策略的功能，要定义的参数或函数名如下：
（1）params：全局参数，可选，用于更改交易策略中变量/参数的值，可用于参数调优。
（2）log：日志，可选，用于记录策略的执行日志，可以打印出该函数提供的日期时间和txt变量。
（3）init：用于初始化交易策略，类中使用的全局变量定义，在其中声明的任何指标都会在next()方法调用之前进行计算。部分python操作符不支持，需要使用bt内置函数来处理，例如bt.And, bt.Or, bt.All, bt.Any等。
（4）notify_order，可选，用于跟踪交易订单（order）的状态。order具有提交，接受，买入/卖出执行和价格，已取消/拒绝等状态。
（5）notify_trade，可选，用于跟踪交易的状态，任何已平仓的交易都将报告毛利和净利润。
（6）next，必选，用于制定交易策略的函数，策略模块最核心的部分。
当满足所有data/indicators的最小周期后，执行将对所有剩余数据点调用。
如period是10 ，最小周期达到后，开始执行next方法。
（7）nextstart()，可选，方法执行一次，在最小周期的data/indicators满足时，默认执行next方法。
如period是10 ，在到达9执行最小周期达到后，执行一次nextstart，之后执行next方法。
（8）prenext()，可选，方法将在所有数据/指标的最小周期满足策略开始执行之前调用执行。
如period是10 ，在1到9执行最小周期之间，执行prenext。
（9）start()，可选，在回测即将开始之前调用，执行一次。
（10）stop()，可选，在回测即将结束之前调用，执行一次。
（11）notify_cashvalue()，可选，接收当前使用的资金余额
（12）notify_fund（），可选，策略的资金和价值发生变化时被调用。用于跟踪和记录策略的现金、价值、基金价值和持仓股票的数量。
（3）指标(Indicators)：
backtrader内置了许多常用的技术指标，如移动平均线、MACD、RSI等。用户可以通过指标类来计算这些指标，并在策略中使用。
backtrader在指标中也集成了TA-Lib库
（4）订单(Order)：
backtrader提供了一套完善的订单管理系统，用户可以通过创建订单对象来执行买入和卖出操作。订单管理系统还支持订单状态的跟踪和管理。
将策略中逻辑做出的决策转换为适合经纪人执行操作的消息，通常在交易策略中调用。
Order将strategy的逻辑做出的决策转换为适合broker执行操作的消息。通过以下方式完成：
创建 ，通过strategy 的方法：buy sell 和close 都可以返回Order的实例
取消，通过strategy的方法：cancel 也可以产生Order实例
通知，notify_order 的方法，也返回Order 实例
订单还作为反馈给用户的通信方法，通知代理中的运行情况
（5）经纪人（Broker）：
通过设置回测的初始自己、佣金费率、税收费率、滑点率等交易条件，模拟不同的订单类型，限价订单，控制订单的有效期，并根据现金检查订单，计算每次交易的现金和权益，保存交易数据。
Trade ：backtrader会自动记录每笔交易的详细信息，包括买入价格、卖出价格、手续费等。用户可以通过这些交易记录进行后续的分析和统计。
Position ：仓位管理 。
（6）策略评估（Analyzers）：
用于分析交易策略的利润和风险，分析交易系统的绩效。
内置各类评价指标，可以加入到评测对象中，对结果进行绩效分析，分析指标：年度回报率，卡尔玛比率，最大回撤，资金杠杆，仓位资金，组合投资值等，是对策略的效果评估参数。
（7）观察者（Observers）：
用于记录交易过程，包括现金、权益、费用以及交易动作、买卖订单等数据。
（8）回测引擎(Backtesting Engine)：
cerebro.run()
backtrader提供了一个强大的回测引擎，用户可以通过指定回测时间段和初始资金等参数来进行策略回测。回测引擎会模拟真实的交易环境，并根据用户定义的策略进行交易。
（9）绘图（Plot）：
分析和可视化(Analysis and Visualization)：
backtrader提供了多种分析工具和可视化功能，用户可以对回测结果进行详细的分析和可视化展示，可以增加图示内容，包括收益曲线、风险指标、交易位置等。
通过图形的方式显示交易测量回测的结果，绘图显示的结果包括三部分类型：现金及权益、交易损益、买卖动作。
绘图设置通过plotinfo来设置，其参数主要有：plot(是否绘图，默认为True)，subplot(是否单独窗口绘图，默认为True，MA类指标该参数为False)，plotname(指标图名，默认为指标类名)，plotabove(绘图位置在数据上方，默认为False)，plotlinelabels， plotymargin， plotyticks，plothlines， plotyhlines， plotforce。
3.代码示例
做一个最简单的SMA测试示例。
取100个股票，进行测试，测试的时间范围从2016年到2020年，一共5年的数据。
在策略中的init（）初始化定义了Indicator ，在next()中买卖操作。
增加了Observer和Analyzer ，把大多数的监控绩效的指标都加入了。
#!/usr/bin/env python
import datetime
import pandas as pd
import numpy as np
import pymysql
import backtrader as bt
import backtrader.feeds as btfeeds
import backtrader.indicators as btind
from sqlalchemy import create_engine
engine_ts = create_engine(
'mysql+pymysql://user:pwd@ip:3306/dbname?charset=utf8&use_unicode=1')
def get_stock_code():
sql = "select t.ts_code from ts_stock_basic t where t.list_status='L' limit 100;"
stock_data = pd.read_sql(sql, con=engine_ts)
return stock_data
def get_code(stock_code):
sql = "select t.trade_date as date,t.`open`,t.high,t.low,t.`close`,t.vol,t.amount from ts_stock_daily t where \
t.ts_code='" + stock_code + "' and t.trade_date > '2016-01-01' and t.trade_date < '2020-12-31' order by date ;"
# print(sql)
# stock_data = pd.read_sql(sql, con=engine_ts,index_col="date")
# 因为BackTrader日期类型必须是datetime ,从数据库中读取的日期类型是date 。
# 读数据，先不设置索引
stock_data = pd.read_sql(sql, con=engine_ts) # ,index_col="date"
# 增加一列，select 字段名是date，赋值到trade_date，同时转datetime类型
stock_data['trade_date'] = pd.to_datetime(stock_data['date'], format='%Y%m%d %H:%M:%S')
# 删除原来的date列
stock_data.drop(columns=['date'])
# 新datetime列作为索引列
stock_data.set_index(['trade_date'], inplace=True)
# 索引列改名
stock_data.index.name = 'date'
# 按backtrader 格式要求，第7列openinterest ，也可以不用
# stock_data['openinterest'] = 0
data = stock_data.sort_index(ascending=True)
#engine_ts.dispose()
return data
class OrderObserver(bt.observer.Observer):
lines = ('created', 'expired',)
plotinfo = dict(plot=True, subplot=True, plotlinelabels=True)
plotlines = dict(
created=dict(marker='*', markersize=8.0, color='lime', fillstyle='full'),
expired=dict(marker='s', markersize=8.0, color='red', fillstyle='full')
)
def next(self):
for order in self._owner._orderspending:
if order.data is not self.data:
continue
if not order.isbuy():
continue
# Only interested in "buy" orders, because the sell orders
# in the strategy are Market orders and will be immediately
# executed
if order.status in [bt.Order.Accepted, bt.Order.Submitted]:
self.lines.created[0] = order.created.price
elif order.status in [bt.Order.Expired]:
self.lines.expired[0] = order.created.price
# CrossOver Strategy
class St_CrossOver(bt.Strategy):
params = (
('smaperiod', 15),
('limitperc', 1.0),
('valid', 7),
('print', False),
)
def log(self, txt, dt=None):
''' Logging function fot this strategy'''
dt = dt or self.data.datetime[0]
if isinstance(dt, float):
dt = bt.num2date(dt).date() # no Hour mintue second
if self.params.print :
print('%s, %s' % (dt.isoformat(), txt))
def notify_order(self, order):
if order.status in [order.Submitted, order.Accepted]:
# Buy/Sell order submitted/accepted to/by broker - Nothing to do
self.log('ORDER ACCEPTED/SUBMITTED', dt=order.created.dt)
self.order = order
return
if order.status in [order.Expired]:
self.log('BUY EXPIRED')
elif order.status in [order.Completed]:
if order.isbuy():
self.log(
'BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f' %
(order.executed.price,
order.executed.value,
order.executed.comm))
else: # Sell
self.log('SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f' %
(order.executed.price,
order.executed.value,
order.executed.comm))
# Sentinel to None: new orders allowed
self.order = None
def __init__(self):
# SimpleMovingAverage on main data
# Equivalent to -> sma = btind.SMA(self.data, period=self.p.smaperiod)
sma = btind.SMA(period=self.p.smaperiod)
# CrossOver (1: up, -1: down) close / sma
self.buysell = btind.CrossOver(self.data.close, sma, plot=True)
# Sentinel to None: new ordersa allowed
self.order = None
def next(self):
if self.order:
# pending order ... do nothing
return
# Check if we are in the market
if self.position:
if self.buysell < 0:
self.log('SELL CREATE, %.2f' % self.data.close[0])
self.sell()
elif self.buysell > 0:
plimit = self.data.close[0] * (1.0 - self.p.limitperc / 100.0)
valid = self.data.datetime.date(0) + \
datetime.timedelta(days=self.p.valid)
self.log('BUY CREATE, %.2f' % plimit)
self.buy(exectype=bt.Order.Limit, price=plimit, valid=valid)
def runstrat(stock_code):
cerebro = bt.Cerebro()
# 初始资金 100,000,000
cerebro.broker.setcash(100000.0)
# 佣金，双边各 0.0003
cerebro.broker.setcommission(commission=0.0003)
# 滑点：双边各 0.0001
cerebro.broker.set_slippage_perc(perc=0.0001)
# 获取数据
stock_df = get_code(stock_code)
start_date = datetime.datetime(2016, 1, 1) # 回测开始时间
end_date = datetime.datetime(2020, 12, 31) # 回测结束时间
data = bt.feeds.PandasData(dataname=stock_df, fromdate=start_date, todate=end_date) # 加载数据
cerebro.adddata(data)
cerebro.addobserver(OrderObserver)
cerebro.addstrategy(St_CrossOver)
tframes = dict(
days=bt.TimeFrame.Days,
weeks=bt.TimeFrame.Weeks,
months=bt.TimeFrame.Months,
years=bt.TimeFrame.Years)
cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='mysharpe')
cerebro.addanalyzer(bt.analyzers.DrawDown,_name = 'mydrown')
cerebro.addanalyzer(bt.analyzers.AnnualReturn,_name = 'myannualreturn')
cerebro.addanalyzer(bt.analyzers.SQN,_name = 'mysqn')
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer,_name = 'mytradeanalyzer')
cerebro.addanalyzer(bt.analyzers.PositionsValue,_name = 'mypositionvalue')
cerebro.addanalyzer(bt.analyzers.Returns,_name = 'myreturns')
cerebro.addanalyzer(bt.analyzers.LogReturnsRolling,timeframe=tframes['years'],_name = 'mylogreturnsrolling')
cerebro.addanalyzer(bt.analyzers.Transactions, _name='mytransactions')
thestrats = cerebro.run()
thestrat = thestrats[0]
print('Sharpe Ratio:', thestrat.analyzers.mysharpe.get_analysis())
print('DrawDown:', thestrat.analyzers.mydrown.get_analysis())
print('AnnualReturn:', thestrat.analyzers.myannualreturn.get_analysis())
print('SQN:', thestrat.analyzers.mysqn.get_analysis())
print('TradeAnalyzer:', thestrat.analyzers.mytradeanalyzer.get_analysis())
print('PositionsValue:', thestrat.analyzers.mypositionvalue.get_analysis())
print('Returns:', thestrat.analyzers.myreturns.get_analysis())
print('LogReturnsRolling:', thestrat.analyzers.mylogreturnsrolling.get_analysis())
print('Transactions:', thestrat.analyzers.mytransactions.get_analysis())
#cerebro.plot()
if __name__ == '__main__':
t1 = datetime.datetime.now()
stock_data = get_stock_code()
for i in range(len(stock_data)):
print(stock_data.loc[i, 'ts_code'])
runstrat(stock_data.loc[i, 'ts_code'])
t2 = datetime.datetime.now()
print('Spend time：', t2 - t1)
engine_ts.dispose()
print('ok!')
详细结果内容多，就不展示了。
结果是用了32.59秒完成计算，100个股票，5年的数据，速度还可以。
Spend time： 0:00:32.591037
ok!
4.小结
backtrader的整体架构是基于事件驱动的，用户通过编写策略类来定义交易逻辑，并通过回测引擎进行策略回测和分析。
通过上面的比较全面的功能测试，基本上覆盖前期学习的backtrader主要功能，完成了一个自定义的策略回测验证。
在不考虑数据采集的情况下，假设数据全部在数据库中，需要后期完成的工作很多：
- 组合策略的定义，肯定不能是简单的SMA，可以结合MACD /RSI/KDJ/ADX 等等指标。
- 时间周期的定义，触发不同指标的效果。
- 策略评估结果保存入库后，进行横向比较。
- 参数调优，最简单的如前篇文章，测试胜率和盈亏比组合，组合参数的递增或递减，绩效结果对比。
- 黑天鹅事件，比如千股跌停的情况，异常极端情况的风险控制，2008年6月次贷危机世界经济危机，2015年6月到8月去杠杆，2016年1月熔断机制上线，还有今年2月5日 。
- 加仓机制实现
- 止损机制实现
- 止盈机制实现
- 仓位管理实现
- 对于不同走势定义不同的策略，如短期打板策略，需要看成交量、换手率，严格的止盈止损。
- 策略模块化，可以是内置类
- 日志，绩效结果模块化，到数据库
- 绩效参考基准，比如沪深500
对于自定义的回测功能或控制内容，欢迎大家可以留言探讨。
版权归原作者 六月闻君 所有， 如有侵权，请联系我们删除。