Backtrader 教程：订单 - OCO

Backtrader Backtrader教程   |   2022年7月2日

版本1.9.34.116将OCO （又名 One Cancel Others）添加到回测库中。

笔记

这仅在回测中实现，还没有针对实时经纪人的实现

笔记

更新为1.9.36.116版本。盈透证券支持StopTrail 、 StopTrailLimit和OCO 。

  • OCO始终将组中的oco一个订单指定为参数oco

  • StopTrailLimit ：代理仿真和IB代理具有 asme 行为。指定： price作为初始止损触发价格（同时指定trailamount ），然后plimi作为初始限价。两者之差将决定limitoffset （限价与止损触发价之间的距离）

使用模式试图保持用户友好。因此，如果策略中的逻辑决定现在是发出订单的时刻，则可以像这样使用OCO ： 

def next(self):
    ...
    o1 = self.buy(...)
    ...
    o2 = self.buy(..., oco=o1)
    ...
    o3 = self.buy(..., oco=o1)  # or even oco=o2, o2 is already in o1 group

简单的。 1 st order o1将类似于组长。通过使用oco命名参数指定o1 ， o2和o3成为OCO 组的一部分。看到片段中的注释表明o3也可以通过指定o2成为组的一部分（它已经是组的一部分）

随着小组的成立，将发生以下情况：

  • 如果该组中的任何订单被运行、取消或到期，其他订单将被取消

下面的示例展示了OCO概念。带有情节的标准运行： 

$ ./oco.py --broker cash=50000 --plot

笔记

现金增加到50000 ，因为资产达到4000的价值并且1件的 3 个订单至少需要12000货币单位（经纪人的默认值为10000 ）

用下面的图表。

这实际上并没有提供太多信息（它是标准的SMA Crossover策略）。该示例运行以下操作：

  • 当快速 SMA 穿过慢速 SMA 向上时，发出 3 个订单

  • order1是一个Limit订单，将在limdays天（策略参数）到期， close价减少一个百分比作为限价

  • order2是一个Limit订单，到期时间更长，限价更低。

  • order3为Limit单，进一步降低限价

因此order2和order3的运行不会发生，因为：

  • order1将首先运行，这应该会触发其他人的取消

或者

  • order1将过期，这将触发其他订单的取消

系统保留 3 个订单的ref标识符，并且仅当notify_order中的三个ref标识符显示为Completed 、 Cancelled 、 Margin或Expired时才会发出新的buy

在持有一些柱的头寸后简单地退出。

为了尝试跟踪实际运行，会生成文本输出。其中一些： 

2005-01-28: Oref 1 / Buy at 2941.11055
2005-01-28: Oref 2 / Buy at 2896.7722
2005-01-28: Oref 3 / Buy at 2822.87495
2005-01-31: Order ref: 1 / Type Buy / Status Submitted
2005-01-31: Order ref: 2 / Type Buy / Status Submitted
2005-01-31: Order ref: 3 / Type Buy / Status Submitted
2005-01-31: Order ref: 1 / Type Buy / Status Accepted
2005-01-31: Order ref: 2 / Type Buy / Status Accepted
2005-01-31: Order ref: 3 / Type Buy / Status Accepted
2005-02-01: Order ref: 1 / Type Buy / Status Expired
2005-02-01: Order ref: 3 / Type Buy / Status Canceled
2005-02-01: Order ref: 2 / Type Buy / Status Canceled
...
2006-06-23: Oref 49 / Buy at 3532.39925
2006-06-23: Oref 50 / Buy at 3479.147
2006-06-23: Oref 51 / Buy at 3390.39325
2006-06-26: Order ref: 49 / Type Buy / Status Submitted
2006-06-26: Order ref: 50 / Type Buy / Status Submitted
2006-06-26: Order ref: 51 / Type Buy / Status Submitted
2006-06-26: Order ref: 49 / Type Buy / Status Accepted
2006-06-26: Order ref: 50 / Type Buy / Status Accepted
2006-06-26: Order ref: 51 / Type Buy / Status Accepted
2006-06-26: Order ref: 49 / Type Buy / Status Completed
2006-06-26: Order ref: 51 / Type Buy / Status Canceled
2006-06-26: Order ref: 50 / Type Buy / Status Canceled
...
2006-11-10: Order ref: 61 / Type Buy / Status Canceled
2006-12-11: Oref 63 / Buy at 4032.62555
2006-12-11: Oref 64 / Buy at 3971.8322
2006-12-11: Oref 65 / Buy at 3870.50995
2006-12-12: Order ref: 63 / Type Buy / Status Submitted
2006-12-12: Order ref: 64 / Type Buy / Status Submitted
2006-12-12: Order ref: 65 / Type Buy / Status Submitted
2006-12-12: Order ref: 63 / Type Buy / Status Accepted
2006-12-12: Order ref: 64 / Type Buy / Status Accepted
2006-12-12: Order ref: 65 / Type Buy / Status Accepted
2006-12-15: Order ref: 63 / Type Buy / Status Expired
2006-12-15: Order ref: 65 / Type Buy / Status Canceled
2006-12-15: Order ref: 64 / Type Buy / Status Canceled

发生以下情况：

  • 第一批订单发出。订单 1 到期，订单 2 和 3 被取消。正如预期的那样。

  • 几个月后，又发出了另外一批 3 份订单。在这种情况下，订单 49 Completed ，50 和 51 立即取消

  • 最后一批和第一批一样

现在让我们检查一下没有OCO的行为： 

$ ./oco.py --strat do_oco=False --broker cash=50000

2005-01-28: Oref 1 / Buy at 2941.11055
2005-01-28: Oref 2 / Buy at 2896.7722
2005-01-28: Oref 3 / Buy at 2822.87495
2005-01-31: Order ref: 1 / Type Buy / Status Submitted
2005-01-31: Order ref: 2 / Type Buy / Status Submitted
2005-01-31: Order ref: 3 / Type Buy / Status Submitted
2005-01-31: Order ref: 1 / Type Buy / Status Accepted
2005-01-31: Order ref: 2 / Type Buy / Status Accepted
2005-01-31: Order ref: 3 / Type Buy / Status Accepted
2005-02-01: Order ref: 1 / Type Buy / Status Expired

就是这样，这并不多（没有订单运行，也不需要图表）

  • 该批订单下达

  • 订单 1 到期，但由于策略获取了参数do_oco= False ，订单 2 和 3 不属于OCO组

  • 因此，订单 2 和 3 不会被取消，并且因为默认的到期增量是1000天后，它们永远不会随着样本的可用数据而到期（2 年的数据）

  • 系统从不发出第二轮订单。

示例使用

$ ./oco.py --help
usage: oco.py [-h] [--data0 DATA0] [--fromdate FROMDATE] [--todate TODATE]
              [--cerebro kwargs] [--broker kwargs] [--sizer kwargs]
              [--strat kwargs] [--plot [kwargs]]

Sample Skeleton

optional arguments:
  -h, --help           show this help message and exit
  --data0 DATA0        Data to read in (default:
                       ../../datas/2005-2006-day-001.txt)
  --fromdate FROMDATE  Date[time] in YYYY-MM-DD[THH:MM:SS] format (default: )
  --todate TODATE      Date[time] in YYYY-MM-DD[THH:MM:SS] format (default: )
  --cerebro kwargs     kwargs in key=value format (default: )
  --broker kwargs      kwargs in key=value format (default: )
  --sizer kwargs       kwargs in key=value format (default: )
  --strat kwargs       kwargs in key=value format (default: )
  --plot [kwargs]      kwargs in key=value format (default: )

示例代码

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)


import argparse
import datetime

import backtrader as bt


class St(bt.Strategy):
    params = dict(
        ma=bt.ind.SMA,
        p1=5,
        p2=15,
        limit=0.005,
        limdays=3,
        limdays2=1000,
        hold=10,
        switchp1p2=False,  # switch prices of order1 and order2
        oco1oco2=False,  # False - use order1 as oco for order3, else order2
        do_oco=True,  # use oco or not
    )

    def notify_order(self, order):
        print('{}: Order ref: {} / Type {} / Status {}'.format(
            self.data.datetime.date(0),
            order.ref, 'Buy' * order.isbuy() or 'Sell',
            order.getstatusname()))

        if order.status == order.Completed:
            self.holdstart = len(self)

        if not order.alive() and order.ref in self.orefs:
            self.orefs.remove(order.ref)

    def __init__(self):
        ma1, ma2 = self.p.ma(period=self.p.p1), self.p.ma(period=self.p.p2)
        self.cross = bt.ind.CrossOver(ma1, ma2)

        self.orefs = list()

    def next(self):
        if self.orefs:
            return  # pending orders do nothing

        if not self.position:
            if self.cross > 0.0:  # crossing up

                p1 = self.data.close[0] * (1.0 - self.p.limit)
                p2 = self.data.close[0] * (1.0 - 2 * 2 * self.p.limit)
                p3 = self.data.close[0] * (1.0 - 3 * 3 * self.p.limit)

                if self.p.switchp1p2:
                    p1, p2 = p2, p1

                o1 = self.buy(exectype=bt.Order.Limit, price=p1,
                              valid=datetime.timedelta(self.p.limdays))

                print('{}: Oref {} / Buy at {}'.format(
                    self.datetime.date(), o1.ref, p1))

                oco2 = o1 if self.p.do_oco else None
                o2 = self.buy(exectype=bt.Order.Limit, price=p2,
                              valid=datetime.timedelta(self.p.limdays2),
                              oco=oco2)

                print('{}: Oref {} / Buy at {}'.format(
                    self.datetime.date(), o2.ref, p2))

                if self.p.do_oco:
                    oco3 = o1 if not self.p.oco1oco2 else oco2
                else:
                    oco3 = None

                o3 = self.buy(exectype=bt.Order.Limit, price=p3,
                              valid=datetime.timedelta(self.p.limdays2),
                              oco=oco3)

                print('{}: Oref {} / Buy at {}'.format(
                    self.datetime.date(), o3.ref, p3))

                self.orefs = [o1.ref, o2.ref, o3.ref]

        else:  # in the market
            if (len(self) - self.holdstart) >= self.p.hold:
                self.close()


def runstrat(args=None):
    args = parse_args(args)

    cerebro = bt.Cerebro()

    # Data feed kwargs
    kwargs = dict()

    # Parse from/to-date
    dtfmt, tmfmt = '%Y-%m-%d', 'T%H:%M:%S'
    for a, d in ((getattr(args, x), x) for x in ['fromdate', 'todate']):
        if a:
            strpfmt = dtfmt + tmfmt * ('T' in a)
            kwargs[d] = datetime.datetime.strptime(a, strpfmt)

    # Data feed
    data0 = bt.feeds.BacktraderCSVData(dataname=args.data0, **kwargs)
    cerebro.adddata(data0)

    # Broker
    cerebro.broker = bt.brokers.BackBroker(**eval('dict(' + args.broker + ')'))

    # Sizer
    cerebro.addsizer(bt.sizers.FixedSize, **eval('dict(' + args.sizer + ')'))

    # Strategy
    cerebro.addstrategy(St, **eval('dict(' + args.strat + ')'))

    # Execute
    cerebro.run(**eval('dict(' + args.cerebro + ')'))

    if args.plot:  # Plot if requested to
        cerebro.plot(**eval('dict(' + args.plot + ')'))


def parse_args(pargs=None):
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
        description=(
            'Sample Skeleton'
        )
    )

    parser.add_argument('--data0', default='../../datas/2005-2006-day-001.txt',
                        required=False, help='Data to read in')

    # Defaults for dates
    parser.add_argument('--fromdate', required=False, default='',
                        help='Date[time] in YYYY-MM-DD[THH:MM:SS] format')

    parser.add_argument('--todate', required=False, default='',
                        help='Date[time] in YYYY-MM-DD[THH:MM:SS] format')

    parser.add_argument('--cerebro', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--broker', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--sizer', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--strat', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--plot', required=False, default='',
                        nargs='?', const='{}',
                        metavar='kwargs', help='kwargs in key=value format')

    return parser.parse_args(pargs)


if __name__ == '__main__':
    runstrat()

推荐阅读

相关文章

Backtrader砖块

Renko Bricks 是呈现价格演变的另一种方式，其中价格比时间发挥更重要的作用。这已在1.9.54.122的1.9.54.122版本中作为过滤器引入Stockcharts 对 Renko Bricks 有很好的参考。

Backtrader策略选择

休士顿我们有一个问题： cerebro 不应多次运行。这不是第1次 ，而不是认为用户做错了，这似乎是一个用例。 这个有趣的用例是通过票证177出现的。在这种情况下， cerebro 被多次用于评估从外部数据源获取的不同策略。 backtrader 仍然可以支持此用例，但不能以直接尝试的方式支持。

Backtrader 教程：订单 - OCO

版本1.9.34.116将OCO （又名 One Cancel Others）添加到回测库中。笔记这仅在回测中实现，还没有针对实时经纪人的实现笔记更新为1.9.36.116版本。盈透证券支持StopTrail 、 StopTrailLimit和OCO 。

Backtrader观察员和统计

在 backtrader 内部运行的策略主要处理数据 和 指针。 数据被添加到Cerebro 实例中，并最终成为策略输入的一部分（解析并用作实例的属性），而指针由策略本身声明和管理。

Backtrader教程：数据馈送 - 重新采样

如果数据仅在单个时间范围内可用，并且必须在不同的时间范围内进行分析，则是时候进行一些重新采样了。 “重采样”实际上应该称为“上采样”，因为一个人从源时间帧到更大的时间帧（例如：几天到几周） backtrader 内置支持通过筛选器对象传递原始数据，从而进行重采样。

Backtrader教程：数据馈送

backtrader 附带一组 Data Feed 解析器（在编写所有基于CSV时），可让您从不同的来源加载数据。

Backtrader扩展数据馈送

GitHub 中的问题实际上是在推动文档部分的完成，或者说明我了解 backtrader 是否具有我从最初时刻就设想的易用性和灵活性以及在此过程中做出的决定。 在本例中为问题 #9。

Backtrader教程：观察者 - 统计

在内部backtrader 运行的策略主要处理 data feeds 和 指针。 Data feeds 被添加到Cerebro 实例中，并最终成为策略输入的一部分（解析并用作实例的属性），而指针则由策略本身声明和管理。

Backtrader 多数据范例

社区中的几个主题似乎以如何跟踪订单为导向，特别是当几个data feeds在起作用时，还包括当多个订单一起工作时，

Backtrader教程：分析仪 - PyFolio

注意 从（至少）2017-07-25pyfolio 开始，API已更改，不再 create_full_tear_sheet 具有 gross_lev 作为命名参数的参数。