股票分析引擎

构建并调优投资算法，用于与人工智能（深度神经网络） <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Comparing-3-Deep-Neural-Networks-Trained-to-Predict-a-Stocks-Closing-Price-Using-The-Analysis-Engine.ipynb>__ 结合使用，并采用分布式架构，利用来自以下平台的自动化数据源——IEX Cloud <https://iexcloud.io/>、Tradier <https://tradier.com/> 和 FinViz <https://finviz.com>__——对公开上市公司的实时行情数据进行回测（包括：行情、期权、新闻、股息、日线、盘中、筛选器、统计信息、财务报表、财报等）。

Kubernetes 用户请参阅 Helm 入门指南 <https://stock-analysis-engine.readthedocs.io/en/latest/deploy_on_kubernetes_using_helm.html>__ 以及 Metalnetes 在裸机服务器上同时运行多个分析引擎的方法 <https://metalnetes.readthedocs.io/en/latest/#>__。

.. image:: https://i.imgur.com/tw2wJ6t.png

获取最新行情数据

支持的行情数据获取方式：

• 使用 fetch 命令行工具
• IEX Cloud Fetch API <https://stock-analysis-engine.readthedocs.io/en/latest/iex_api.html#iex-fetch-api-reference>__
• Tradier Fetch API <https://stock-analysis-engine.readthedocs.io/en/latest/tradier.html#tradier-fetch-api-reference>__
• 使用 Docker Compose 的 ./compose/start.sh -c
• Kubernetes 作业：获取盘中数据 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/datasets/pull_intraday_per_minute.yml>、获取日线数据 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/datasets/pull_daily.yml>、获取周线数据 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/datasets/pull_weekly.yml>，或 仅从 Tradier 获取数据 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/datasets/pull_tradier_per_minute.yml>

使用命令行获取数据

以下视频展示了如何使用命令行获取某个股票代码的最新行情数据：

.. image:: https://asciinema.org/a/220460.png :target: https://asciinema.org/a/220460?autoplay=1 :alt: 使用命令行获取行情数据

#. 克隆到 /opt/sa

::

    git clone https://github.com/AlgoTraders/stock-analysis-engine.git /opt/sa
    cd /opt/sa

#. 创建 Docker 挂载点并启动 Redis 和 Minio

这将拉取 `Redis <https://hub.docker.com/_/redis>`__ 和 `Minio <https://hub.docker.com/r/minio/minio>`__ 的 Docker 镜像。

::

    ./compose/start.sh -a

#. 获取所有行情数据

#.  `按照入门部分操作 <https://github.com/AlgoTraders/stock-analysis-engine#getting-started>`__

#.  从 `IEX Cloud（需要账户且按需付费） <https://iexcloud.io/cloud-login#/register/>`__ 和 `Tradier（需要账户） <https://developer.tradier.com/getting_started>`__ 获取行情数据：

    - 设置 **IEX_TOKEN** 环境变量以从 IEX Cloud 数据源获取数据：

    ::

        export IEX_TOKEN=YOUR_IEX_TOKEN

    - 设置 **TD_TOKEN** 环境变量以从 Tradier 数据源获取数据：

    ::

        export TD_TOKEN=YOUR_TRADIER_TOKEN

    - 使用以下命令获取数据：

    ::

        fetch -t SPY

    - 如果只想从 **IEX** 获取数据，可以使用 **-g iex**：

    ::

        fetch -t SPY -g iex
        # 如果只想从 Tradier 获取数据，则使用：
        # fetch -t SPY -g td

    - 从 IEX Cloud 获取过去 30 个自然日的盘中分钟级行情数据：

    ::

        backfill-minute-data.sh TICKER
        # backfill-minute-data.sh SPY

#.  更多关于控制行情请求使用方式的示例，请参阅 `文档 <https://stock-analysis-engine.readthedocs.io/en/latest/scripts.html#module-analysis_engine.scripts.fetch_new_stock_datasets>`__

.. note:: 因为 Yahoo 已经`禁用了 YQL 金融 API，所以默认情况下无法从 Yahoo 获取行情数据 <https://developer.yahoo.com/yql/>`__

#. 在 Redis 中查看压缩后的行情数据

::

    redis-cli keys "SPY_*"
    redis-cli get "<key like SPY_2019-01-08_minute>"

使用算法运行器 API 进行回测

使用最新行情数据运行回测：

.. code-block:: python

import analysis_engine.algo_runner as algo_runner
import analysis_engine.plot_trading_history as plot
runner = algo_runner.AlgoRunner('SPY')
# 使用最近 200 分钟的数据运行算法：
df = runner.latest()
print(df[['minute', 'close']].tail(5))
plot.plot_trading_history(
    title=(
        f'SPY - ${df["close"].iloc[-1]} at: '
        f'{df["minute"].iloc[-1]}'),
    df=df)
# 启动完整回测：
# runner.start()

请查看 backtest_with_runner.py 脚本 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/backtest_with_runner.py>，其中包含一个使用 算法运行器 API <https://stock-analysis-engine.readthedocs.io/en/latest/algo_runner.html> 并根据 算法回测配置文件 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/cfg/default_algo.json>__ 运行和绘图的命令行示例。

从 Redis API 提取数据

数据提取完成后，您可以使用以下方法从 Redis 缓存中提取数据集：

.. code-block:: python

import analysis_engine.extract as ae_extract
print(ae_extract.extract('SPY'))

提取股票和期权的最新分钟级行情

.. code-block:: python

import analysis_engine.extract as ae_extract
print(ae_extract.extract(
    'SPY',
    datasets=['minute', 'tdcalls', 'tdputs']))

提取历史数据

使用格式为 YYYY-MM-DD 的 date 参数提取历史数据：

.. code-block:: python

import analysis_engine.extract as ae_extract
print(ae_extract.extract(
    'AAPL',
    datasets=['minute', 'daily', 'financials', 'earnings', 'dividends'],
    date='2019-02-15'))

其他提取 API

• 提取 API 参考 <https://stock-analysis-engine.readthedocs.io/en/latest/extract.html>__
• IEX Cloud 提取 API 参考 <https://stock-analysis-engine.readthedocs.io/en/latest/iex_api.html#iex-extraction-api-reference>__
• Tradier 提取 API 参考 <https://stock-analysis-engine.readthedocs.io/en/latest/tradier.html#tradier-extraction-api-reference>__
• 检查 Redis 中缓存的数据集是否存在错误 <https://stock-analysis-engine.readthedocs.io/en/latest/inspect_datasets.html#module-analysis_engine.scripts.inspect_datasets>__

备份

Redis 中的价格数据会自动压缩，并且有一个用于将所有存储的价格数据备份到 AWS S3 的 Kubernetes 作业示例 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/backups/backup-to-aws-job.yml>__。

在本地运行全栈以进行回测和实时交易分析

虽然回测并不需要运行整个系统，但在实时交易时段运行算法时则必须运行全栈。以下视频展示了如何使用 Docker Compose 和视频中的命令在本地部署整个系统。

.. image:: https://asciinema.org/a/220487.png :target: https://asciinema.org/a/220487?autoplay=1 :alt: 在本地运行全栈以进行回测和实时交易分析

#. 启动工作节点、回测器、价格数据采集、Jupyter、Redis 和 Minio

现在使用下面的命令启动剩余的组件。这将拉取 `约 3.0 GB 的 stock-analysis-engine Docker 镜像 <https://hub.docker.com/r/jayjohnson/stock-analysis-engine>`__，并启动工作节点、回测器、数据集采集以及 `Jupyter 镜像 <https://hub.docker.com/r/jayjohnson/stock-analysis-jupyter>`__。如果 Redis 和 Minio 尚未运行，它们也会被启动。

::

    ./compose/start.sh

.. tip:: 对于 Mac OS X 用户，请注意 `存在一个与 network_mode: "host" 相关的已知 Docker Compose 问题 <https://github.com/docker/for-mac/issues/1031>`__，因此您可能在尝试连接服务时遇到问题。

#. 检查 Docker 容器

::

    docker ps -a

#. 查看数据集采集日志

::

    logs-dataset-collection.sh

#. 等待定价引擎日志停止，按 ctrl+c

::

    logs-workers.sh

#. 验证 Redis 中是否存在价格数据

::

    redis-cli keys "*"

#. 可选 — 使用 automation-dataset-collection.yml Docker Compose 文件自动化价格数据采集 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/automation-dataset-collection.yml>__：

.. note:: 根据您希望日内算法运行的速度，您可以使用此 Docker Compose 作业，或者使用 `Kubernetes 作业 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/datasets/job.yml>`__，亦或是 `仅从 Tradier 获取数据的 Kubernetes 作业 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/k8/datasets/pull_tradier_per_minute.yml>`__ 来收集最新的价格信息。

::

    ./compose/start.sh -c

运行自定义的逐分钟日内算法回测并绘制交易历史

当 Redis 中已有价格数据后，您可以通过多种方式开始运行回测：

• 在 Jupyter Notebook 中比较三种训练用于预测股票收盘价的深度神经网络 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Comparing-3-Deep-Neural-Networks-Trained-to-Predict-a-Stocks-Closing-Price-Using-The-Analysis-Engine.ipynb>__
• 在 Jupyter Notebook 中构建、运行并调优算法，在运行过程中绘制余额与股票收盘价的关系图 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Run-a-Custom-Trading-Algorithm-Backtest-with-Minute-Timeseries-Pricing-Data.ipynb>__
• 使用此 Jupyter Notebook 分析并重放存储在 S3 中的算法交易历史 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Analyze%20Compressed%20Algorithm%20Trading%20Histories%20Stored%20in%20S3.ipynb>__
• 使用命令行回测工具运行 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/run_backtest_and_plot_history.py>__
• 进阶 — 构建一个独立的算法类以进行交易分析 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/mocks/example_algo_minute.py>__

使用实时日内价格数据运行算法

以下视频展示了如何运行该算法：

.. image:: https://asciinema.org/a/220498.png :target: https://asciinema.org/a/220498?autoplay=1 :alt: 使用实时日内价格数据运行算法

回测命令行工具 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/run_backtest_and_plot_history.py>__ 使用一个 算法配置字典 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/tests/algo_configs/test_5_days_ahead.json>__ 来构建多个 威廉指标 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/run_backtest_and_plot_history.py#L49>__ 成一个起始资金为 10,000.00 美元 的算法。配置完成后，回测工具会遍历每个交易数据集，并根据价格数据判断是否应该买入或卖出。处理完毕后，该工具将使用 matplotlib 和 seaborn 绘制一张图表，显示算法的 余额 以及股票每分钟的 收盘价。

::

# 这可能需要几分钟时间来评估
# 因为随着更多数据的收集
# 每天都有 390 行数据需要处理
bt -t SPY -f /tmp/history.json

.. note:: 算法的 交易历史 数据集提供了许多额外的列，可用于调整指标和自定义买卖规则。为了减少等待算法完成处理的时间，您可以使用 -f <save_to_file> 参数将整个交易历史保存到磁盘上。

从文件中查看分钟级算法的交易历史

一旦 交易历史 被保存到磁盘上，您可以重新打开它，并使用以下命令绘制数据集中其他列的图表：

.. image:: https://i.imgur.com/pH368gy.png

::

# 默认情况下，图表会显示
# 每分钟的余额与收盘价
plot-history -f /tmp/history.json

运行自定义算法并仅使用当日价格数据保存交易历史

以下是如何在实时交易时段运行算法的方法。这种方法假设有另一个进程或 cron 正在使用该引擎获取价格数据，以便算法可以访问最新的价格数据：

::

bt -t SPY -f /tmp/SPY-history-$(date +"%Y-%m-%d").json -j $(date +"%Y-%m-%d")

.. note:: 使用 -j <DATE> 参数可以让算法在开始交易前 跳转到指定日期。这对于调试指标、算法、数据集问题以及买卖规则非常有帮助。

使用外部算法模块和配置文件进行回测

使用包含在单个 Python 模块文件中的独立算法类，并通过磁盘上的配置文件来运行算法回测，该模块文件甚至可以位于仓库之外：

::

ticker=SPY
config=<CUSTOM_ALGO_CONFIG_DIR>/minute_algo.json
algo_mod=<CUSTOM_ALGO_MODULE_DIR>/minute_algo.py
bt -t ${ticker} -c ${algo_config} -g ${algo_mod}

或者，配置文件也可以使用 "algo_path": "<PATH_TO_FILE>" 来设置外部算法模块文件的路径。

::

bt -t ${ticker} -c ${algo_config}

.. note:: 使用独立算法类时，必须从 analysis_engine.algo.BaseAlgo 类派生。

构建您自己的交易算法

除了运行回测之外，所包含的引擎还支持同时运行多种算法并为实时交易或回测获取数据。随着您开始采用这种方法，您将生成大量的算法定价数据集、历史数据集，以及即将推出的用于 AI 训练的绩效数据集。由于这些算法使用相同的数据集结构，您可以与团队共享开箱即用的数据集，并将其发布到 S3 上，以便通过 Lambda 函数启动回测，或者仅用于灾难恢复的归档。

.. note:: 回测可以使用来自 S3、Redis 或文件的 开箱即用 数据集。

下一节将介绍如何从 Redis 中缓存的定价数据中构建 适用于算法的数据集 <https://github.com/AlgoTraders/stock-analysis-engine#extract-algorithm-ready-datasets>__。

运行本地回测并将算法交易历史发布到 S3

::

ae -t SPY -p s3://algohistory/algo_training_SPY.json

使用 -w 在引擎的工作节点上分布式运行

::

ae -w -t SPY -p s3://algohistory/algo_training_SPY.json

使用算法配置运行本地回测并提取适用于算法的数据集

使用此命令可使用附带的 算法配置 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/tests/algo_configs/test_5_days_ahead.json>__ 启动本地回测。回测完成后，还将生成一个保存到文件的本地算法就绪数据集。

#. 定义常用值

::

    ticker=SPY
    algo_config=tests/algo_configs/test_5_days_ahead.json
    extract_loc=file:/tmp/algoready-SPY-latest.json
    history_loc=file:/tmp/history-SPY-latest.json
    load_loc=${extract_loc}

运行带有提取和历史记录发布的算法

::

run-algo-history-to-file.sh -t ${ticker} -c ${algo_config} -e ${extract_loc} -p ${history_loc}

使用 vprof 分析您的算法代码性能

.. image:: https://i.imgur.com/1cwDUBC.png

pip 包含 vprof，用于分析算法性能（CPU、内存、剖析器和热图——与资金无关） <https://github.com/nvdv/vprof>__，上述 CPU 火焰图就是使用它生成的。

按照以下步骤分析您的算法代码性能：

#. 在第一个终端以远程模式启动 vprof

.. note:: 此命令将在端口 ``3434`` 上启动一个 Web 应用程序

::

    vprof -r -p 3434

#. 在第二个终端启动剖析器

.. note:: 此命令会将数据推送到另一个终端上监听端口 ``3434`` 的 Web 应用程序

::

    vprof -c cm ./analysis_engine/perf/profile_algo_runner.py

使用算法配置和算法就绪数据集运行本地回测

在生成本地算法就绪数据集后（这可能需要一些时间），使用此命令通过磁盘上的文件再次运行回测：

::

dev_history_loc=file:/tmp/dev-history-${ticker}-latest.json
run-algo-history-to-file.sh -t ${ticker} -c ${algo_config} -l ${load_loc} -p ${dev_history_loc}

查看买入和卖出交易

::

run-algo-history-to-file.sh -t ${ticker} -c ${algo_config} -l ${load_loc} -p ${dev_history_loc} | grep "TRADE"

绘制交易历史工具

绘制包含高点、低点、开盘价和收盘价的时间序列交易历史

::

sa -t SPY -H ${dev_history_loc}

运行并发布自定义算法的交易绩效报告

此操作将按顺序对过去 60 天进行回测，并运行 作为类示例的独立算法 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/mocks/example_algo_minute.py>__。完成后，它会将交易绩效报告发布到文件或 Minio（S3）。

将交易绩效报告写入本地文件

::

run-algo-report-to-file.sh -t SPY -b 60 -a /opt/sa/analysis_engine/mocks/example_algo_minute.py
# run-algo-report-to-file.sh -t <TICKER> -b <NUM_DAYS_BACK> -a <CUSTOM_ALGO_MODULE>
# 可以通过以下参数运行特定日期范围：
# -s <start date YYYY-MM-DD> -n <end date YYYY-MM-DD>

将交易绩效报告写入 Minio（S3）

::

run-algo-report-to-s3.sh -t SPY -b 60 -a /opt/sa/analysis_engine/mocks/example_algo_minute.py

运行并发布自定义算法的交易历史

此操作将按顺序对过去 60 天进行全面回测，并运行 示例算法 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/mocks/example_algo_minute.py>__。完成后，它会将交易历史发布到文件或 Minio（S3）。

将交易历史写入本地文件

::

run-algo-history-to-file.sh -t SPY -b 60 -a /opt/sa/analysis_engine/mocks/example_algo_minute.py

将交易历史写入 Minio（S3）

::

run-algo-history-to-s3.sh -t SPY -b 60 -a /opt/sa/analysis_engine/mocks/example_algo_minute.py

在 AWS 上开发

如果您对 AWS S3 的使用费用感到放心，那么您只需使用一个 Redis 服务器即可开发和调优算法。这对于团队以及用于灾难恢复的数据集归档都非常有用。

环境变量

根据您的 AWS IAM 凭证和 S3 终端节点导出以下变量。

::

export AWS_ACCESS_KEY_ID="ACCESS"
export AWS_SECRET_ACCESS_KEY="SECRET"
export S3_ADDRESS=s3.us-east-1.amazonaws.com

提取并发布到 AWS S3

::

./tools/backup-datasets-on-s3.sh -t TICKER -q YOUR_BUCKET -k ${S3_ADDRESS} -r localhost:6379

发布到自定义 AWS S3 存储桶和密钥

::

extract_loc=s3://YOUR_BUCKET/TICKER-latest.json ./tools/backup-datasets-on-s3.sh -t TICKER -e ${extract_loc} -r localhost:6379

使用 AWS S3 上的数据集回测自定义算法

::

backtest_loc=s3://YOUR_BUCKET/TICKER-latest.json
custom_algo_module=/opt/sa/analysis_engine/mocks/example_algo_minute.py
sa -t TICKER -a ${S3_ADDRESS} -r localhost:6379 -b ${backtest_loc} -g ${custom_algo_module}

通过 Kubernetes 每分钟获取新的 Tradier 价格数据

如果您想从 Tradier <https://developer.tradier.com/getting_started>__ 获取并追加新的期权定价数据，可以使用随附的 Kubernetes 作业配合 Cron 定时任务，每分钟拉取一次新数据：

::

kubectl -f apply /opt/sa/k8/datasets/pull_tradier_per_minute.yml

在 SPY 上运行分布式 60 天回测，并将交易报告、交易历史及算法就绪数据集发布至 S3

将回测和实盘交易算法发布到引擎的工作节点上，以便同时运行多个算法。完成后，算法会将结果发布到 S3、Redis 或本地文件中。默认情况下，以下示例会将所有数据集发布到 Minio（S3）中，用户可将其下载用于离线回测，或重新加载回 Redis。

.. 注意：运行分布式算法工作负载需要 Redis、Minio 和分析引擎处于运行状态。

::

num_days_back=60
./tools/run-algo-with-publishing.sh -t SPY -b ${num_days_back} -w

在本地对 SPY 进行 60 天回测，并将交易报告、交易历史及算法就绪数据集发布至 S3

::

num_days_back=60
./tools/run-algo-with-publishing.sh -t SPY -b ${num_days_back}

或者手动执行：

::

ticker=SPY
num_days_back=60
use_date=$(date +"%Y-%m-%d")
ds_id=$(uuidgen | sed -e 's/-//g')
ticker_dataset="${ticker}-${use_date}_${ds_id}.json"
echo "creating ${ticker} dataset: ${ticker_dataset}"
extract_loc="s3://algoready/${ticker_dataset}"
history_loc="s3://algohistory/${ticker_dataset}"
report_loc="s3://algoreport/${ticker_dataset}"
backtest_loc="s3://algoready/${ticker_dataset}"  # same as the extract_loc
processed_loc="s3://algoprocessed/${ticker_dataset}"  # archive it when done
start_date=$(date --date="${num_days_back} day ago" +"%Y-%m-%d")
echo ""
echo "extracting algorithm-ready dataset: ${extract_loc}"
echo "sa -t SPY -e ${extract_loc} -s ${start_date} -n ${use_date}"
sa -t SPY -e ${extract_loc} -s ${start_date} -n ${use_date}
echo ""
echo "running algo with: ${backtest_loc}"
echo "sa -t SPY -p ${history_loc} -o ${report_loc} -b ${backtest_loc} -e ${processed_loc} -s ${start_date} -n ${use_date}"
sa -t SPY -p ${history_loc} -o ${report_loc} -b ${backtest_loc} -e ${processed_loc} -s ${start_date} -n ${use_date}

Kubernetes 上的 Jupyter

此命令将在 AntiNex Kubernetes 集群 <https://deploy-to-kubernetes.readthedocs.io/en/latest/>__ 上运行 Jupyter：

::

./k8/jupyter/run.sh ceph dev

Kubernetes - 从交易历史中分析和调优算法

部署了分析引擎的 Jupyter 实例后，您可以使用此笔记本 从交易历史中调优算法 <https://aejupyter.example.com/notebooks/Analyze%20Compressed%20Algorithm%20Trading%20Histories%20Stored%20in%20S3.ipynb>__。

Kubernetes 作业 - 导出 SPY 数据集并发布到 Minio

手动运行时可使用 ssh-eng 别名：

::

function ssheng() {
    pod_name=$(kubectl get po | grep ae-engine | grep Running |tail -1 | awk '{print $1}')
    echo "logging into ${pod_name}"
    kubectl exec -it ${pod_name} bash
}
ssheng
# once inside the container on kubernetes
source /opt/venv/bin/activate
sa -a minio-service:9000 -r redis-master:6379 -e s3://backups/SPY-$(date +"%Y-%m-%d") -t SPY

查看算法就绪数据集

配置好 AWS CLI 后，您可以通过以下命令查看 Minio（S3）存储桶中可用的算法就绪数据集：

::

aws --endpoint-url http://localhost:9000 s3 ls s3://algoready

查看交易历史数据集

配置好 AWS CLI 后，您可以通过以下命令查看 Minio（S3）存储桶中可用的交易历史数据集：

::

aws --endpoint-url http://localhost:9000 s3 ls s3://algohistory

查看交易绩效报告数据集

配置好 AWS CLI 后，您可以通过以下命令查看 Minio（S3）存储桶中可用的交易绩效报告数据集：

::

aws --endpoint-url http://localhost:9000 s3 ls s3://algoreport

进阶 - 离线运行算法回测

借助 已在 Minio（S3）、Redis 或文件中提取的算法就绪数据集 <https://github.com/AlgoTraders/stock-analysis-engine#extract-algorithm-ready-datasets>__，您可以在本地开发和调优自己的算法，而无需运行 Redis、Minio、分析引擎或 Jupyter。

使用算法就绪文件进行离线自定义算法回测

::

# extract with:
sa -t SPY -e file:/tmp/SPY-latest.json
sa -t SPY -b file:/tmp/SPY-latest.json -g /opt/sa/analysis_engine/mocks/example_algo_minute.py

运行日内逐分钟算法并将算法就绪数据集发布到 S3

运行随附的独立算法 https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/mocks/example_algo_minute.py__，使用最新的定价数据集：

::

sa -t SPY -g /opt/sa/analysis_engine/mocks/example_algo_minute.py -e s3://algoready/SPY-$(date +"%Y-%m-%d").json

若需调试算法的历史交易表现，可添加 -d 调试标志：

::

sa -d -t SPY -g /opt/sa/analysis_engine/mocks/example_algo_minute.py -e s3://algoready/SPY-$(date +"%Y-%m-%d").json

提取算法就绪数据集

当定价数据缓存在 Redis 中时，您可以提取算法就绪数据集并将其保存为本地文件，以供离线历史回测分析使用。这同时也作为一份本地备份，将单个股票的所有缓存数据集中在一个本地文件中。

从 Redis 提取算法就绪数据集并保存为文件

::

sa -t SPY -e ~/SPY-latest.json

创建每日备份

::

sa -t SPY -e ~/SPY-$(date +"%Y-%m-%d").json

通过检查数据集文件验证每日备份

::

sa -t SPY -l ~/SPY-$(date +"%Y-%m-%d").json

通过检查数据集文件验证每日备份

::

sa -t SPY -l ~/SPY-$(date +"%Y-%m-%d").json

将备份恢复到 Redis

使用此命令缓存缺失的定价数据集，以便算法在做出买卖预测之前能够获得正确的准备就绪数据。

.. note:: 默认情况下，此命令不会覆盖 Redis 中已有的数据集。它被设计为在虚拟机重启后合并 Redis 定价数据集的工具，此时过去几天的定价数据可能缺失（定价数据中的缺口对算法不利）。

::

sa -t SPY -L ~/SPY-$(date +"%Y-%m-%d").json

获取

在 Redis 和 Minio 运行的情况下（./compose/start.sh），您可以获取、缓存、归档并返回所有最新 ticker 的数据集：

.. code-block:: python

from analysis_engine.fetch import fetch
d = fetch(ticker='SPY')
for k in d['SPY']:
    print(f'dataset key: {k}\nvalue {d["SPY"][k]}\n')

从 IEX Cloud 补充历史分钟级数据

.. note:: IEX Cloud 支持提取从今天起向前推算 30 天的数据 <https://iexcloud.io/docs/api/#historical-prices>__

::

fetch -t TICKER -F PAST_DATE -g iex_min
# 示例：
# fetch -t SPY -F 2019-02-07 -g iex_min

请参阅 Stock Analysis 入门：提取数据集 Jupyter 笔记本 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Stock-Analysis-Intro-Extracting-Datasets.ipynb>__ 获取最新的使用示例。

.. list-table:: :header-rows: 1

• • 构建 <https://travis-ci.org/AlgoTraders/stock-analysis-engine>__
• • .. image:: https://api.travis-ci.org/AlgoTraders/stock-analysis-engine.svg :alt: Travis 测试 :target: https://travis-ci.org/AlgoTraders/stock-analysis-engine

开始使用

本节概述了如何在本地运行 Stock Analysis 技术栈，包括：

• Redis
• Minio (S3)
• Stock Analysis 引擎
• Jupyter

从背景来看，该技术栈提供了一个数据管道，可自动将定价数据归档到 minio (s3) <https://minio.io>__ 并将定价数据缓存在 Redis 中。一旦数据被缓存或归档，自定义算法就可以利用这些定价信息来确定买入或卖出条件，并在历史回测中跟踪内部交易表现。

从技术角度来看，该引擎使用 Celery 工作进程处理重量级异步任务 <http://www.celeryproject.org/>，并且可以根据您需要运行的位置，支持多种传输和后端实现以实现水平扩展 <https://github.com/celery/celery#transports-and-backends>。该技术栈可以通过 Kubernetes <https://github.com/AlgoTraders/stock-analysis-engine#running-on-kubernetes>__ 或 Docker Compose 部署，并且 支持向 Slack 发布交易警报 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Stock-Analysis-Intro-Publishing-to-Slack.ipynb>__。

在技术栈已经运行的情况下，请参阅 使用 Jupyter Notebook 的 Stock Analysis 入门 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Stock-Analysis-Intro.ipynb>__ 获取更多入门示例。

使用 Docker Compose 设置您的 Tradier 账户

请在启动技术栈之前，在 Docker 环境文件中设置您的 Tradier 账户令牌：

::

grep -r SETYOURTRADIERTOKENHERE compose/*
compose/envs/backtester.env:TD_TOKEN=SETYOURTRADIERTOKENHERE
compose/envs/workers.env:TD_TOKEN=SETYOURTRADIERTOKENHER

请导出变量以便本地开发：

::

export TD_TOKEN=<TRADIER_ACCOUNT_TOKEN>

.. note:: 设置 Tradier 令牌环境变量后，请使用 ./compose/stop.sh 停止技术栈，然后使用 ./compose/start.sh 重新启动。

#. 启动 Redis 和 Minio

.. note:: Redis 和 Minio 容器被配置为将数据保存到 ``/data`` 目录，这样文件可以在重启后继续保留。在 Mac OS X 上，请确保在 Docker 偏好设置 -> 文件共享选项卡中添加 ``/data``（以及用于 Jupyter 笔记本的 ``/data/sa/notebooks``），并在尝试启动容器之前让 Docker 守护进程重新启动。否则，您可能会看到类似以下错误：

   ::

        ERROR: for minio  Cannot start service minio:
        b'Mounts denied: \r\nThe path /data/minio/data\r\nis not shared from OS X

    以下是手动创建共享卷目录的命令：

    ::

        sudo mkdir -p -m 777 /data/redis/data /data/minio/data /data/sa/notebooks/dev /data/registry/auth /data/registry/data

::

    ./compose/start.sh

#. 验证 Redis 和 Minio 是否正在运行

::

    docker ps | grep -E "redis|minio"

在 Ubuntu 和 CentOS 上运行

#. 安装软件包

Ubuntu

::

    sudo apt-get install make cmake gcc python3-distutils python3-tk python3 python3-apport python3-certifi python3-dev python3-pip python3-venv python3.6 redis-tools virtualenv libcurl4-openssl-dev libssl-dev

CentOS 7

::

    sudo yum install cmake gcc gcc-c++ make tkinter curl-devel make cmake python-devel python-setuptools python-pip python-virtualenv redis python36u-libs python36u-devel python36u-pip python36u-tkinter python36u-setuptools python36u openssl-devel

#. 安装 TA-Lib

请按照 `TA-Lib 安装指南 <https://mrjbq7.github.io/ta-lib/install.html>`__ 操作，或者以 root 用户身份使用附带的安装工具：

::

    sudo su
    /opt/sa/tools/linux-install-talib.sh
    exit

#. 创建并加载 Python 3 虚拟环境

::

    virtualenv -p python3 /opt/venv
    source /opt/venv/bin/activate
    pip install --upgrade pip setuptools

#. 安装 Analysis Pip

::

    pip install -e .

#. 验证 Pip 是否已安装

::

    pip list | grep stock-analysis-engine

在 Mac OS X 上运行

#. 下载 Python 3.6

.. note:: Celery 不支持 Python 3.7，因此请确保使用 Python 3.6 版本。

https://www.python.org/downloads/mac-osx/

#. 安装软件包

::

    brew install openssl pyenv-virtualenv redis freetype pkg-config gcc ta-lib

.. note:: 对于 Mac OS X 用户，请注意，目前尚未调试完成 ``keras``、``tensorflow`` 和 ``h5py`` 的安装问题。如果您在设置环境时遇到任何问题，请告知我们，因为我们可能尚未遇到过此类问题。

#. 创建并加载 Python 3 虚拟环境

::

    python3 -m venv /opt/venv
    source /opt/venv/bin/activate
    pip install --upgrade pip setuptools

#. 安装证书

在遇到 SSL 验证错误后，我找到了这个 Stack Overflow 帖子 https://stackoverflow.com/questions/42098126/mac-osx-python-ssl-sslerror-ssl-certificate-verify-failed-certificate-verify__，它指出对于 Python 3.6 的设置还需要额外的一步：

::

    /Applications/Python\ 3.6/Install\ Certificates.command

#. 使用 OpenSSL 安装 PyCurl

::

    PYCURL_SSL_LIBRARY=openssl LDFLAGS="-L/usr/local/opt/openssl/lib" CPPFLAGS="-I/usr/local/opt/openssl/include" pip install --no-cache-dir pycurl

#. 安装 Analysis Pip

::

    pip install --upgrade pip setuptools
    pip install -e .

#. 验证 Pip 是否已安装

::

    pip list | grep stock-analysis-engine

启动工作进程

::

./start-workers.sh

获取并发布定价数据

请参考仓库中的最新 API 文档：

https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/api_requests.py

获取新的股票数据集

使用 ./analysis_engine/scripts/fetch_new_stock_datasets.py <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/fetch_new_stock_datasets.py>__ 运行股票代码分析：

收集某个股票代码或证券符号的所有数据集

收集股票代码 SPY 的所有数据集：

::

fetch -t SPY

.. note:: 这需要以下服务正在监听：

- redis ``localhost:6379``
- minio ``localhost:9000``

查看引擎工作进程日志

::

docker logs ae-workers

在 Docker 容器内运行

如果您使用的引擎是在 Docker 容器内运行的，那么 localhost 可能不是查找 redis 和 minio 的正确网络主机名。

如果您正在使用 integration <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/integration.yml>__ 或 notebook integration <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/notebook-integration.yml>__ 这些用于部署分析引擎堆栈的 Docker Compose 文件，请根据需要设置这些值，以便发布和归档数据集工件：

::

fetch -t SPY -a 0.0.0.0:9000 -r 0.0.0.0:6379

.. warning:: 不建议让多个引擎工作进程同时共享同一个 Redis 服务器，无论它们是在 Docker 容器内还是容器外。这是因为目前 REDIS_ADDRESS 和 S3_ADDRESS 只能设置为一个字符串值。如果某个任务被错误的引擎（无法连接到正确的 Redis 和 Minio）拾取，就可能导致数据无法正确缓存或归档，并显示为连接失败。

详细使用示例

fetch_new_stock_datasets.py 脚本 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/fetch_new_stock_datasets.py>__ 支持许多参数。如果您有自定义的 redis 和 minio 部署，例如在 Kubernetes 上的 minio-service:9000 <https://github.com/AlgoTraders/stock-analysis-engine/blob/7323ad4007b44eaa511d448c8eb500cec9fe3848/k8/engine/deployment.yml#L80-L81>__ 和 redis-master:6379 <https://github.com/AlgoTraders/stock-analysis-engine/blob/7323ad4007b44eaa511d448c8eb500cec9fe3848/k8/engine/deployment.yml#L88-L89>__，可以这样设置：

• S3 认证（-k 和 -s）
• S3 端点（-a）
• Redis 端点（-r）
• 自定义 S3 Key 和 Redis Key 名称（-n）

::

fetch -t SPY -g all -u pricing -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -n SPY_demo -P 1 -N 1 -O 1 -U 1 -R 1

用法

请参考 fetch_new_stock_datasets.py 脚本 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/fetch_new_stock_datasets.py>__ 中最新的支持用法，因为以下内容可能已经过时：

::

fetch -h
2019-02-11 01:55:33,791 - fetch - INFO - start - fetch_new_stock_datasets
用法: fetch_new_stock_datasets.py [-h] [-t TICKER] [-g FETCH_MODE]
                                [-i TICKER_ID] [-e EXP_DATE_STR]
                                [-l LOG_CONFIG_PATH] [-b BROKER_URL]
                                [-B BACKEND_URL] [-k S3_ACCESS_KEY]
                                [-s S3_SECRET_KEY] [-a S3_ADDRESS]
                                [-S S3_SECURE] [-u S3_BUCKET_NAME]
                                [-G S3_REGION_NAME] [-p REDIS_PASSWORD]
                                [-r REDIS_ADDRESS] [-n KEYNAME]
                                [-m REDIS_DB] [-x REDIS_EXPIRE] [-z STRIKE]
                                [-c CONTRACT_TYPE] [-P GET_PRICING]
                                [-N GET_NEWS] [-O GET_OPTIONS]
                                [-U S3_ENABLED] [-R REDIS_ENABLED]
                                [-A ANALYSIS_TYPE] [-L URLS] [-Z] [-d]

下载并存储最新的股票定价、新闻和期权链数据，并将其存储在 Minio（S3）和 Redis 中。还支持获取 FinViz 筛选器中的股票代码。

可选参数： -h, --help 显示此帮助消息并退出 -t TICKER 股票代码 -g FETCH_MODE 可选 - 获取模式：initial = 默认从初始数据源（IEX和Tradier）获取，intra = 从IEX和Tradier获取日内数据，daily = 从IEX获取日线数据，weekly = 从IEX获取周线数据，all = 从所有数据源获取，td = 仅从Tradier数据源获取，iex = 仅从IEX Cloud数据源获取，iex_min = 获取IEX Cloud每分钟的日内数据 https://iexcloud.io/docs/api/#historical-prices iex_day = 获取IEX Cloud的日线数据 https://iexcloud.io/docs/api/#historical-prices iex_quote = 获取IEX Cloud的报价数据 https://iexcloud.io/docs/api/#quote iex_stats = 获取IEX Cloud的关键统计数据 https://iexcloud.io/docs/api/#key-stats iex_peers = 仅从IEX Cloud的同业数据获取 https://iexcloud.io/docs/api/#peers iex_news = 获取IEX Cloud的新闻数据 https://iexcloud.io/docs/api/#news iex_fin = 获取IEX Cloud的财务数据 https://iexcloud.io/docs/api/#financials iex_earn = 仅从IEX Cloud的收益数据获取 https://iexcloud.io/docs/api/#earnings iex_div = 仅从IEX Cloud的股息数据获取 https://iexcloud.io/docs/api/#dividends iex_comp = 仅从IEX Cloud的公司数据获取 https://iexcloud.io/docs/api/#company -i TICKER_ID 可选 - 股票代码ID，在没有数据库的情况下不使用 -e EXP_DATE_STR 可选 - 期权到期日期 -l LOG_CONFIG_PATH 可选 - 日志配置文件路径 -b BROKER_URL 可选 - Celery的经纪人URL -B BACKEND_URL 可选 - Celery的后端URL -k S3_ACCESS_KEY 可选 - S3访问密钥 -s S3_SECRET_KEY 可选 - S3秘密密钥 -a S3_ADDRESS 可选 - S3地址格式： host:port -S S3_SECURE 可选 - S3是否启用SSL -u S3_BUCKET_NAME 可选 - S3存储桶名称 -G S3_REGION_NAME 可选 - S3区域名称 -p REDIS_PASSWORD 可选 - redis密码 -r REDIS_ADDRESS 可选 - redis地址格式： host:port -n KEYNAME 可选 - redis和s3密钥名称 -m REDIS_DB 可选 - redis数据库编号（默认为0） -x REDIS_EXPIRE 可选 - redis过期时间（秒） -z STRIKE 可选 - 行权价 -c CONTRACT_TYPE 可选 - 合约类型，“C”表示看涨期权，“P”表示看跌期权 -P GET_PRICING 可选 - 是否获取定价数据，1表示启用，0表示禁用 -N GET_NEWS 可选 - 是否获取新闻数据，1表示启用，0表示禁用 -O GET_OPTIONS 可选 - 是否获取期权数据，1表示启用，0表示禁用 -U S3_ENABLED 可选 - 是否启用S3发布功能，1表示启用，0表示禁用 -R REDIS_ENABLED 可选 - 是否启用redis发布功能，1表示启用，0表示禁用 -A ANALYSIS_TYPE 可选 - 运行分析支持的模式：scn -L URLS 可选 - 用于拉取待分析股票代码的筛选器网址 -Z 禁用无引擎运行，用于本地测试和演示 -d 调试

运行FinViz筛选器驱动的分析

这是一项正在进行中的工作，但筛选器驱动的工作流程如下：

#. 将FinViz筛选器转换为股票代码列表 并从每个股票代码的HTML行中生成一个pandas.DataFrames #. 构建唯一的股票代码列表 #. 拉取每个股票代码的数据集 #. 执行卖方处理 - 即将推出 #. 执行买方处理 - 即将推出 #. 发送提醒至Slack - 即将推出

以下是如何对在两个FinViz筛选器网址中找到的所有唯一股票代码进行分析的方法：

https://finviz.com/screener.ashx?v=111&f=cap_midunder,exch_nyse,fa_div_o6,idx_sp500&ft=4 和 https://finviz.com/screener.ashx?v=111&f=cap_midunder,exch_nyse,fa_div_o8,idx_sp500&ft=4

::

fetch -A scn -L 'https://finviz.com/screener.ashx?v=111&f=cap_midunder,exch_nyse,fa_div_o6,idx_sp500&ft=4|https://finviz.com/screener.ashx?v=111&f=cap_midunder,exch_nyse,fa_div_o8,idx_sp500&ft=4'

从现有S3密钥到Redis的发布

#. 将集成测试密钥上传到S3

::

    export INT_TESTS=1
    python -m unittest tests.test_publish_pricing_update.TestPublishPricingData.test_integration_s3_upload

#. 确认集成测试密钥已在S3中

http://localhost:9000/minio/integration-tests/

#. 使用./analysis_engine/scripts/publish_from_s3_to_redis.py <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/publish_from_s3_to_redis.py>__，通过现有S3密钥运行分析

::

    publish_from_s3_to_redis.py -t SPY -u integration-tests -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -n integration-test-v1

#. 确认密钥现在已存在于Redis中

::

    ./tools/redis-cli.sh
    127.0.0.1:6379> keys *
    keys *
    1) "SPY_demo_daily"
    2) "SPY_demo_minute"
    3) "SPY_demo_company"
    4) "integration-test-v1"
    5) "SPY_demo_stats"
    6) "SPY_demo"
    7) "SPY_demo_quote"
    8) "SPY_demo_peers"
    9) "SPY_demo_dividends"
    10) "SPY_demo_news1"
    11) "SPY_demo_news"
    12) "SPY_demo_options"
    13) "SPY_demo_pricing"
    127.0.0.1:6379>

从S3到Redis聚合并发布股票数据

#. 使用./analysis_engine/scripts/publish_ticker_aggregate_from_s3.py <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/scripts/publish_ticker_aggregate_from_s3.py>__，通过现有S3密钥运行分析

::

    publish_ticker_aggregate_from_s3.py -t SPY -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -u pricing -c compileddatasets

#. 确认聚合后的股票数据现已存在于Redis中

::

    ./tools/redis-cli.sh
    127.0.0.1:6379> keys *latest*
    1) "SPY_latest"
    127.0.0.1:6379>

查看S3中的存档 - Minio

这里有一张截图，展示了在运行于用于分布式AI预测的3节点Kubernetes集群 <https://github.com/jay-johnson/deploy-to-kubernetes#deploying-a-distributed-ai-stack-to-kubernetes-on-centos>__时创建的股市数据集存档

.. image:: https://i.imgur.com/wDyPKAp.png

http://localhost:9000/minio/pricing/

登录

• 用户名: trexaccesskey
• 密码: trex123321

使用 AWS CLI 列出定价存储桶

请参阅官方文档，了解如何将 awscli pip 与 MinIO 配合使用：

https://docs.minio.io/docs/aws-cli-with-minio.html

#. 导出凭证

::

    export AWS_SECRET_ACCESS_KEY=trex123321
    export AWS_ACCESS_KEY_ID=trexaccesskey

#. 列出存储桶

::

    aws --endpoint-url http://localhost:9000 s3 ls
    2018-10-02 22:24:06 company
    2018-10-02 22:24:02 daily
    2018-10-02 22:24:06 dividends
    2018-10-02 22:33:15 integration-tests
    2018-10-02 22:24:03 minute
    2018-10-02 22:24:05 news
    2018-10-02 22:24:04 peers
    2018-10-02 22:24:06 pricing
    2018-10-02 22:24:04 stats
    2018-10-02 22:24:04 quote

#. 列出定价存储桶内容

::

    aws --endpoint-url http://localhost:9000 s3 ls s3://pricing

#. 获取最新的 SPY 定价键

::

    aws --endpoint-url http://localhost:9000 s3 ls s3://pricing | grep -i spy_demo
    SPY_demo

查看 Redis 中的缓存

::

./tools/redis-cli.sh
127.0.0.1:6379> keys *
1) "SPY_demo"

Jupyter

您可以通过以下命令启动 notebook-integration.yml 堆栈 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/notebook-integration.yml>__ 来运行 Jupyter 笔记本：

.. warning:: 在 Mac OS X 上，目前 Jupyter 尚无法与分析引擎协同工作。欢迎提交 PR，但我们尚未找到解决方法，即如何在 Mac OS X 上已知的 docker compose network_host 问题 <https://github.com/docker/for-mac/issues/1031>__ 的情况下共享笔记本并访问 Redis 和 MinIO。

对于 Linux 用户，Jupyter 容器会在以下 URL 上托管 股票分析入门笔记本 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Stock-Analysis-Intro.ipynb>__（默认登录密码为 admin）：

http://localhost:8888/notebooks/Stock-Analysis-Intro.ipynb

使用 RISE 进行 Jupyter 演示

该 Docker 容器预装了 RISE <https://github.com/damianavila/RISE>__，可用于从浏览器中运行笔记本演示。以下是用于启动网页演示的笔记本按钮：

.. image:: https://i.imgur.com/IDMW2Oc.png

使用 Docker 实现分布式自动化

.. note:: 自动化需要集成堆栈（Redis + MinIO + 引擎）以及 docker-compose 正在运行。

数据集收集

通过 docker-compose 启动自动化的数据集收集：

::

./compose/start.sh -c

Redis 中的数据集

运行数据集收集容器后，数据集应会自动缓存在 MinIO（http://localhost:9000/minio/pricing/）和 Redis 中：

::

./tools/redis-cli.sh
127.0.0.1:6379> keys *

发布到 Slack

请参阅 发布股票警报到 Slack 的 Jupyter 笔记本 <https://github.com/AlgoTraders/stock-analysis-engine/blob/master/compose/docker/notebooks/Stock-Analysis-Intro-Publishing-to-Slack.ipynb>__ 以获取最新的使用示例。

将 FinViz 筛选器中的股票代码发布到 Slack

以下是用于测试 Slack 集成的示例代码。

.. code-block:: python

import analysis_engine.finviz.fetch_api as fv
from analysis_engine.send_to_slack import post_df
# 简单的纽约证券交易所道琼斯指数金融板块，市盈率高于 5 的筛选器网址
url = 'https://finviz.com/screener.ashx?v=111&f=exch_nyse,fa_pe_o5,idx_dji,sec_financial&ft=4'
res = fv.fetch_tickers_from_screener(url=url)
df = res['rec']['data']

# 请确保 SLACK_WEBHOOK 环境变量已正确设置：
post_df(
    df=df[SLACK_FINVIZ_COLUMNS],
    columns=SLACK_FINVIZ_COLUMNS)

在 Kubernetes 上运行

Kubernetes 部署 - 引擎

使用以下命令部署引擎：

::

kubectl apply -f ./k8/engine/deployment.yml

Kubernetes 作业 - 数据集收集

使用以下命令启动数据集收集作业：

::

kubectl apply -f ./k8/datasets/job.yml

Kubernetes 部署 - Jupyter

使用以下命令将 Jupyter 部署到 Kubernetes 集群：

::

./k8/jupyter/run.sh

使用私有 Docker 注册表的 Kubernetes

您可以按照以下步骤部署一个私有 Docker 注册表，以便从 Kubernetes 集群外部拉取镜像：

#. 部署 Docker 注册表

::

    ./compose/start.sh -r

#. 配置 Kubernetes 主机及其他 Docker 守护进程，使其信任不安全的注册表

::

    cat /etc/docker/daemon.json
    {
        "insecure-registries": [
            "<运行注册表容器的主机的公有 IP 地址/FQDN>:5000"
        ]
    }

#. 重启所有 Docker 守护进程

::

    sudo systemctl restart docker

#. 从所有需要访问注册表的 Kubernetes 主机及其他守护进程登录到 Docker 注册表

.. note:: 您可以通过修改使用 ``trex`` 和 ``123321`` 作为凭据的 ``./compose/start.sh`` 文件来更改默认注册表密码，或者编辑挂载卷文件 ``/data/registry/auth/htpasswd``。以下是查找注册表默认登录设置的方法：

    ::

        grep docker compose/start.sh  | grep htpass

::

    docker login <运行注册表容器的主机的公有 IP 地址/FQDN>:5000

#. 为所有凭据设置 Kubernetes 秘密

根据您自己的存储桶、Docker 注册表和 Tradier 账户令牌设置每个字段：

::

    cat /opt/sa/k8/secrets/secrets.yml | grep SETYOUR
    aws_access_key_id: SETYOURENCODEDAWSACCESSKEYID
    aws_secret_access_key: SETYOURENCODEDAWSSECRETACCESSKEY
    .dockerconfigjson: SETYOURDOCKERCREDS
    td_token: SETYOURTDTOKEN

#. 部署 Kubernetes 秘密

::

    kubectl apply -f /opt/sa/k8/secrets/secrets.yml

#. 确认 Kubernetes 秘密已部署

::

    kubectl get secrets ae.docker.creds
    NAME              TYPE                             DATA   AGE
    ae.docker.creds   kubernetes.io/dockerconfigjson   1      4d1h

::

    kubectl get secrets | grep "ae\."
    ae.docker.creds         kubernetes.io/dockerconfigjson        1      4d1h
    ae.k8.aws.s3            Opaque                                3      4d1h
    ae.k8.minio.s3          Opaque                                3      4d1h
    ae.k8.tradier           Opaque                                4      4d1h

#. 配置 Kubernetes 部署以使用外部私有 Docker 注册表

根据您的设置，将以下行添加到 Kubernetes 部署 YAML 文件中：

imagePullSecrets: - name: ae.docker.creds containers: - image: <运行注册表容器的主机的公网IP地址或FQDN>:5000/my-own-stock-ae:latest imagePullPolicy: Always

.. 提示:: 在花费了不少时间进行调试之后，请务必在应用从外部注册表拉取 Docker 镜像的新 Pod 之前先删除旧的 Pod。执行 kubectl delete pod <name> 命令后，再应用或创建新的 Pod，即可运行最新镜像。

测试

要启用调试和跟踪日志记录，请将 SHARED_LOG_CFG 导出为一个调试日志 JSON 文件。要为本库开启调试模式，可以使用以下命令将其导出到仓库中包含的文件：

::

export SHARED_LOG_CFG=/opt/sa/analysis_engine/log/debug-logging.json

.. 注意:: 目前存在一个已知的 pandas 问题 <https://github.com/pandas-dev/pandas/issues/18141>__，它会记录关于 _timelex 的警告信息，并且在 pandas 修复该问题之前，此警告将持续出现。请暂时忽略此警告。

::

    DeprecationWarning: _timelex 是一个私有类，可能会在未通知的情况下中断工作，未来版本中它将被移动或重命名。

运行所有测试

::

py.test --maxfail=1

运行单个测试用例

::

python -m unittest tests.test_publish_pricing_update.TestPublishPricingData.test_success_publish_pricing_data

发布测试

S3 上传

::

python -m unittest tests.test_publish_pricing_update.TestPublishPricingData.test_success_s3_upload

从 S3 发布到 Redis

::

python -m unittest tests.test_publish_from_s3_to_redis.TestPublishFromS3ToRedis.test_success_publish_from_s3_to_redis

Redis 缓存设置

::

python -m unittest tests.test_publish_pricing_update.TestPublishPricingData.test_success_redis_set

准备数据集

::

python -m unittest tests.test_prepare_pricing_dataset.TestPreparePricingDataset.test_prepare_pricing_data_success

测试算法将所有输入数据集保存到文件

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_algo_can_save_all_input_datasets_to_file

端到端集成测试

使用脚本启动所有容器，以进行完整的端到端集成测试（使用真实 Docker 容器）：

::

./compose/start.sh -a

验证容器是否正在运行：

::

docker ps | grep -E "stock-analysis|redis|minio"

停止端到端堆栈：

::

./compose/stop.sh
./compose/stop.sh -s

集成单元测试

.. 注意:: 请在运行这些测试之前先启动 Redis 和 MinIO。

请启用集成测试：

::

export INT_TESTS=1

Redis

::

python -m unittest tests.test_publish_pricing_update.TestPublishPricingData.test_integration_redis_set

S3 上传

::

python -m unittest tests.test_publish_pricing_update.TestPublishPricingData.test_integration_s3_upload

从 S3 发布到 Redis

::

python -m unittest tests.test_publish_from_s3_to_redis.TestPublishFromS3ToRedis.test_integration_publish_from_s3_to_redis

IEX 测试 - 获取所有数据集

::

python -m unittest tests.test_iex_fetch_data

IEX 测试 - 每日获取

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_daily

IEX 测试 - 每分钟获取

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_minute

IEX 测试 - 获取统计数据

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_stats

IEX 测试 - 获取同行数据

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_peers

IEX 测试 - 获取新闻

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_news

IEX 测试 - 获取财务数据

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_financials

IEX 测试 - 获取收益数据

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_earnings

IEX 测试 - 获取股息数据

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_dividends

IEX 测试 - 获取公司信息

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_fetch_company

IEX 测试 - 获取财务数据辅助函数

::

python -m unittest tests.test_iex_fetch_data.TestIEXFetchData.test_integration_get_financials_helper

IEX 测试 - 提取每日数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_daily_dataset

IEX 测试 - 提取每分钟数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_minute_dataset

IEX 测试 - 提取报价数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_quote_dataset

IEX 测试 - 提取统计数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_stats_dataset

IEX 测试 - 提取同行数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_peers_dataset

IEX 测试 - 提取新闻数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_news_dataset

IEX 测试 - 提取财务数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_financials_dataset

IEX 测试 - 提取收益数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_earnings_dataset

IEX 测试 - 提取股息数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_dividends_dataset

IEX 测试 - 提取公司数据集

::

python -m unittest tests.test_iex_dataset_extraction.TestIEXDatasetExtraction.test_integration_extract_company_dataset

FinViz 测试 - 从筛选器 URL 获取股票代码

::

python -m unittest tests.test_finviz_fetch_api.TestFinVizFetchAPI.test_integration_test_fetch_tickers_from_screener

或者使用代码：

.. code-block:: python

import analysis_engine.finviz.fetch_api as fv
url = 'https://finviz.com/screener.ashx?v=111&f=exch_nyse&ft=4&r=41'
res = fv.fetch_tickers_from_screener(url=url)
print(res)

算法测试

算法测试——将输入数据集发布到 Redis

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_integration_algo_publish_input_dataset_to_redis

算法测试——将输入数据集发布到文件

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_integration_algo_publish_input_dataset_to_file

算法测试——从文件加载数据集

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_integration_algo_load_from_file

算法测试——将算法就绪的数据集发布到 S3 并从 S3 加载

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_integration_algo_publish_input_s3_and_load

算法测试——将算法就绪的数据集发布到 S3 并从 S3 加载

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_integration_algo_publish_input_redis_and_load

算法测试——从 Redis 数据库 0 中提取算法就绪的数据集，并加载到 Redis 数据库 1

在 Redis 数据库之间复制数据集是集成测试的一部分。运行方法如下：

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_integration_algo_restore_ready_back_to_redis

算法测试——测试文档示例

::

python -m unittest tests.test_base_algo.TestBaseAlgo.test_sample_algo_code_in_docstring

准备数据集

::

ticker=SPY
sa -t ${ticker} -f -o ${ticker}_latest_v1 -j prepared -u pricing -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -n ${ticker}_demo

调试

测试算法

运行算法最快的方式是指定一个 1 天的时间范围：

::

sa -t SPY -s $(date +"%Y-%m-%d) -n $(date +"%Y-%m-%d")

测试任务

大多数脚本都支持在没有 Celery 工作进程的情况下运行。要在同步模式下不使用工作进程运行，可以使用以下命令：

::

export CELERY_DISABLED=1

::

ticker=SPY
publish_from_s3_to_redis.py -t ${ticker} -u integration-tests -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -n integration-test-v1
sa -t ${ticker} -f -o ${ticker}_latest_v1 -j prepared -u pricing -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -n ${ticker}_demo
fetch -t ${ticker} -g all -e 2018-10-19 -u pricing -k trexaccesskey -s trex123321 -a localhost:9000 -r localhost:6379 -m 0 -n ${ticker}_demo -P 1 -N 1 -O 1 -U 1 -R 1
fetch -A scn -L 'https://finviz.com/screener.ashx?v=111&f=cap_midunder,exch_nyse,fa_div_o6,idx_sp500&ft=4|https://finviz.com/screener.ashx?v=111&f=cap_midunder,exch_nyse,fa_div_o8,idx_sp500&ft=4'

代码检查及其他工具

#. 代码检查

::

    flake8 .
    pycodestyle .

#. Sphinx 文档

::

    cd docs
    make html

#. Docker 管理——拉取最新镜像

::

    docker pull jayjohnson/stock-analysis-jupyter && docker pull jayjohnson/stock-analysis-engine

#. 备份 Docker Redis 数据库

::

    /opt/sa/tools/backup-redis.sh

查看本地 Redis 备份的方法如下：

::

    ls -hlrt /opt/sa/tests/datasets/redis/redis-0-backup-*.rdb

#. 将 Kubernetes Redis 集群的数据库导出到本地 Redis 容器

#.  停止 Redis Docker 容器：

    ::

        ./compose/stop.sh

#.  归档之前的 Redis 数据库

    ::

        cp /data/redis/data/dump.rdb /data/redis/data/archive.rdb

#.  保存集群中的 Redis 数据库

    ::

        kubectl exec -it redis-master-0 redis-cli save

#.  将 Pod 内保存的 Redis 数据库文件导出到默认 Docker Redis 容器的本地文件中

    ::

        kubectl cp redis-master-0:/bitnami/redis/data/dump.rdb /data/redis/data/dump.rdb

#.  重启堆栈

    .. note:: Redis 需要几秒钟才能将所有数据加载到内存中，因此这可能需要几秒钟时间

    ::

        ./compose/start.sh

将分叉的功能分支部署到正在运行的容器中

在开发影响多个容器的功能时，无需重新下载或手动构建 Docker 镜像，即可部署您自己的功能分支。当容器正在运行时，您可以将自己的分叉分支作为新镜像部署（这些镜像会自动保存为新的 Docker 容器镜像）。

将公共或私有分叉部署到正在运行的容器中

::

./tools/update-stack.sh <git 分叉 https uri> <可选——分支名称（默认为 master）> <可选——分叉仓库名称>

示例：

::

./tools/update-stack.sh https://github.com/jay-johnson/stock-analysis-engine.git timeseries-charts jay

将容器恢复到主分支

通过以下命令将容器构建恢复到来自 https://github.com/AlgoTraders/stock-analysis-engine 的 master 分支：

::

./tools/update-stack.sh https://github.com/AlgoTraders/stock-analysis-engine.git master upstream

部署分叉别名

以下是一个 bashrc 别名，用于快速从分叉的功能分支构建容器：

::

alias bd='pushd /opt/sa >> /dev/null && source /opt/venv/bin/activate && /opt/sa/tools/update-stack.sh https://github.com/jay-johnson/stock-analysis-engine.git timeseries-charts jay && popd >> /dev/null'

调试 IEX 数据获取

::

ticker="SPY"
use_date=$(date +"%Y-%m-%d")
source /opt/venv/bin/activate
exp_date=$(/opt/sa/analysis_engine/scripts/print_next_expiration_date.py)
fetch -t ${ticker} -g iex -n ${ticker}_${use_date} -e ${exp_date} -Z

Tradier 数据获取失败

如果您在尝试从 Tradier 获取定价数据时遇到以下错误，请确保在您的 compose/envs/*.env Docker Compose 文件中导出了有效的 TD_TOKEN：

::

2019-01-09 00:16:47,148 - analysis_engine.td.fetch_api - INFO - 获取put失败，响应=<Response [401]>，代码=401，文本=无效的访问令牌 2019-01-09 00:16:47,151 - analysis_engine.td.get_data - CRITICAL - 股票代码=TSLA-tdputs - 股票代码=TSLA 字段=10001 fetch_data 失败，异常='date' 2019-01-09 00:16:47,151 - analysis_engine.work_tasks.get_new_pricing_data - CRITICAL - 股票代码=TSLA TD获取失败，股票代码=TSLA 字段=tdputs 状态=ERR 错误=股票代码=TSLA-tdputs - 股票代码=TSLA 字段=10001 fetch_data 失败，异常='date'

许可证

Apache 2.0 - 请参阅 LICENSE_ 以获取更多详细信息

.. _License: https://github.com/AlgoTraders/stock-analysis-engine/blob/master/LICENSE

常见问题解答

我可以用我的算法进行实盘交易吗？

目前还不能。如果您想了解如何进行实盘交易，或者您已经有心仪的交易平台，请联系我们寻求帮助。

我可以发布算法交易通知吗？

目前，算法仅支持在发现买入或卖出交易机会时，将消息发布到私有的Slack频道中，供团队成员共享。如果您有自定义的聊天客户端应用或服务，并认为应该被支持，请随时与我们联系。

服务条款

数据归属

本仓库目前使用 Tradier <https://tradier.com/>__ 和 IEX <https://iextrading.com/developer/docs/>__ 提供的行情数据。使用这些数据源需要遵守其服务条款中的相关协议。

IEX Cloud

• IEX 使用条款链接：IEX's Terms of Use <https://iextrading.com/api-exhibit-a>__
• 本仓库使用了 IEX 实时行情 <https://iextrading.com/developer>__
• IEX Cloud 是一个数据源，其额外的数据归属说明可在 https://iextrading.com/developer/docs/#attribution 上找到。

添加Celery任务

如果您想添加一个新的Celery任务，请将文件路径添加到以下位置的 WORKER_TASKS 中：

• compose/envs/local.env
• compose/envs/.env
• analysis_engine/work_tasks/consts.py

Stock Analysis Engine 快速上手指南

Stock Analysis Engine 是一个用于构建和调整投资策略的开源引擎，支持利用人工智能（深度神经网络）进行回测。它提供分布式架构，可从 IEX Cloud、Tradier 等数据源自动获取公开交易公司的实时定价、期权、新闻及财务数据。

环境准备

在开始之前，请确保您的系统满足以下要求：

• 操作系统: Linux 或 macOS (Windows 用户建议使用 WSL2)。
  • 注意: macOS 用户需注意 Docker Compose 的 network_mode: "host" 已知兼容性问题，可能导致服务连接困难。
• 核心依赖:
  • Docker
  • Docker Compose
  • Git
• 数据源账户 (可选但推荐):
  • IEX Cloud: 需注册账户并获取 Token (按需计费)。
  • Tradier: 需注册开发者账户并获取 Token。
  • 注: 默认已禁用 Yahoo Finance 数据源。

安装步骤

1. 克隆项目代码

将仓库克隆到本地目录（示例使用 /opt/sa）：

git clone https://github.com/AlgoTraders/stock-analysis-engine.git /opt/sa
cd /opt/sa

2. 启动基础服务 (Redis & MinIO)

运行以下命令拉取 Redis 和 MinIO 的 Docker 镜像并创建挂载点：

./compose/start.sh -a

3. 配置数据源凭证

如果您计划从 IEX Cloud 或 Tradier 获取数据，请设置相应的环境变量：

# 替换为您的实际 Token
export IEX_TOKEN=YOUR_IEX_TOKEN
export TD_TOKEN=YOUR_TRADIER_TOKEN

4. 获取最新定价数据

使用 fetch 命令获取特定股票代码（例如 SPY）的数据：

# 从所有配置的数据源获取
fetch -t SPY

# 仅从 IEX Cloud 获取
fetch -t SPY -g iex

# 仅从 Tradier 获取
fetch -t SPY -g td

# 获取过去 30 天的分钟级历史数据 (仅限 IEX Cloud)
backfill-minute-data.sh SPY

5. 启动完整栈 (可选，用于实盘分析或完整回测)

如果需要运行 Worker、回测器、Jupyter Notebook 等完整组件：

./compose/start.sh

该命令会自动拉取约 3.0 GB 的 stock-analysis-engine 镜像并启动所有相关服务。

基本使用

验证数据缓存

数据获取后会被压缩存储在 Redis 中，您可以使用以下命令验证：

redis-cli keys "SPY_*"
redis-cli get "<key like SPY_2019-01-08_minute>"

运行简单回测 (Python API)

您可以使用 AlgoRunner API 加载最新数据并运行简单的策略回测。

创建一个 Python 脚本（例如 test_backtest.py）：

import analysis_engine.algo_runner as algo_runner
import analysis_engine.plot_trading_history as plot

# 初始化运行器，目标标的为 SPY
runner = algo_runner.AlgoRunner('SPY')

# 获取最新的 200 分钟数据
df = runner.latest()

# 打印最后 5 行的时间和收盘价
print(df[['minute', 'close']].tail(5))

# 绘制交易历史图表
plot.plot_trading_history(
    title=(
        f'SPY - ${df["close"].iloc[-1]} at: '
        f'{df["minute"].iloc[-1]}'),
    df=df)

# 如需启动完整回测，取消下面注释
# runner.start()

提取特定数据集

您也可以直接从 Redis 缓存中提取特定类型的数据（如分钟线、看涨期权、看跌期权）：

import analysis_engine.extract as ae_extract

# 提取 SPY 的分钟线及期权数据
print(ae_extract.extract(
    'SPY',
    datasets=['minute', 'tdcalls', 'tdputs']))

# 提取特定日期的历史数据 (格式：YYYY-MM-DD)
print(ae_extract.extract(
    'AAPL',
    datasets=['minute', 'daily', 'financials', 'earnings', 'dividends'],
    date='2019-02-15'))

进阶使用

• Jupyter Notebook: 项目内置了多个 Notebook 示例，可用于比较深度神经网络模型或自定义交易算法。
• 命令行回测: 使用 run_backtest_and_plot_history.py 脚本配合配置文件运行复杂回测。
• Kubernetes 部署: 生产环境用户可参考 Helm Chart 指南在 K8s 集群中部署。