Backtrader 文档学习- 整体架构功能分析理解

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!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

详细结果内容多，就不展示了。
结果是用了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

对于自定义的回测功能或控制内容，欢迎大家可以留言探讨。