python - 该类(class)如何工作？ (与Quantopian，Python和Pandas有关)

Question

从这里：https://www.quantopian.com/posts/wsj-example-algorithm

class Reversion(CustomFactor):
    """
    Here we define a basic mean reversion factor using a CustomFactor. We
    take a ratio of the last close price to the average price over the
    last 60 days. A high ratio indicates a high price relative to the mean
    and a low ratio indicates a low price relative to the mean.
    """
    inputs = [USEquityPricing.close]
    window_length = 60   

    def compute(self, today, assets, out, prices):
        out[:] = -prices[-1] / np.mean(prices, axis=0)

Reversion()似乎返回 pandas.DataFrame，我完全不知道为什么。
一方面， inputs和 window_length在哪里使用？
  out[:]到底是什么？

这种特定的行为是否特别与Quantopian或Python / Pandas有关？

Answer 1

TL; DR


Reversion()不返回DataFrame，而是返回
Reversion类，您可以将其视为执行
尾窗计算。您可以在特定时间内运行该公式
使用quantopian.algorithm.pipeline_output或
quantopian.research.run_pipeline，具体取决于您是否正在撰写
交易算法或在笔记本中进行离线研究。
compute方法定义了Reversion计算的“公式”
实例。它计算2D numpy价格数组的减少量，其中
数组的每一行对应一天，数组的每一列
对应于股票。计算的结果是一维数组
包含每个股票的值，将其复制到out。 out也是
一个numpy数组。语法out[:] = <expression>说“从以下位置复制值
<expression>转换为out”。

compute将其结果直接写入输出数组，而不是简单地
返回，因为这样做允许CustomFactor基类确保
输出具有正确的形状和dtype，对于
更复杂的情况。

通过覆盖输入来具有“返回”功能是不常见的，并且通常
非惯用的Python。我不建议实现类似的API，除非
您确定没有更好的解决方案。
链接示例中的所有代码都是开源的，可以在以下位置找到
Zipline，位于顶部的框架
建于哪里？如果您对实施感兴趣，
以下文件是开始的好地方：


zipline/pipeline/engine.py
zipline/pipeline/term.py
zipline/pipeline/graph.py
zipline/pipeline/pipeline.py
zipline/pipeline/factors/factor.py

您还可以找到有关Pipeline API的详细教程
here。




我认为您的问题有两种答案：


Reversion类如何适应更大的框架
Zipline / Quantopian算法？换句话说，“ Reversion类怎么样
用过的”？
Reversion.compute()的预期输入是什么，以及如何计算
在这些输入上执行吗？换句话说，“具体而言，
Reversion.compute()方法吗？


使用（1）中的某些上下文来回答（2）更容易。

Reversion类如何使用？

Reversion是CustomFactor的子类，它是Zipline的一部分
管道API。 Pipeline API的主要目的是使其变得简单
供用户有效地执行某种特殊类型的计算
许多数据来源。这种特殊的计算方式是横截面
尾窗计算，其形式为：

每天，对于某些数据源，获取所有数据的最后N天
已知资产并应用归约函数以产生一个
资产。

一个非常简单的横截面尾部窗口计算将是
例如“每日收盘价”，其格式为：

每天获取最后两天的收盘价，对于每种资产，
计算资产前一天的收盘价与
当前的收盘价。

为了描述截面后窗计算，我们至少需要
三个信息：


计算基于哪种数据（例如价格，数量，市值）
操作？
数据尾随窗口的时间长度（例如1天，20天，100天）
计算工作吗？
计算对所描述的数据执行什么归约函数
由（1）和（2）？


CustomFactor类定义用于合并这三部分内容的API
将信息整合为一个对象。


inputs属性描述了执行
计算。在问题的摘录中，唯一的输入是
USEquityPricing.close，表示我们只需要跟踪每日收盘价
价格。但是，总的来说，我们可以要求任何数量的输入。对于
例如，要计算VWAP（成交量加权平均价格），我们将使用
类似于inputs = [USEquityPricing.close, USEquityPricing.volume]
说我们要跟踪收盘价和跟踪每日交易量。
window_length属性描述跟踪数据的天数
需要进行计算。在上面的代码段中，我们要求60
连续几天收盘价。
compute方法将尾随窗口计算描述为
执行。在下面的部分中，我概述了compute的确切表现
它的计算。现在，只要知道compute本质上是一个
从一些二维数组到单个二维数组的约简函数
一维数组。


您可能会注意到，我们尚未定义一组实际的日期
可能要计算Reversion因子。这是设计使然，因为我们希望
能够使用相同的Reversion实例在以下位置执行计算
不同的时间点。

Quantopian定义了两个API，用于计算Reversion这样的表达式：
专为实际交易算法设计的“在线”模式和“批量”模式
设计用于研发。在这两个API中，我们首先构造
Pipeline对象，包含我们要执行的所有计算。我们
然后将管道对象输入实际执行
我们感兴趣的计算。

在批处理API中，我们调用run_pipeline传递管道，开始日期，
和结束日期。一个简单的计算笔记本，可以计算自定义因素
看起来像这样：

from quantopian.pipeline import Pipeline, CustomFactor
from quantopian.research import run_pipeline

class Reversion(CustomFactor):
    # Code from snippet above.

reversion = Reversion()
pipeline = Pipeline({'reversion': reversion})
result = run_pipeline(pipeline, start_date='2014-01-02', end_date='2015-01-02')
do_stuff_with(result)

在交易算法中，我们通常对最近的交易感兴趣
通过管道计算值，因此有一个稍微不同的API：
在启动时将管道“附加”到我们的算法，然后我们请求最新的
每天开始时管道的输出。一个简单的交易算法
使用 Reversion可能看起来像这样：

import quantopian.algorithm as algo
from quantopian.pipeline import Pipeline, CustomFactor


class Reversion(CustomFactor):
    # Code from snippet above.

def initialize(context):
    reversion = Reversion()
    pipeline = Pipeline({'reversion': reversion})
    algo.attach_pipeline(pipeline, name='my_pipe')

def before_trading_start(context, data):
    result = algo.pipeline_output(name='my_pipe')
    do_stuff_with(result)

关于以上两个示例，最重要的要了解的是
简单地构造 Reversion的实例不会执行任何操作
计算。特别是，该行：

reversion = Reversion()

不会获取任何数据或调用 compute方法。它只是创建一个
Reversion类的实例，它知道它需要关闭60天
每天为运行其 compute功能定价。同样，
USEquityPricing.close不是DataFrame或numpy数组或类似的东西
那：它只是一个哨兵值，描述了什么样的数据 Reversion
需要作为输入。

思考这一问题的一种方法是通过类比数学。的实例
Reversion类似于用于执行计算的公式，并且
USEquityPricing.close就像该公式中的变量。

简单地写下公式不会产生任何值。它给了我们一个
这样说：“如果您插入所有
这些变量”。

通过为变量实际插入值，我们得到了具体的结果，
当我们调用 run_pipeline或 pipeline_output时会发生这种情况。

那么， Reversion.compute()具体做什么？

run_pipeline和 pipeline_output最终归结为对
PipelineEngine.run_pipeline，这是实际计算发生的地方。

如果 reversion是公式，则继续从上面进行类比，并且
USEquityPricing.close是该公式中的变量，然后 PipelineEngine是
作业要查找的价值的小学学生
变量并将其插入公式。

当我们调用 PipelineEngine.run_pipeline(pipeline, start_date, end_date)时，
引擎遍历我们请求的表达式，为这些表达式加载输入
表达式，然后每个交易一次调用每个表达式的 compute方法
start_date和 end_date之间的一天，并加载适当的片段
输入数据。

具体来说，引擎希望每个表达式都有一个 compute方法，
签名如下：

def compute(self, today, assets, out, input1, input2, ..., inputN):

前四个参数始终相同：


self是相关的 CustomFactor实例（例如，
以上的摘要）。通常，这就是方法在Python中的工作方式。
reversion是熊猫时间戳记，表示 today的日期
被呼叫。
compute是一维numpy数组，每个数组均包含一个整数
assets上的可交易资产。
today是与 out形状相同的一维numpy数组。的
assets的约定是应写出其计算结果
进入 compute。


其余参数是形状为 out的二维numpy数组。
这些参数中的每一个都对应于表达式的 (window_length, len(assets))中的一个条目
清单。对于 inputs，我们只有一个输入，
Reversion，因此只有一个额外的参数 USEquityPricing.close
包含一个 prices数组，其中包含60天的追踪收盘价
对于 60 x len(assets)上存在的每个资产。

today的一个不寻常的功能是它期望写出它的计算结果。
结果进入 compute。通过变异输入使函数“返回”在以下情况中很常见
低级语言（例如C或Fortran），但在Python和一般情况下很少见
被视为非惯用语。 out将其输出部分写入 compute
性能原因（在某些情况下，我们可以避免大阵列的额外复制），
并使其部分实现，以便 out实现者无需担心
关于构造具有正确形状和dtype的输出数组，可以是
在用户拥有多个返回值的更复杂的情况下，这是棘手的。