bt 包

bt

algos 模块

用于创建策略逻辑的算法集合。

class bt.algos.CapitalFlow(amount)[source]

基础类:Algo

用于模拟资本流动。流动可以是流入或流出。

该算法可用于模拟资金流动。例如,养老基金可能由于每月的供款而有资金流入。该算法将影响目标节点的资金,而不会影响该节点的回报。

由于这是作为调整建模的,资本将保留在策略中,直到进行重新分配/再平衡。

Args:
  • amount (float): 调整的金额

class bt.algos.CloseDead[source]

基础类: Algo

关闭所有价格为零的头寸(我们假设这些股票已经失效),如果它们偶然进入temp['weights'],则将其从中移除。 在Rebalance()之前调用。

在正常的工作流程中,这是不需要的,因为这些证券不会被SelectAll(include_no_data=False)或类似的方法选中,而且Rebalance()会关闭不在temp['weights']中的头寸。然而,在某些情况下,如果由于某些原因无法使用include_no_data=False或使用了某些修改的加权方法,CloseDead()将允许避免错误。

Requires:
  • 权重

class bt.algos.ClosePositionsAfterDates(close_dates)[source]

基础类:Algo

在给定日期后关闭证券头寸。 这可以用于确保已到期/赎回的证券头寸被关闭。它也可以作为策略的一部分使用,例如确保策略不持有任何到期时间少于一年的证券。

请注意,如果在堆栈中的RunPeriod算法之后放置,实际的头寸平仓将在提供的日期之后发生。为了使此操作有效,证券的“价格”(即使已到期)必须存在直到该日期。或者,使用@run_always装饰器运行此操作以立即平仓。

还要注意,这个算法不使用 temp['weights'] 和 Rebalance 进行操作。 这是为了确保对冲(在该工作流中被排除)也会在必要时被关闭。

Args:
  • close_dates (str): 一个按证券名称索引的数据框的名称,包含列 “date”: 我们希望尽快平仓的日期

Sets:
  • target.perm['closed'] : 用于跟踪哪些证券已经关闭

class bt.algos.Debug(name=None)[source]

基础类: Algo

实用算法,当触发时调用 pdb.set_trace。

在调试会话中,‘target’是可用的,并且可以通过StrategyBase接口进行检查。

class bt.algos.HedgeRisks(measures, pseudo=False, strategy=None, throw_nan=True)[source]

基础类: Algo

使用选定的工具对冲风险措施。

确保之前已经调用了UpdateRisk算法。

Args:
  • measures (list): 要对冲的风险度量名称

  • pseudo (bool): 是否使用伪逆来计算逆雅可比矩阵。如果为False,当选择的工具数量不等于测量数量,或者雅可比矩阵为奇异时,将会失败。

  • strategy (StrategyBase): 如果提供,将除了对冲目标的风险外,还会对冲此策略的风险。这是为了允许分别跟踪对冲和未对冲的表现。请注意,在根节点的子节点的深度优先遍历中,risk_strategy 必须出现在 'target' 之前,否则在对冲之前,risk_strategy 的头寸将不会被更新。

  • throw_nan (bool): 是否在nan对冲名义金额时抛出异常,而不是简单地不进行对冲。

Requires:
  • 已选择

class bt.algos.LimitDeltas(limit=0.1)[source]

基础类: Algo

根据权重增量限制修改 temp['weights']。

基本上,如果我们想限制证券的目标权重每天可以变化多少,可以使用这个方法。当我们希望对某一天实际可以交易的数量更加保守,而不影响市场时,这很有用。

例如,如果我们有一个策略,目前持有一个证券的100%多头,而权重算法将新权重设置为0%,但我们将此算法与0.1的限制一起使用,新的目标权重将是90%而不是0%。

Args:
  • limit (float, dict): 权重变化限制。如果是浮点数,这将是所有证券的全局限制。如果是字典,您可以指定按代码的限制。

Sets:
  • 权重

Requires:
  • 权重

class bt.algos.LimitWeights(limit=0.1)[source]

基础类: Algo

根据重量限制修改temp['weights']。

这是一个围绕ffn的limit_weights的算法包装器。此算法的目的是限制任何单一特定资产的权重。例如,某些算法可能会设置一些相当极端的权重,这些权重可能不可接受。因此,我们可以使用此算法来限制极端权重。然后,多余的权重将按比例重新分配给其他资产,根据它们当前的权重。

有关更多信息,请参阅ffn的limit_weights。

Args:
  • limit (float): 重量限制。

Sets:
  • 权重

Requires:
  • 权重

class bt.algos.Not(algo)[source]

基础类: Algo

流量控制算法

它对于“反转”其他流程控制算法非常有用, 例如 Not( RunAfterDate(…) ), Not( RunAfterDays(…) ), 等等

Args:
  • list_of_algos (Algo): 要运行并反转其返回值的算法

class bt.algos.Or(list_of_algos)[source]

基础类: Algo

流量控制算法

它对于将多个信号合并为一个信号非常有用。 例如,我们可能希望两个不同的再平衡信号能够协同工作:

runOnDateAlgo = bt.algos.RunOnDate(pdf.index[0]) # 其中 pdf.index[0] 是我们时间序列中的第一个日期 runMonthlyAlgo = bt.algos.RunMonthly() orAlgo = Or([runMonthlyAlgo,runOnDateAlgo])

如果它是第一个日期或每月的第一天,orAlgo 将返回 True

Args:
  • list_of_algos: 可迭代的算法列表。 运行每个算法,如果任何算法返回true,则返回true。

class bt.algos.PTE_Rebalance(PTE_volatility_cap, target_weights, lookback=<DateOffset: months=3>, lag=<DateOffset: days=0>, covar_method='standard', annualization_factor=252)[source]

基础类: Algo

当静态权重的PTE超过某个水平时,触发重新平衡。

Args:
  • PTE_volatility_cap: 年化波动率目标

  • target_weights: 需要与价格数据框具有相同索引的权重数据框

  • lookback (DateOffset): 用于估计波动率的回溯期

  • lag (DateOffset): 计算协方差需要等待的时间量

  • covar_method: 计算波动率的方法

  • annualization_factor: 用于年化的周期数。 假设目标波动率已经通过此因子进行了年化。

class bt.algos.PrintDate(name=None)[source]

基础类: Algo

这个算法简单地打印当前日期。

对于调试目的可能有用。

class bt.algos.PrintInfo(fmt_string='{name} {now}')[source]

基础类: Algo

打印出与目标策略相关的信息。对于调试目的非常有用。

Args:
  • fmt_string (str): 一个稍后将使用目标对象的 __dict__ 属性进行格式化的字符串。因此,您应该在大括号({ })内提供您想要检查的内容。

Ex:

PrintInfo('策略 {name} : {now}')

这将在每次调用时打印出名称和日期(现在)。 基本上,你提供一个字符串,该字符串将使用 target.__dict__ 进行格式化。

class bt.algos.PrintRisk(fmt_string='')[source]

基础类: Algo

此算法打印风险数据。

Args:
  • fmt_string (str): 一个稍后将使用目标对象的风险属性进行格式化的字符串。因此,您应该在大括号({ })内提供您想要检查的内容。如果未提供,将打印整个字典而不进行格式化。

class bt.algos.PrintTempData(fmt_string=None)[source]

基础类: Algo

这个算法打印温度数据。

对调试很有用。

Args:
  • fmt_string (str): 一个稍后将使用目标的临时字典进行格式化的字符串。因此,你应该在大括号({ })内提供你想要检查的内容。

class bt.algos.Rebalance[source]

基础类: Algo

根据 temp['weights'] 重新平衡资本

根据temp['weights']重新平衡资本。如果持仓开放但不在target_weights中,也会关闭持仓。这通常是在目标权重设置后调用的最后一个Algo。

Requires:
  • 权重

  • 现金(可选):您可以在temp上设置一个‘cash’值。这应该是一个介于0-1之间的数字,并确定要留出的现金量。例如,如果cash=0.3,策略将分配其价值的70%到提供的权重,剩余的30%将保留为现金。如果未提供此值(默认),策略的全部价值将分配给证券。

  • notional_value(可选):仅适用于fixed_income目标。这是将应用于权重的总名义价值的基础值。

class bt.algos.RebalanceOverTime(n=10)[source]

基础类: Algo

类似于Rebalance,但在n个周期内重新平衡到目标权重。

在n个周期内重新平衡以达到目标权重。将权重增量分散在n个周期内。

如果我们想要做出更保守的再平衡假设,这可能很有用。一些策略可能会在分配上产生大的波动。假设这种再平衡可以在一个特定时期结束时发生可能是不合理的。因此,这个算法可以用来模拟在n个时期内的再平衡。

这通常用于月度策略中,我们希望将再平衡分散在5或10天内。

Note:

在这种情况下,此算法将需要 run_always 包装器。例如,RunMonthly 将在第一天返回 True,并且 RebalanceOverTime 将被“激活”。然而,RunMonthly 将在该月的其余几天返回 False。因此,我们必须指定我们希望始终运行此算法。

Args:
  • n (int): 重新平衡发生的周期数。

Requires:
  • 权重

class bt.algos.ReplayTransactions(transactions)[source]

基础类: Algo

重放一系列已执行的交易。 这对于获取实际发生的交易记录,并衡量与假设策略的表现非常有用。 特别是,可以重放backtest.Result.get_transactions的输出。

请注意,这允许报告交易的时间戳和价格完全任意,因此虽然策略可能会每天跟踪表现,但它将根据实际交易的位置准确计算交易的实际PNL,并且策略上的bidofferpaid属性将捕捉相对于每日价格测量的“滑点”。

Args:
  • transactions (str): 一个MultiIndex数据框的名称,格式为 日期, 证券 | 数量, 价格。 请注意,此模式遵循backtest.Result.get_transactions的输出

class bt.algos.Require(pred, item, if_none=False)[源代码]

基础类: Algo

流量控制算法。

该算法返回一个临时条目上的谓词值。用于控制流程。

例如,我们可能希望确保选择了一些项目。 我们可以传递一个lambda函数来检查'selected'的长度:

pred=lambda x: len(x) == 0 item=’selected’

Args:
  • pred (Algo): 给定策略返回布尔值的函数。这是Algo的定义。然而,这通常与简单的lambda函数一起使用。

  • item (str): temp 中的一个项目。

  • if_none (bool): 如果所需项不在temp中或其值为None时的结果

class bt.algos.ResolveOnTheRun(on_the_run, include_no_data=False, include_negative=False)[source]

基础类: Algo

查看设置在 temp['selected'] 中的证券,并搜索与提供的数据中“别名”名称匹配的证券名称。然后将别名替换为适用于给定日期的基础证券名称,并将其设置回 temp['selected']。

Args:
  • on_the_run (str): Name of a Data frame with
    • 列设置为“动态”股票代码名称

    • 索引设置为回测的时间线

    • values 是给定日期使用的实际安全名称

  • include_no_data (bool): 是否包含没有数据的证券?

  • include_negative (bool): 是否包含价格为负或为零的证券?

Requires:
  • 已选择

Sets:
  • 已选择

class bt.algos.RollPositionsAfterDates(roll_data)[source]

基础类: Algo

根据提供的地图滚动证券。 这可以用于任何具有“在运行”和“不在运行”版本的证券(国债、指数互换等)。

还要注意,这个算法不使用temp['weights']和Rebalance进行操作。 这是为了确保对冲(在该工作流中被排除)也会根据需要滚动。

Args:
  • roll_data (str): the name of a dataframe indexed by security name, with columns
    • “date”: 滚动可以发生的第一个日期

    • “target”:我们正在转入的证券名称

    • “factor”: 转换因子。原始证券的一个单位转换为新证券的“factor”单位。

Sets:
  • target.perm['rolled'] : 用于跟踪哪些证券已经滚动

class bt.algos.RunAfterDate(date)[source]

基础类: Algo

在日期过去后返回True

Args:
  • 日期: 开始交易之后的日期

Note:

这对于依赖追踪平均值的算法非常有用,在这些算法中,您不希望在没有积累一定量的数据之前开始交易

class bt.algos.RunAfterDays(days)[source]

基础类: Algo

在特定数量的“预热”交易日过去后返回True

Args:
  • days (int): 开始前等待的交易天数

Note:

这对于依赖追踪平均值的算法非常有用,在这些算法中,您不希望在没有积累一定量的数据之前开始交易。

class bt.algos.RunDaily(run_on_first_date=True, run_on_end_of_period=False, run_on_last_date=False)[source]

基础类:RunPeriod

在日期变化时返回True。

Args:
  • run_on_first_date (bool): 确定是否在算法首次调用时运行

  • run_on_end_of_period (bool): 确定它是否应在周期结束时运行 或在开始时运行

  • run_on_last_date (bool): 确定是否在算法最后一次调用时运行

如果目标日期的天数与上一次(或下一次,如果run_on_end_of_period)日期相比发生了变化,则返回True,否则返回False。适用于每日再平衡策略。

compare_dates(now, date_to_compare)[source]
class bt.algos.RunEveryNPeriods(n, offset=0)[source]

基础类: Algo

该算法每n个周期运行一次。

Args:
  • n (int): 每n个周期运行一次

  • offset (int): 适用于第一次运行。如果为0,此算法将在第一次调用时运行。

This Algo can be useful for the following type of strategy:

每个月,选择表现最好的5个。持有它们3个月。

然后,您可以创建3种具有不同偏移量的策略,并创建一个主策略,该策略将向每种策略分配等量的资金。

class bt.algos.RunIfOutOfBounds(tolerance)[source]

基础类: Algo

如果任何目标权重偏离超过容忍度,此算法将返回true。例如,如果容忍度设置为0.5,并且某个证券的目标权重从0.2增长到超过0.3,它将运行。

一种策略,其中每季度或每当任何证券的权重偏离超过20%时进行再平衡,可以通过以下方式实现:

或([runQuarterlyAlgo, runIfOutOfBoundsAlgo(0.2)])

Args:
  • tolerance (float): 每个证券权重的允许偏差。

Requires:
  • 权重

class bt.algos.RunMonthly(run_on_first_date=True, run_on_end_of_period=False, run_on_last_date=False)[source]

基础类:RunPeriod

在月份更改时返回True。

Args:
  • run_on_first_date (bool): 确定是否在算法首次调用时运行

  • run_on_end_of_period (bool): 确定它是否应在周期结束时运行 或在开始时运行

  • run_on_last_date (bool): 确定是否在算法最后一次调用时运行

如果目标.now的月份相对于上一个(或下一个)日期发生了变化,则返回True,否则返回False。适用于月度再平衡策略。

compare_dates(now, date_to_compare)[source]
class bt.algos.RunOnDate(*dates)[source]

基础类: Algo

在特定的一组日期上返回True。

Args:
  • dates (list): 运行算法的日期列表。

class bt.algos.RunOnce[source]

基础类: Algo

第一次运行时返回True,然后返回False。

Args:
  • run_on_first_call: 布尔值,决定算法第一次调用时是否运行

顾名思义,该算法只运行一次。在我们希望只运行一次逻辑的情况下非常有用(例如买入并持有)。

class bt.algos.RunPeriod(run_on_first_date=True, run_on_end_of_period=False, run_on_last_date=False)[source]

基础类: Algo

abstract compare_dates(now, date_to_compare)[source]
class bt.algos.RunQuarterly(run_on_first_date=True, run_on_end_of_period=False, run_on_last_date=False)[source]

基础类:RunPeriod

在季度变化时返回True。

Args:
  • run_on_first_date (bool): 确定是否在算法首次调用时运行

  • run_on_end_of_period (bool): 确定它是否应在周期结束时运行 或在开始时运行

  • run_on_last_date (bool): 确定是否在算法最后一次调用时运行

如果目标.now的季度相对于上一个(或下一个)日期发生了变化,则返回True,否则返回False。适用于季度再平衡策略。

compare_dates(now, date_to_compare)[source]
class bt.algos.RunWeekly(run_on_first_date=True, run_on_end_of_period=False, run_on_last_date=False)[source]

基础类:RunPeriod

在周变化时返回True。

Args:
  • run_on_first_date (bool): 确定是否在算法首次调用时运行

  • run_on_end_of_period (bool): 确定它是否应在周期结束时运行 或在开始时运行

  • run_on_last_date (bool): 确定是否在算法最后一次调用时运行

如果目标.now的周相对于上一个(或下一个)日期发生了变化,则返回True,否则返回False。适用于每周再平衡策略。

compare_dates(now, date_to_compare)[source]
class bt.algos.RunYearly(run_on_first_date=True, run_on_end_of_period=False, run_on_last_date=False)[source]

基础类:RunPeriod

在年份变化时返回True。

Args:
  • run_on_first_date (bool): 确定是否在算法首次调用时运行

  • run_on_end_of_period (bool): 确定它是否应在周期结束时运行 或在开始时运行

  • run_on_last_date (bool): 确定是否在算法最后一次调用时运行

如果目标.now的年份相对于上一个(或下一个)日期发生了变化,则返回True,否则返回False。适用于年度再平衡策略。

compare_dates(now, date_to_compare)[source]
class bt.algos.ScaleWeights(scale)[source]

基础类: Algo

根据自身的缩放版本设置 temp['weights']。 在使用 FixedIncomeStrategy 时,这对于做空或放大/缩小非常有用。

Args:
  • scale (float): 缩放因子

Sets:
  • 权重

Requires:
  • 权重

class bt.algos.SelectActive(name=None)[source]

基础类: Algo

根据过滤条件设置temp['selected'],以排除在某个日期之后已关闭或滚动的证券,使用ClosePositionsAfterDates或RollPositionsAfterDates。这确保不会再次选择它们进行加权(即使它们有价格)。

Requires:
  • 已选择

  • perm['closed'] 或 perm['rolled']

Sets:
  • 已选择

class bt.algos.SelectAll(include_no_data=False, include_negative=False)[source]

基础类: Algo

设置 temp['selected'] 为所有证券(基于 universe)。

选择所有证券并将它们保存在 temp['selected'] 中。 默认情况下,SelectAll 不包括在当前日期没有数据(nan)或价格为零或负数的证券。

Args:
  • include_no_data (bool): 是否包含没有数据的证券?

  • include_negative (bool): 是否包含价格为负或为零的证券?

Sets:
  • 已选择

class bt.algos.SelectHasData(lookback=<DateOffset: months=3>, min_count=None, include_no_data=False, include_negative=False)[source]

基础类: Algo

根据宇宙中所有满足数据要求的项目设置temp['selected']。

这是SelectAll的一个更高级版本。适用于选择需要一定数量数据的股票代码,以便未来的算法能够正常运行。

例如,如果我们需要具有3个月或更长时间数据的项目,我们可以使用这个算法,回溯期为3个月。

当提供回溯期时,提供最小计数也是明智的。 这基本上是在回溯期内需要的数据点数量,以便将系列视为有效。例如,在我们上面的3个月回溯中,我们可能希望将最小计数指定为57 -> 一个典型的交易月大约有20个交易日。如果我们考虑一些假期,我们可以使用57或58。这真的取决于你。

如果不指定min_count,min_count将默认使用ffn的get_num_days_required。

Args:
  • lookback (DateOffset): 一个确定回溯周期的 DateOffset。

  • min_count (int): 序列被视为有效所需的最少天数。如果未提供,则使用ffn的get_num_days_required来估计所需的点数。

  • include_no_data (bool): 是否包含没有数据的证券?

  • include_negative (bool): 是否包含价格为负或为零的证券?

Sets:
  • 已选择

class bt.algos.SelectMomentum(n, lookback=<DateOffset: months=3>, lag=<DateOffset: days=0>, sort_descending=True, all_or_none=False)[source]

基础类: AlgoStack

根据简单的动量过滤器设置 temp['selected']。

根据给定回顾期内的总回报选择前n个证券。这只是围绕一个包含两个算法的AlgoStack的封装:StatTotalReturn和SelectN。

请注意,应在调用SelectMomentum()之前调用SelectAll()或类似函数,因为StatTotalReturn使用temp['selected']的值。

Args:
  • n (int): 选择前N个元素

  • lookback (DateOffset): 用于总回报计算的回顾期

  • lag (DateOffset): 用于总回报计算的滞后间隔

  • sort_descending (bool): 降序排序(最高回报为最佳)

  • all_or_none (bool): 如果为真,仅当我们有n个项目时填充temp['selected']。如果我们少于n个,则temp['selected'] = []。

Sets:
  • 已选择

Requires:
  • 已选择

class bt.algos.SelectN(n, sort_descending=True, all_or_none=False, filter_selected=False)[source]

基础类: Algo

根据排名 temp['stat'] 设置 temp['selected']。

根据 temp['stat'] 选择前 N 个或后 N 个项目。 这通常是某种指标,将在之前的算法中计算,并用于排名目的。可以根据 sort_descending 参数选择前 N 个或后 N 个。

Args:
  • n (int): 选择前n个项目。

  • sort_descending (bool): 在选择前n个项目之前,统计信息是否应按降序排序?

  • all_or_none (bool): 如果为真,仅当我们有n个项目时填充temp['selected']。如果我们少于n个,则temp['selected'] = []。

  • filter_selected (bool): 如果为True,将仅从现有的'selected'列表中选择。

Sets:
  • 已选择

Requires:
  • 统计

class bt.algos.SelectRandomly(n=None, include_no_data=False, include_negative=False)[source]

基础类: AlgoStack

根据当前在temp['selected']中的项目的随机子集设置temp['selected']。

从存储在temp['selected']中的列表中随机选择n个元素。 这对于与我们相信选择算法正在增加价值的策略进行基准测试非常有用。

例如,如果我们正在测试一个动量策略,并且我们想看看基于动量选择证券是否比随机选择证券更好,我们可以使用这个算法来创建一个用于随机基准测试的随机策略。

Note:

在使用此算法之前,应使用另一种选择算法来填充 temp['selected']。这通常是 SelectAll。

Args:
  • n (int): 随机选择N个元素。

  • include_no_data (bool): 是否包含没有数据的证券?

  • include_negative (bool): 是否包含价格为负或为零的证券?

Sets:
  • 已选择

Requires:
  • 已选择

class bt.algos.SelectRegex(regex)[source]

基础类: Algo

根据名称的正则表达式设置 temp['selected']。 在处理大量不同类型的证券时非常有用。

Args:
  • regex (str): 名称的正则表达式

Sets:
  • 已选择

Requires:
  • 已选择

class bt.algos.SelectThese(tickers, include_no_data=False, include_negative=False)[source]

基础类: Algo

使用一组预定义的股票代码设置 temp['selected']。

Args:
  • ticker (list): 要选择的股票代码列表。

  • include_no_data (bool): 是否包含没有数据的证券?

  • include_negative (bool): 是否包含价格为负或为零的证券?

Sets:
  • 已选择

class bt.algos.SelectTypes(include_types=(<class 'bt.core.Node'>, ), exclude_types=())[source]

基础类: Algo

根据节点类型设置 temp['selected']。 如果 temp['selected'] 已经设置,它将过滤现有的选择。

Args:
  • include_types (list): 要包含的节点类型

  • exclude_types (list): 要排除的节点类型

Sets:
  • 已选择

class bt.algos.SelectWhere(signal, include_no_data=False, include_negative=False)[source]

基础类: Algo

根据指标DataFrame选择证券。

选择在当前日期(target.now)值为True的证券,仅当当前日期存在于信号DataFrame中时。

例如,这可能是pandas布尔比较的结果,如data > 100。

Args:
  • signal (str|DataFrame): 包含选择逻辑的布尔DataFrame。 如果传递的是字符串,则使用target.get_data访问frame。 这是使用算法的首选方式。

  • include_no_data (bool): 是否包含没有数据的证券?

  • include_negative (bool): 是否包含价格为负或为零的证券?

Sets:
  • 已选择

class bt.algos.SetNotional(notional_value)[source]

基础类: Algo

设置名义值作为FixedIncomeStrategy目标的再平衡基础

Args:
  • notional_value (str): 包含策略随时间变化的目标名义值的 pd.Series 对象的名称。

Sets:
  • 名义价值

class bt.algos.SetStat(stat)[source]

基础类: Algo

设置 temp['stat'] 供下游算法(如 SelectN)使用。

Args:
  • stat (str|DataFrame): 一个与目标宇宙维度相同的数据框 如果传递了一个字符串,则使用 target.get_data 访问框架 这是使用算法的首选方式。

Sets:
  • 统计

class bt.algos.SimulateRFQTransactions(rfqs, model)[source]

基础类: Algo

一种算法,使用“模型”模拟RFQ(询价请求)的结果,该模型确定哪些RFQ成为交易以及这些交易以何种价格发生。这可以从RFQ的发送者或接收者的角度使用。

Args:
  • rfqs (str): 数据框的名称,包含列 日期, 证券 | 数量, *模型所需的其他列

  • model (object): a function/callable object with arguments
    • rfqs : 需要回应的rfqs数据框

    • 目标:策略对象,用于访问位置和值数据

    and which returns a set of transactions, a MultiIndex DataFrame with:

    日期, 证券 | 数量, 价格

class bt.algos.StatTotalReturn(lookback=<DateOffset: months=3>, lag=<DateOffset: days=0>)[source]

基础类: Algo

设置 temp['stat'] 为给定期间内的总回报。

根据给定回顾期内 temp['selected'] 中每个元素的总回报设置 'stat'。总回报由 ffn 的 calc_total_return 确定。

Args:
  • lookback (DateOffset): 回溯周期。

  • lag (DateOffset): 滞后间隔。总回报在区间 [now - lookback - lag, now - lag] 中计算。

Sets:
  • 统计

Requires:
  • 已选择

class bt.algos.TargetVol(target_volatility, lookback=<DateOffset: months=3>, lag=<DateOffset: days=0>, covar_method='standard', annualization_factor=252)[source]

基础类: Algo

根据目标年化波动率更新 temp['weights']。

Args:
  • target_volatility: 目标年化波动率

  • lookback (DateOffset): 用于估计波动率的回溯期

  • lag (DateOffset): 计算协方差需要等待的时间量

  • covar_method: 计算波动率的方法

  • annualization_factor: 用于年化的周期数。 假设目标波动率已经通过此因子进行了年化。

Updates:
  • 权重

Requires:
  • temp['weights']

class bt.algos.UpdateRisk(measure, history=0)[source]

基础类: Algo

跟踪策略所有节点的风险度量。要使用此节点,Backtest上的additional_data参数必须包含一个“unit_risk”键。该值应为一个字典,按风险度量键控,每个度量敏感的证券都有一个列的DataFrames。

Args:
  • name (str): 风险度量的名称(IR01, PVBP, IsIndustials等)。 名称必须与传递给additional_data的字典中的键一致,作为“unit_risk”参数。

  • history (int): 树中跟踪风险数字时间序列的深度级别。 即 0=不跟踪,1=仅第一级,等等。级别越多,成本越高。

Modifies:
  • 目标及其所有子元素的“risk”属性

  • 如果 history==True,目标和其所有子项的“risks”属性

class bt.algos.WeighERC(lookback=<DateOffset: months=3>, initial_weights=None, risk_weights=None, covar_method='ledoit-wolf', risk_parity_method='ccd', maximum_iterations=100, tolerance=1e-08, lag=<DateOffset: days=0>)[源代码]

基础类: Algo

根据等风险贡献算法设置 temp['weights']。

基于ffn的calc_erc_weights设置目标权重。这是逆波动率风险平价投资组合的扩展,其中资产回报的相关性被纳入每个资产风险贡献的计算中。

最终的投资组合类似于一个最小方差投资组合,受到其组成部分权重的多样化约束,其波动性位于最小方差和等权重投资组合之间(Maillard 2008)。

See:

https://en.wikipedia.org/wiki/Risk_parity

Args:
  • lookback (DateOffset): 用于估计协方差的回溯期

  • initial_weights (list): 初始资产权重 [默认逆波动率]。

  • risk_weights (list): 风险目标权重 [默认等权重]。

  • covar_method (str): 用于估计协方差的方法。有关更多详细信息,请参见ffn的calc_erc_weights。(默认值为ledoit-wolf)。

  • risk_parity_method (str): 风险平价估计方法。更多详情请参见ffn的calc_erc_weights。(默认值为ccd)。

  • maximum_iterations (int): 迭代解决方案中的最大迭代次数 (默认 100).

  • tolerance (float): 迭代解中的容差水平(默认值为1E-8)。

Sets:
  • 权重

Requires:
  • 已选择

class bt.algos.WeighEqually[source]

基础类: Algo

通过为所选中的所有项目计算相等的权重来设置 temp['weights']。

等权重算法。将“selected”中每个项目的“weights”设置为1/n。

Sets:
  • 权重

Requires:
  • 已选择

class bt.algos.WeighInvVol(lookback=<DateOffset: months=3>, lag=<DateOffset: days=0>)[源代码]

基础类: Algo

根据逆波动率算法设置 temp['weights']。

根据ffn的calc_inv_vol_weights设置目标权重。这是一种常用于风险平价投资组合的技术。在这种方案下,波动性最小的元素获得最高的权重。权重与它们的波动性的倒数成正比。

Args:
  • lookback (DateOffset): 用于估计波动率的回溯期

Sets:
  • 权重

Requires:
  • 已选择

class bt.algos.WeighMeanVar(lookback=<DateOffset: months=3>, bounds=(0.0, 1.0), covar_method='ledoit-wolf', rf=0.0, lag=<DateOffset: days=0>)[源代码]

基础类: Algo

基于均值-方差优化设置 temp['weights']。

基于ffn的calc_mean_var_weights设置目标权重。这是Markowitz均值方差优化的Python实现。

See:

http://en.wikipedia.org/wiki/Modern_portfolio_theory#The_efficient_frontier_with_no_risk-free_asset

Args:
  • lookback (DateOffset): 用于估计波动率的回溯期

  • bounds ((min, max)): 元组,指定优化中每个资产的最小和最大权重。

  • covar_method (str): 用于估计协方差的方法。有关更多详细信息,请参阅 ffn 的 calc_mean_var_weights。

  • rf (float): 优化中使用的无风险利率。

Sets:
  • 权重

Requires:
  • 已选择

class bt.algos.WeighRandomly(bounds=(0.0, 1.0), weight_sum=1)[source]

基础类: Algo

基于随机权重向量设置 temp['weights']。

为“selected”中的每个证券设置随机目标权重。 这对于与我们相信权重算法正在增加价值的策略进行基准测试非常有用。

例如,如果我们正在测试一个低波动策略,并且我们想看看我们的权重策略是否比随机加权证券更好,我们可以使用这个算法来创建一个用于随机基准测试的随机策略。

这是围绕ffn的random_weights函数的一个算法封装。

Args:
  • bounds ((low, high)): 包含每个证券的低和高界限的元组

  • weight_sum (float): 权重应该总和为多少?

Sets:
  • 权重

Requires:
  • 已选择

class bt.algos.WeighSpecified(**weights)[source]

基础类: Algo

根据提供的股票代码:权重字典设置temp['weights']。

根据预先指定的目标设置权重。

Args:
  • weights (dict): 目标权重 -> 股票代码: 权重

Sets:
  • 权重

class bt.algos.WeighTarget(weights)[source]

基础类: Algo

根据目标权重DataFrame设置目标权重。

如果目标权重数据框架的维度与目标宇宙相同,投资组合将在每个时期有效地重新平衡。例如,如果我们有每日数据并且目标数据框架的形状相同,我们将进行每日重新平衡。

然而,如果我们提供一个仅包含月末日期的目标权重数据框,那么重新平衡只会每月发生一次。

基本上,如果在给定日期提供了权重,则设置目标权重,算法继续(可能是转向再平衡算法)。如果没有提供权重,则不设置目标权重。

Args:
  • weights (str|DataFrame): 包含目标权重的DataFrame 如果传递的是字符串,则使用target.get_data访问frame 这是使用算法的首选方式。

Sets:
  • 权重

bt.algos.run_always(f)[source]

始终运行的装饰器,用于与Algo一起使用,以确保堆栈在每次通过时运行装饰的Algo,无论堆栈中是否有失败。

backtest 模块

包含回测逻辑和对象。

class bt.backtest.Backtest(strategy, data, name=None, initial_capital=1000000.0, commissions=None, integer_positions=True, progress_bar=False, additional_data=None)[source]

基础类:object

回测将策略与数据结合以产生结果。

回测基本上是在数据集上测试策略。

Note:

策略将被深度复制,以便在其他回测中重复使用。要访问回测后的策略,只需访问策略属性。

Args:
  • strategy (Strategy, Node, StrategyBase): 要测试的策略。

  • data (DataFrame): 包含回测中使用的数据的DataFrame。这将是策略的“宇宙”。

  • name (str): 回测名称 - 默认为策略名称

  • initial_capital (float): 传递给策略的初始资本金额。

  • 佣金 (fn(数量, 价格)): 要使用的佣金函数。例如:commissions=lambda q, p: max(1, abs(q) * 0.01)

  • integer_positions (bool): 是否在回测中使用整数仓位。当价格相对于资本量较高时(例如,由于拆股调整后的价格或资本量过低),这可能会导致分配的仓位四舍五入为零。虽然默认值为True,但可以尝试设置为False以获得更稳健的行为。

  • progress_bar (Bool): 在运行回测时显示进度条

  • additional_data (dict): 在预处理后传递给 StrategyBase.setup 的额外 kwargs 这些数据可以通过 Algos 使用 StrategyBase.get_data 来获取。 这些数据也可能被策略本身使用,即。

    • bidoffer: 一个与‘data’格式相同的DataFrame,将用于策略中的交易成本建模

    • coupons: 一个与‘data’格式相同的DataFrame,将被CouponPayingSecurity用于确定现金流。

    • cost_long/cost_short: 一个与‘data’格式相同的DataFrame, 将被CouponPayingSecurity 用于计算多头(或空头)头寸的非对称持有成本。

Attributes:
  • strategy (Strategy): 回测的策略。这将是传入策略的深拷贝。

  • data (DataFrame): 传入的数据

  • dates (DateTimeIndex): 数据的索引

  • initial_capital (float): 初始资本

  • name (str): 回测名称

  • stats (ffn.PerformanceStats): 性能统计

  • has_run (bool): 运行标志

  • weights (DataFrame): 每个组件随时间变化的权重

  • security_weights (DataFrame): 每个证券的权重,作为整个投资组合的百分比随时间变化

  • additional_data (dict): 在构造时传递的额外数据

property herfindahl_index

计算投资组合的赫芬达尔-赫希曼指数(HHI)。 对于每个给定的日期,HHI被定义为投资组合中证券权重的平方和;其范围从1/N到1。 值为1/N对应于等权重投资组合,值为1对应于所有金额投资于单一资产的极端情况。

1 / HHI 通常被认为是给定投资组合中的“有效资产数量”

property positions

每个组件随时间变化的位置的DataFrame

run()[source]

运行回测。

property security_weights

包含每个证券权重随时间变化的DataFrame,权重以整个投资组合的百分比表示

property turnover

计算回测的周转率。

此函数将计算策略的周转率。周转率定义为正支出或负支出中的较小值除以净资产值(NAV)。

property weights

每个组件权重随时间变化的DataFrame

class bt.backtest.RandomBenchmarkResult(*backtests)[source]

基础类: Result

RandomBenchmarkResult 扩展了 Result,增加了特定于随机策略基准测试的方法。

Args:
  • 回测列表 (list): 回测的列表

Attributes:
  • base_name (str): 被基准测试的回测名称

  • r_stats (结果): 随机策略的统计信息

  • b_stats (结果): 基准策略的统计数据

plot_histogram(statistic='monthly_sharpe', figsize=(15, 5), title=None, bins=20, **kwargs)[来源]

绘制给定统计量的分布。直方图表示随机策略统计量的分布,垂直线是基准策略统计量的值。

这有助于您确定您的策略在统计上是否“优于”随机版本。

Args:
  • 统计量 (str): 统计量 - 结果有效的任何数值统计量。

  • figsize ((x, y)): 图形大小

  • 标题 (str): 图表标题

  • bins (int): 箱子的数量

  • kwargs (dict): 传递给 pandas 的 hist 函数。

class bt.backtest.RenormalizedFixedIncomeResult(normalizing_value, *backtests)[source]

基础类: Result

一个新的结果类型,用于帮助比较由 FixedIncomeStrategy 生成的结果。回想一下,在固定收益策略中,归一化价格是使用以当前未偿还名义金额的百分比表示的加性回报计算的(即固定名义等价物)。 在名义金额变化的策略中,这可能会导致反直觉的结果,因为总和中的不同项被分母中的不同名义金额缩放(即价格可能低于面值,但总体价值变化为正)。

该类提供了一种使用不同的分母值或系列“重新归一化”结果的方法,即使用最大或平均名义敞口,或策略的风险敞口。

Args:
  • normalizing_value: pd.Series, float 或其字典(按策略名称)

  • 回测列表 (list): 回测列表(即来自 Result.backtest_list)

class bt.backtest.Result(*backtests)[source]

基础类:GroupStats

基于ffn的GroupStats,并添加了一些额外的辅助方法。

Args:
  • 回测列表 (list): 回测的列表

Attributes:
  • backtest_list (list): 按照提供的顺序排列的回测列表

  • 回测 (dict): 按名称分类的回测字典

display_monthly_returns(backtest=0)[source]

显示特定回测的月度回报。

Args:
  • backtest (str, int): Backtest. Can be either a index (int) or the

    名称 (str)

get_security_weights(backtest=0, filter=None)[source]
Parameters
  • backtest – (str, int) Backtest 可以是一个索引 (int) 或名称 (str)

  • filter – (list, str) 过滤特定列的列。过滤器 直接传递给DataFrame[filter],因此使用与DataFrame 有意义的内容。

Returns

(pd.DataFrame) 安全权重的DataFrame

get_transactions(strategy_name=None)[source]

辅助函数,返回以下格式的交易:

日期, 证券 | 数量, 价格

结果是一个多索引数据框。

Args:
  • strategy_name (str): 如果为none,它将采用第一个回测的策略 (self.backtest_list[0].name)

get_weights(backtest=0, filter=None)[source]
Parameters
  • backtest – (str, int) Backtest 可以是一个索引 (int) 或名称 (str)

  • filter – (list, str) 过滤特定列的列。过滤器 直接传递给 DataFrame[filter],因此使用与 DataFrame 兼容的内容。

Returns

(pd.DataFrame) 权重数据框

plot_histogram(backtest=0, **kwds)[source]

绘制给定回测随时间变化的收益直方图。

Args:
  • backtest (str, int): Backtest. Can be either a index (int) or the

    名称 (str)

  • kwds (dict): 传递给 plot_histogram 的关键字

plot_security_weights(backtest=0, filter=None, figsize=(15, 5), **kwds)[source]

绘制给定回测的安全权重随时间的变化。

Args:
  • backtest (str, int): Backtest. Can be either a index (int) or the

    名称 (str)

  • filter (list, str): filter columns for specific columns. Filter

    直接传递给DataFrame[filter],因此请使用与DataFrame有意义的内容。

  • figsize ((宽度, 高度)): 图形大小

  • kwds (dict): 传递给绘图的关键字

plot_weights(backtest=0, filter=None, figsize=(15, 5), **kwds)[source]

绘制给定回测的权重随时间的变化。

Args:
  • 回测(str, int):回测可以是一个索引(int)或名称(str)

  • filter (list, str): 过滤特定列的列。过滤器直接传递给DataFrame[filter],因此请使用与DataFrame有意义的内容。

  • figsize ((宽度, 高度)): 图形大小

  • kwds (dict): 传递给绘图的关键字

bt.backtest.benchmark_random(backtest, random_strategy, nsim=100)[source]

给定一个回测和一个随机策略,将回测与多个随机投资组合进行比较。

这里的想法是将你的策略与一系列具有相似结构但随机执行部分逻辑的随机策略进行基准测试 - 基本上你试图确定你的策略是否有任何价值 - 它是否胜过随机选择权重?或者随机选择所选证券?

Args:
  • backtest (Backtest): 你想要进行基准测试的回测

  • random_strategy (Strategy): 你想要进行基准测试的策略。该策略应具有随机成分,以模拟无技能行为。

  • nsim (int): 要创建的随机策略的数量。

Returns:

随机基准测试结果

bt.backtest.run(*backtests)[源代码]

运行一系列回测并返回一个包含回测结果的Result对象。

Args:
  • 回测 (*list): 回测列表。

Returns:

结果

core 模块

包含框架的核心构建块。

class bt.core.Algo(name=None)[source]

基础类:object

算法用于模块化策略逻辑,使策略逻辑变得模块化、可组合、更易测试且不易出错。基本上,算法应遵循Unix哲学——做好一件事。

在实践中,算法只是一个接收一个参数的函数,该参数是策略(称为目标),并且预期返回一个布尔值。

当在调用之间需要保持某些状态时,可以使用Algo对象(此对象)。应实现__call___方法,并在其中定义逻辑以模拟函数调用。如果不需要保持状态,也可以使用简单的函数。

Args:
  • name (str): 算法名称

property name

算法名称。

class bt.core.AlgoStack(*algos)[source]

基础类: Algo

一个AlgoStack从Algo派生,运行多个Algo直到遇到失败。

AlgoStack 的目的是将一组逻辑相关的 Algos 组合在一起。堆栈中的每个 Algo 都会运行。如果某个 Algo 返回 False,则执行停止。

Args:
  • algos (list): 算法列表。

class bt.core.CouponPayingHedgeSecurity(name, multiplier=1, fixed_income=True, lazy_add=False)[source]

基础类: CouponPayingSecurity

CouponPayingHedgeSecurity 是一种 CouponPayingSecurity,其名义价值设为零,因此不计入策略的名义价值。它主要用于固定收益策略。

例如,在公司债券策略中,名义价值可能指的是公司债券投资组合的规模,并排除用作对冲的国债或利率互换的名义价值。

update(date, data=None, inow=None)[source]

使用给定日期更新安全性,并可选择性地更新一些数据。 这将更新价格、价值、权重等。

class bt.core.CouponPayingSecurity(name, multiplier=1, fixed_income=True, lazy_add=False)[源代码]

基础类:FixedIncomeSecurity

CouponPayingSecurity 扩展了 SecurityBase,用于处理支付(可能不规则的)息票(或其他形式的现金支付)的证券。更一般地说,这可以包括任何形式的持有成本的工具,包括(可能不对称的)持有成本。

Args:
  • name (str): 安全名称

  • multiplier (float): 安全乘数 - 通常用于衍生品。

  • fixed_income (bool): 用于控制notional_value是否仅基于数量,还是基于市场价值(如股票)的标志。 默认为支付利息工具的名义权重。

  • lazy_add (bool): 标志,用于控制是否应懒加载地将工具添加到策略子项中,即仅在工具上有交易时才添加。这提高了在稀疏子项集上进行交易的策略的性能。

Attributes:
  • SecurityBase 属性

  • coupon (float): 当前优惠券支付(数量)。

  • holding_cost (float): 当前持有成本(数量)。

代表一种支付息票的证券,其中息票支付会调整母公司的资本。息票和成本必须在设置期间传入。

property coupon

当前优惠券支付(按头寸缩放)

property coupons

优惠券支付的时间序列(按头寸缩放)

property holding_cost

当前持有成本(按仓位比例缩放)

property holding_costs

优惠券支付的时间序列(按头寸缩放)

setup(universe, **kwargs)[source]

使用宇宙和优惠券数据设置安全性。加快未来的运行速度。

Args:
  • universe (DataFrame): 包含证券名称作为其中一列的价格DataFrame。

  • 优惠券 (DataFrame): 必须的优惠券/携带金额的DataFrame,其模式与universe相同。

  • cost_long (DataFrame): 可选的DataFrame,包含持有证券单位多头头寸的成本(即资金成本)。

  • cost_short (DataFrame): 可选的DataFrame,包含持有证券空头头寸的成本(即回购)。

  • kwargs (dict): 策略所需的额外信息的字典。特别是,通常采用证券级别信息(即信号、风险等)的DataFrame形式。

update(date, data=None, inow=None)[source]

使用给定日期更新安全性,并可选择性地更新一些数据。 这将更新价格、价值、权重等。

class bt.core.FixedIncomeSecurity(name, multiplier=1, lazy_add=False)[来源]

基础类: SecurityBase

固定收益证券是一种仅根据证券的数量(面值)来衡量名义价值的证券。仅在使用FixedIncomeStrategy时相关。

update(date, data=None, inow=None)[source]

使用给定日期更新安全性,并可选择性地更新一些数据。 这将更新价格、价值、权重等。

class bt.core.FixedIncomeStrategy(name, algos=None, children=None)[source]

基础类:Strategy

FixedIncomeStrategy 是 Strategy 的别名,其中 fixed_income 标志设置为 True。

For this type of strategy:
  • 资本分配不是必要的,初始资本未被使用

  • 破产功能已禁用(应通过算法明确建模)

  • 权重基于名义价值而非实际价值

  • 策略价格是根据每单位当前名义价值的附加PNL回报计算的,参考价格为PAR。 RenormalizedFixedIncomeResult 可以用于重新计算基于价格的绩效统计,使用不同的总PNL归一化方案。

  • “transact” 承担了“allocate”的角色,以便在加权名义基础上买卖子项

  • “rebalance” 根据权重调整名义金额而不是资本分配

class bt.core.HedgeSecurity(name, multiplier=1, lazy_add=False)[source]

基础类: SecurityBase

HedgeSecurity 是一个 SecurityBase,其名义价值设置为零,因此不计入策略的名义价值。它旨在用于固定收益策略。

例如,在公司债券策略中,名义价值可能指的是公司债券投资组合的规模,并排除用作对冲的国债或利率互换的名义价值。

update(date, data=None, inow=None)[source]

使用给定日期更新安全性,并可选择性地更新一些数据。 这将更新价格、价值、权重等。

class bt.core.Node(name, parent=None, children=None)[source]

基础类:object

节点是bt树结构设计中的主要构建块。 StrategyBase和SecurityBase都继承自Node。它包含了树节点的核心功能。

Args:
  • name (str): 节点名称

  • parent (Node): 父节点

  • children (dict, list): 子元素的集合。如果是字典, 格式为 {name: child},如果是列表则为子元素列表。 子元素可以是任何类型的 Node 或 str。 字符串值对应于在需要时将延迟创建的子元素, 并使用该名称。

Attributes:
  • name (str): 节点名称

  • 父节点 (Node): 节点的父节点

  • root (Node): 树的根节点(最顶层的节点)

  • children (dict): 节点的子节点

  • now (datetime): 用于回测时存储当前日期

  • stale (bool): 用于确定节点是否过时并需要更新的标志

  • 价格 (TimeSeries): 节点的价格。对于证券,价格将是证券的价格,对于策略,它将是一个反映策略随时间变化的指数。

  • price (float): 最后价格

  • value (float): 最后的值

  • notional_value (float): 最后的名义价值。名义价值在 fixed_income=True 时使用。对于策略来说,它总是正数,但对于证券来说,它是有符号的(通常设置为市场价值、头寸或零)。

  • weight (float): 父级中的权重

  • full_name (str): 包括父母姓名的全名

  • 成员(列表):当前节点 + 节点的子节点

  • fixed_income (bool): 节点是否对应于固定收益组件,该组件将使用名义权重而不是市场价值权重。更多详情请参见 FixedIncomeStrategy

adjust(amount, update=True, flow=True)[source]

按数量调整节点值。

allocate(amount, update=True)[source]

将资金分配给节点。

property fixed_income

节点是否为固定收益节点(使用名义加权)。

property full_name
property members

节点成员。成员包括当前节点以及节点的子节点。

property notional_value

节点的当前名义价值

property price

节点的当前价格

property prices

节点价格的时间序列。

setup(universe, **kwargs)[source]

用于初始化具有宇宙的节点,并可能包含其他信息的设置方法。

to_dot(root=True)[source]

以DOT格式表示节点结构。

update(date, data=None, inow=None)[source]

使用最新日期更新节点,并可选择性地更新一些数据。

use_integer_positions(integer_positions)[source]

设置指示器以使用(或不使用)整数位置用于给定策略或证券。

默认情况下,股票数量中的所有头寸应为整数。 然而,在处理股票的调整价格时,这可能会导致意外的结果。由于一系列股票的反向拆分,过去的调整价格可能很高。因此,将想要购买的股票数量四舍五入可能会导致0,从而在回测中忽略这只股票。

property value

节点的当前值

property weight

节点的当前权重(相对于父节点)。

class bt.core.Security(name, multiplier=1, lazy_add=False)[source]

基础类: SecurityBase

一种没有特殊功能的标准证券,其名义价值基于市场价值(名义价值乘以价格)来衡量。它的存在是为了能够通过isinstance识别标准证券与非标准证券,即isinstance(sec, Security)仅对普通证券返回True,而SecurityBase对所有证券返回True。

class bt.core.SecurityBase(name, multiplier=1, lazy_add=False)[source]

基础类:Node

安全节点。用于在树中定义一个安全。 安全节点没有子节点。它只是模拟一个可以买卖的资产。

Args:
  • name (str): 安全名称

  • multiplier (float): 安全乘数 - 通常用于衍生品或以批次交易。证券的数量将始终乘以该值以确定基础金额。

  • lazy_add (bool): 标志,用于控制是否应懒加载地将工具添加到策略子项中,即仅在工具上有交易时才添加。这提高了在稀疏子项集上进行交易的策略的性能。

Attributes:
  • name (str): 安全名称

  • parent (Security): 安全父级

  • root (Security): 树的根节点(最顶层的节点)

  • now (datetime): 用于回测时存储当前日期

  • stale (bool): 用于确定Security是否过时并需要更新的标志

  • 价格 (TimeSeries): 证券价格。

  • price (float): 最后价格

  • 支出 (TimeSeries): 一系列支出。正支出表示资金被分配到证券,并且证券消耗了该金额。负支出则相反。这对于在策略级别计算周转率非常有用。

  • value (float): 最后的值 - 基本上是位置 * 价格 * 乘数

  • weight (float): 父级中的权重

  • full_name (str): 包括父母姓名的全名

  • 成员(列表):当前安全+策略的子项

  • position (float): 当前持仓量(数量)。

  • bidoffer (float): 当前买卖价差

  • bidoffers (TimeSeries): 买卖价差系列

  • bidoffer_paid (TimeSeries): 交易中支付的买卖报价系列

allocate(amount, update=True)[source]

这为证券分配资金。这是用于买卖证券的方法。

给定数量的股份将根据当前价格确定,佣金将根据父级的佣金函数计算,任何剩余的资本将作为调整传递回父级。

Args:
  • amount (float): 调整的金额。

  • update (bool): 强制更新?

property bidoffer

当前买卖价差。

property bidoffer_paid

当前步骤中交易支付的买卖价差的时间序列

property bidoffers

买卖价差的时间序列

property bidoffers_paid

当前步骤中交易支付的买卖价差的时间序列

commission(q, p)[source]

根据数量和价格计算佣金(交易费用)。使用父级的commission_fn。

Args:
  • q (float): 数量

  • p (float): 价格

multiplier = 0.0
property notional_values

名义值的时间序列。

outlay(q, p=None)[source]

确定给定数量q所需的完整现金支出(包括佣金)。 第二个返回参数是佣金本身。

Args:
  • q (float): 数量

  • p (float): 价格覆盖

property outlays

支出的时间序列。正支出(买入)意味着该证券接收并消耗了资本(资本被分配给它)。负支出则相反(证券关闭/卖出,并将资本返还给母公司)。

property position

当前位置

property positions

位置的时间序列。

property price

当前价格。

property prices

价格的时间序列。

run()[source]

什么都不做 - 证券在运行时没有任何操作。

setup(universe, **kwargs)[源代码]

使用universe设置安全性。加快未来的运行速度。

Args:
  • universe (DataFrame): 包含证券名称作为其中一列的价格DataFrame。

  • bidoffer (DataFrame): 可选参数,表示每种证券随时间变化的买卖价差。如果提供,策略在重新平衡时将考虑这些成本。

  • kwargs (dict): 策略所需的额外信息的字典。特别是,通常采用证券级别信息(即信号、风险等)的DataFrame形式。

transact(q, update=True, update_self=True, price=None)[source]

这是进行证券交易的方法。此方法用于买卖给定数量的证券。

明确提供了股份数量,将根据父级的佣金函数计算佣金,任何剩余的资本将作为调整返回到父级。

Args:
  • amount (float): 调整的金额。

  • update (bool): 由于交易进行,强制更新父级

  • update_self (bool): 检查自身更新

  • 价格 (float): 如果交易发生在定制级别,则为可选价格

update(date, data=None, inow=None)[来源]

使用给定日期更新安全性,并可选择性地更新一些数据。 这将更新价格、价值、权重等。

property values

时间序列的值。

class bt.core.Strategy(name, algos=None, children=None, parent=None)[source]

基础类:StrategyBase

策略扩展了StrategyBase并包含了算法。

基本上,策略是通过传入一组算法来构建的。这些算法将被放置在算法堆栈中,运行函数将调用该堆栈。

此外,创建了两个类属性以在算法之间传递数据。 perm用于永久数据,temp用于临时数据。

Args:
  • name (str): 策略名称

  • algos (list): 要传递给AlgoStack的算法列表

  • children (dict, list): 子节点 - 当您想要创建策略的策略时非常有用 子节点可以是任何类型的节点或字符串。 字符串值对应于在需要时将延迟创建的子节点,并使用该名称。

  • parent (Node): 父节点

Attributes:
  • stack (AlgoStack): 堆栈

  • temp (dict): 一个包含临时数据的字典 - 每次调用 run 时都会被清除。这可以用于将信息传递给其他算法。

  • perm (dict): 用于在算法之间传递信息的永久数据。每次传递时不会被清除。

run()[source]

这是主要的逻辑方法。重写此方法以提供一些算法,在每次日期变化时执行。此方法由回测器调用。

class bt.core.StrategyBase(name, children=None, parent=None)[source]

基础类:Node

策略节点。用于在树中定义策略逻辑。 策略的作用是根据一个函数将资本分配给其子节点。

Args:
  • name (str): 策略名称

  • children (dict, list): 子元素的集合。如果是字典, 格式为 {name: child},如果是列表则为子元素列表。 子元素可以是任何类型的 Node 或 str。 字符串值对应于在需要时将延迟创建的子元素, 并使用该名称。

  • parent (Node): 父节点

Attributes:
  • name (str): 策略名称

  • parent (Strategy): 策略父级

  • root (Strategy): 树的根节点(最顶层的节点)

  • children (dict): 策略的子项

  • now (datetime): 用于回测时存储当前日期

  • stale (bool): 用于确定策略是否过时并需要更新的标志

  • 价格 (TimeSeries): 策略的价格 - 基本上是一个反映策略随时间变化的价值的指数。

  • 支出 (DataFrame): 每个 SecurityBase 子项的支出

  • price (float): 最后价格

  • value (float): 最后的值

  • notional_value (float): 最后的名义价值

  • weight (float): 父级中的权重

  • full_name (str): 包括父母姓名的全名

  • 成员(列表):当前策略 + 策略的子项

  • 证券(列表):类型为SecurityBase的策略子项列表

  • commission_fn (fn(quantity, price)): 用于确定佣金(交易费用)金额的函数。可用于模拟滑点(执行缺口)。请注意,通常买卖的费用是对称的,应使用数量的绝对值进行计算。

  • capital (float): 策略中的资本金额 - 现金

  • universe (DataFrame): 当前时间可用的数据宇宙。 Universe 包含创建 Backtest 时传入的数据。使用 此数据来确定策略逻辑。

adjust(amount, update=True, flow=True, fee=0.0)[source]

调整资本 - 用于向策略注入资本。此资本注入不会对子策略产生影响。

Args:
  • amount (float): 调整的金额。

  • update (bool): 强制更新?

  • flow (bool): 这个调整是一个流动吗?流动不会影响性能(价格指数)。流动的例子仅仅是资本注入(比如每月对投资组合的贡献)。这不应该反映在回报中。非流动(flow=False)确实会影响性能。一个很好的例子是佣金或股息。

allocate(amount, child=None, update=True)[source]

将资金分配给策略。默认情况下,资金会递归地按比例分配给子策略,根据子策略的权重。如果指定了子策略,资金将分配给该特定子策略。

分配也有一个副作用。它们将从父级的“账户”中扣除相同的金额以抵消分配。如果分配后还有剩余资金,它将保留在策略中。

Args:
  • amount (float): 分配的金额。

  • child (str): 如果指定,分配将仅定向到子级。通过名称指定。

  • update (bool): 强制更新。

bankrupt = False
property bidoffer_paid

当前步骤中交易支付的买卖价差

property bidoffers_paid

每一步交易中支付的买卖价差的时间序列

property capital

当前资本 - 策略中剩余的未分配资本金额。

property cash

未分配资本的时间序列。

close(child, update=True)[source]

关闭子仓位 - rebalance(0, child) 的别名。这也会平仓(关闭所有)子仓位的子仓位。

Args:
  • child (str): 子节点,通过名称指定。

property fees

费用的时间序列。

flatten()[source]

关闭所有子仓位。

property flows

流量的时间序列。

get_data(key)[source]

返回通过kwargs传递给设置函数的额外数据,供算法使用。这允许算法“按名称”引用数据源,其中数据与名称的绑定发生在回测创建时,而不是策略定义时,从而使得相同的策略更容易在不同的数据集上运行。

get_transactions()[source]

辅助函数,返回以下格式的交易:

日期, 证券 | 数量, 价格

结果是一个多索引数据框。

property notional_values

名义值的时间序列。

property outlays

返回每个子SecurityBase的支出DataFrame

property positions

位置的时间序列。

property price

当前价格。

property prices

价格的时间序列。

rebalance(weight, child, base=nan, update=True)[source]

将子节点重新平衡到给定的权重。

这是一个辅助方法,用于简化代码逻辑。当我们想要将特定子项的权重设置为一定数量时,会使用此方法。它与分配类似,但会根据当前权重计算适当的分配。对于固定收益策略,它使用交易来基于名义价值而不是资本进行再平衡。

Args:
  • weight (float): 目标权重。通常在 -1.0 和 1.0 之间。

  • child (str): 要分配给的子节点 - 通过名称指定。

  • base (float): 如果指定,这是所有权重增量计算将基于的基本金额。当我们确定一组权重并希望根据这些新权重重新平衡每个子项时,这很有用。然而,当我们遍历每个子项并调用此方法时,base(默认是当前值)将会改变。因此,我们可以在迭代之前将此base设置为原始值,以确保进行正确的分配。

  • update (bool): 强制更新?

run()[source]

这是主要的逻辑方法。重写此方法以提供一些算法,在每次日期变化时执行。此方法由回测器调用。

property securities

返回类型为 SecurityBase 的子项列表

set_commissions(fn)[source]

设置佣金(交易费)功能。

Args:

fn (fn(quantity, price)): 用于确定佣金金额的函数。

setup(universe, **kwargs)[source]

使用宇宙设置策略。这将加快未来的计算和更新。

setup_from_parent(**kwargs)[来源]

从父级设置策略。用于动态创建子策略时。

Args:
  • kwargs: additional arguments that will be passed to setup

    (可能覆盖来自父级的那些)

transact(q, child=None, update=True)[source]

在策略中交易一个名义金额 q。默认情况下,它会按比例递归分配给子策略,比例根据子策略的权重确定。递归分配仅适用于固定收益策略。如果指定了子策略,名义金额将分配给该特定子策略。

Args:
  • q (float): 要分配的名义数量。

  • child (str): 如果指定,分配将仅定向到子级。通过名称指定。

  • update (bool): 强制更新。

property universe

当前可用的数据宇宙。 宇宙包含创建回测时传入的数据。 使用此数据来确定策略逻辑。

update(date, data=None, inow=None)[source]

更新策略。更新价格、价值、重量等。

property values

时间序列的值。

bt.core.is_zero(x)[source]

测试零值,该测试对浮点精度误差具有鲁棒性