BacktraderOCO订单

Backtrader   |   2022年6月21日

Release1.9.34.116 将 OCO （又名One Cancel Others）添加到回溯测试武器库中。

注意

这仅在回溯测试中实现，并且还没有针对即时代理的实现

注意

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

  • OCO 始终将组中的第 1个顺序指定为参数 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个顺序o1将类似于组长， o2 o3并通过o1指定命名参数成为 OCO 组的一oco部分。查看代码段中的注释指示o3也可以通过指定o2（已经是组的一部分）成为组的一部分

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

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

下面的示例将这个OCO 概念付诸实践。带有绘图的标准运行：

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

注意

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

如下图所示。

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

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

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

  • order2 是到期 Limit 期限更长且限价降低得多的订单。

  • order3 是进一 Limit 步降低限价的订单

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

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

或

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

系统保留ref 3 个订单的识别码，并且仅当buy这三ref个Completed标识码被视为 notify_order 、 、 或 CancelledMarginExpired

退出是在持有某些柱的仓位后完成的。

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

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批 订单发出。订单 1 过期，2 和 3 被取消。不出所料。

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

  • last批就像1st一样

现在让我们检查一下没有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 年的数据）而过期

  • 系统从不发出第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佣金计划

backtrader 的诞生是出于必要。我自己的...有一种感觉，我控制着自己的回溯测试平台，可以尝试新的想法。但是，在这样做并且从一开始就完全 open 采购它时，很明显它必须有一种方法来满足他人的需求和愿望。 作为未来的交易者，我本可以选择基于点的计算和每轮佣金的固定价格，但这将是一个错误。

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

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

Backtrader股票筛选

在寻找其他一些东西时，我在StackOverlow家族网站之一上遇到了一个问题：Quantitative Finance aka Quant StackExchange。问题： 它被标记为Python，因此值得一看的是 backtrader 是否能够胜任这项任务。 分析仪本身 该问题似乎适合用于简单的分析器。

BacktraderPyFolio 集成

注意 2017年2月 pyfolio API 已更改，不再 create_full_tear_sheet 具有 gross_lev 作为命名参数的参数。

Backtrader教程：过滤器 - 参考

工作阶段筛检程序 类 backtrader.filters。

Backtraderta-lib 集成

即使 backtrader 提供了已经 high 数量的内置指针，并且开发指针主要是定义输入，输出和以自然的方式编写公式的问题，有些人也希望使用TA-LIB。

Backtrader教程：经纪商

经纪商仿真器该模拟支持不同的订单类型，根据当前现金检查提交的订单现金需求，跟踪每次反复运算的cerebro 现金和价值，并在不同数据上保持当前位置。

Backtrader教程：观察者 - 统计

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

Backtrader蟒蛇隐藏的力量3

Last，但并非最不重要的一点是，在这个系列中，关于如何在 backtrader 中使用Python的隐藏功能是一些神奇变量是如何出现的。

Backtrader教程：指针 - ta-lib

即使 backtrader 提供了已经 high 数量的内置指针，并且开发指针主要是定义输入，输出和以自然的方式编写公式的问题，有些人也希望使用TA-LIB。