1
2
3

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
system.portfolio.get_notional_position("DAX")

1
2
3

from systems.provided.futures_chapter15.estimatedsystem import futures_system
system=futures_system()
system.portfolio.get_notional_position("SOFR")

1
2
3

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
system.rules.get_raw_forecast("DAX", "ewmac64_256")

1
2
3
4
5
6
7

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
system.accounts.portfolio().stats() ## 查看一些统计量
system.accounts.portfolio().curve().plot() ## 画出账户净值曲线
system.accounts.portfolio().percent.curve().plot() ## 画出百分比账户净值曲线
system.accounts.pandl_for_instrument("US10").percent.stats() ## 输出 10 年期国债的百分比统计
system.accounts.pandl_for_instrument_forecast("SOFR", "carry").sharpe() ## 某条交易规则变体的夏普比率（Sharpe ratio）

1
2
3
4
5

from sysdata.config.configdata import Config
from systems.provided.futures_chapter15.basesystem import futures_system

my_config=Config("private.this_system_name.config.yaml")
system=futures_system(config=my_config)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
new_config=system.config

new_idm=1.1 ## 新的 IDM

new_config.instrument_div_multiplier=new_idm

## 下面是如何修改一个嵌套参数的示例
## 如果该元素在你的配置中还不存在：

system.config.volatility_calculation=dict(days=20)

## 如果它已经存在：
system.config.volatility_calculation['days']=20


system=futures_system(config=new_config)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()

## 我们对 system 做的任何操作都可能被缓存；
## 在系统看到新数值之前，缓存需要被清理……


new_idm=1.1 ## 新的 IDM
system.config.instrument_div_multiplier=new_idm

## 如果我们修改的是嵌套结构，为了避免清空默认值，
## 只修改其中的单个元素：
# 正确做法：
system.config.volatility_calculation['days']=20

# 不要这样做——它会抹掉 volatility_calculation 字典中其他所有元素：
# system.config.volatility_calculation=dict(days=20)


## 配置已经更新，但再次强调：任何用到它的东西
## 都需要从缓存中清除后再重新计算

1
2
3
4
5
6
7
8

instrument_weights:
    SOFR: 0.117
    US10: 0.117
    EUROSTX: 0.20
    V2X: 0.098
    MXP: 0.233
    CORN: 0.233
instrument_div_multiplier: 1.89

1
2
3
4
5
6

forecast_weights:
   SOFR:
     ewmac16_64: 0.21
     ewmac32_128: 0.08
     ewmac64_256: 0.21
     carry: 0.50

1

instruments: ["SOFR", "US10", "EUROSTX", "V2X", "MXP", "CORN"]

1

system.config.instruments = list(system.config.instrument_weights.keys())

1
2

rule_variations:
     SOFR: ['ewmac16_64','ewmac32_128', 'ewmac64_256', 'carry']

1
2
3
4
5
6

from sysdata.config.configdata import Config

my_config=Config("private.this_system_name.config.yaml")

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(config=my_config)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
new_config=system.config

new_weights=dict(SP500=0.5, KR10=0.5) ## 新的标的权重
new_idm=1.1 ## 新的 IDM

new_config.instrument_weights=new_weights
new_config.instrument_div_multiplier=new_idm

system=futures_system(config=new_config)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from systems.provided.futures_chapter15.estimatedsystem import futures_system
system=futures_system()
new_config=system.config

new_config.instruments=["SP500", "KR10"]

del(new_config.rule_variations) ## 表示所有品种都会使用所有交易规则

# 如果你希望给不同品种指定不同的规则集合，可以加上这一步（可选）
new_config.rule_variations=dict(SP500=['ewmac16_64','carry'], KR10=['ewmac32_128', 'ewmac64_256', 'carry'])

system=futures_system(config=new_config)

1
2

## 注意必须使用这种格式
start_date: '2000-01-19'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def trading_rule_function(data1):
   ## 对 data1 做一些处理

def trading_rule_function(data1, arg1=default_value):
   ## 对 data1 做一些处理
   ## 由 arg1 的取值来控制

def trading_rule_function(data1, data2):
   ## 对 data1 和 data2 做一些处理

def trading_rule_function(data1, data2, arg1=default_value, arg2=default_value):
   ## 对 data1 做一些处理
   ## 由 arg1 和 arg2 的取值来控制

1

from systems.futures.rules import ewmac

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

trading_rules:
  .... existing rules ...
  new_rule:
     function: systems.futures.rules.ewmac
     data:
         - "rawdata.daily_prices"
         - "rawdata.daily_returns_volatility"
     other_args:
         Lfast: 10
         Lslow: 40
#
#
## 以下部分用于固定的缩放因子、权重和分散化乘数：
#
forecast_scalars:
  ..... existing rules ....
  new_rule=10.6
#
forecast_weights:
  .... existing rules ...
  new_rule=0.10
#
forecast_div_multiplier=1.5
#
#
## 如果你要估计这些量，则使用下面这些配置：
#
use_forecast_weight_estimates: True
use_forecast_scale_estimates: True
use_forecast_div_mult_estimates: True

rule_variations:
     SOFR: ['ewmac16_64','ewmac32_128', 'ewmac64_256', 'new_rule']
#
# 或者如果所有品种使用相同的规则集合：
#
rule_variations: ['ewmac16_64','ewmac32_128', 'ewmac64_256', 'new_rule']
#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

from systems.trading_rules import TradingRule

# 方法一
new_rule = TradingRule(
   dict(function="systems.futures.rules.ewmac", data=["rawdata.daily_prices", "rawdata.daily_returns_volatility"],
        other_args=dict(Lfast=10, Lslow=40)))

# 方法二——适合于“现写”的函数
from systems.futures.rules import ewmac

new_rule = TradingRule(dict(function=ewmac, data=["rawdata.daily_prices", "rawdata.daily_returns_volatility"],
                            other_args=dict(Lfast=10, Lslow=40)))

## 两种方法都一样——接下来要修改配置：
config.trading_rules['new_rule'] = new_rule

## 如果你使用的是固定权重和缩放因子：

config.forecast_scalars['new_rule'] = 7.0
config.forecast_weights = dict(...., new_rule=0.10)  ## 所有已有的预测权重也需要重新调整
config.forecast_div_multiplier = 1.5

## 如果你使用的是估计值：

config.use_forecast_scale_estimates = True
config.use_forecast_weight_estimates = True
use_forecast_div_mult_estimates: True

config.rule_variations = ['ewmac16_64', 'ewmac32_128', 'ewmac64_256', 'new_rule']
# 或者为不同品种指定不同的规则集合：
config.rule_variations = dict(SP500=['ewmac16_64', 'ewmac32_128', 'ewmac64_256', 'new_rule'], US10=['new_rule', ....)

1
2
3
4

## 用新配置创建一个系统

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(config=config)

1
2
3

import pandas as pd
test=pd.read_csv("filename.csv")
test

1
2
3
4
5

from sysdata.sim.csv_futures_sim_data import csvFuturesSimData
from systems.provided.futures_chapter15.basesystem import futures_system

data=csvFuturesSimData(csv_data_paths=dict(csvFuturesAdjustedPricesData = "private.system_name.adjusted_price_data"))
system=futures_system(data=data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from systems.provided.futures_chapter15.basesystem import futures_system

system = futures_system()
system.accounts.portfolio().sharpe() ## 会执行一大堆计算，并把结果保存到缓存中

system.cache.pickle("private.this_system_name.system.pck") ## 文件扩展名可以随意

## 在新的会话中
from systems.provided.futures_chapter15.basesystem import futures_system

system = futures_system()
system.cache.unpickle("private.this_system_name.system.pck")

## 下面这步会快很多，并复用之前的计算结果
# 只有比较复杂的记账 P&L 对象不会被存入缓存
system.accounts.portfolio().sharpe()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from sysdata.sim.csv_futures_sim_data import csvFuturesSimData

data=csvFuturesSimData()

## 取出数据
data.methods() ## 列出所有方法

data.get_raw_price(instrument_code)
data[instrument_code] ## 等价于 get_raw_price

data.get_instrument_list()
data.keys() ## 同样可以得到品种列表

data.get_value_of_block_price_move(instrument_code)
data.get_instrument_currency(instrument_code)
data.get_fx_for_instrument(instrument_code, base_currency) # 获取品种货币与基准货币之间的汇率

1
2
3
4
5

## 与 system 配合使用
from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(data=data)

system.data.get_instrument_currency(instrument_code) # 以及其他类似方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

## 与 system 配合使用
from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(data=data)

# 也可以在 YAML 文件中做同样的设置。注意格式必须一致
system.config.start_date = '2000-01-19'

## 或者使用 datetime（显然不能在 YAML 中这么写）
import datetime
system.config.start_date = datetime.datetime(2000,1,19)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

from sysdata.sim.csv_futures_sim_data import csvFuturesSimData

## 使用默认目录
data=csvFuturesSimData()

## 或者通过传入一个字典来指定不同的目录
data=csvFuturesSimData(csv_data_paths = dict(key_name = "pathtodata.with.dots"))

# 允许使用的 key 名包括：
# 'csvFxPricesData'（外汇价格）、
# 'csvFuturesMultiplePricesData'（carry 与远期价格）、
# 'csvFuturesAdjustedPricesData' 和 'csvFuturesInstrumentData'（配置与成本）。
# 如果未提供某个 key，则会使用系统默认路径。

# 示例：覆盖默认设置，改用 /psystemtrade/private/data/fxdata/ 中的 FX 数据：

data=csvFuturesSimData(csv_data_paths = dict(csvFxPricesData="private.data.fxdata"))

# 警告：不要把 multiple_price_data 和 adjusted_price_data 放在同一目录下，
#       因为它们使用相同的文件名！

## 取出数据
data.methods() ## 会列出任何额外的方法
data.get_instrument_raw_carry_data(instrument_code) ## 期货特有的数据

## 与 system 配合使用
from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(data=data)
system.data.get_instrument_raw_carry_data(instrument_code)

1
2
3
4
5
6
7
8
9

from systems.provided.futures_chapter15.basesystem import futures_system
from sysdata.sim.db_futures_sim_data import dbFuturesSimData

# 使用默认数据库
data = dbFuturesSimData()

# 与 system 配合使用
system = futures_system()
print(system.accounts.portfolio().sharpe())

1
2
3
4
5
6
7
8

use_sim_classes = {
    FX_DATA: arcticFxPricesData,
    ROLL_PARAMETERS_DATA: csvRollParametersData,
    FUTURES_INSTRUMENT_DATA: csvFuturesInstrumentData,
    FUTURES_MULTIPLE_PRICE_DATA: arcticFuturesMultiplePricesData,
    FUTURES_ADJUSTED_PRICE_DATA: arcticFuturesAdjustedPricesData,
    STORED_SPREAD_DATA: mongoSpreadCostData,
}

1
2
3
4

from sysdata.config.configdata import Config

my_config_dict=dict(optionone=1, optiontwo=dict(a=3.0, b="beta", c=["a", "b"]), optionthree=[1.0, 2.0])
my_config=Config(my_config_dict)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

optionone: 1
optiontwo:
  a: 3.0
  b: "beta"
  c:
    - "a"
    - "b"
optionthree:
  - 1.0
  - 2.0

1
2

from sysdata.config.configdata import Config
my_config=Config("private.filename.yaml") ## 假设文件位于 "pysystemtrade/private/filename.yaml"

1
2
3

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
new_config=system.config

1
2
3
4

from sysdata.config.configdata import Config

my_config_dict=dict(optionfour=1, optionfive=dict(one=1, two=2.0))
my_config=Config(["filename.yaml", my_config_dict])

1
2
3

from sysinit.configtools.csvweights_to_yaml import instr_weights_csv_to_yaml  # 标的权重
from sysinit.configtools.csvweights_to_yaml import forecast_weights_by_instrument_csv_to_yaml  # 各品种的预测权重
from sysinit.configtools.csvweights_to_yaml import forecast_mapping_csv_to_yaml # 各品种的预测映射

1
2
3

from sysdata.config.configdata import Config
my_config=Config()
print(my_config) ## 空配置

1

 Config with elements:

1
2
3
4
5

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(config=my_config)

print(system.config) ## 充满默认值
print(my_config) ## 同一个对象

1

 Config with elements: average_absolute_forecast, base_currency, buffer_method, buffer_size, buffer_trade_to_edge, forecast_cap, forecast_correlation_estimate, forecast_div_mult_estimate, forecast_div_multiplier, forecast_scalar, forecast_scalar_estimate, forecast_weight_estimate, instrument_correlation_estimate, instrument_div_mult_estimate, instrument_div_multiplier, instrument_weight_estimate, notional_trading_capital, percentage_vol_target, use_SR_costs, use_forecast_scale_estimates, use_forecast_weight_estimates, use_instrument_weight_estimates, volatility_calculation

1

system.accounts.portfolio()

1
2

# 省略完整错误堆栈
Exception: A system config needs to include trading_rules, unless rules are passed when object created

1
2
3

my_config.optionone
my_config.optiontwo['a']
my_config.optionthree[0]

1
2
3

my_config.optionone=1.0
my_config.optiontwo['d']=5.0
my_config.optionthree.append(6.3)

1
2

my_config.optionfour=20.0
setattr(my_config, "optionfour", 20.0) ## 如果你更喜欢这种写法

1

del(my_config.optionone)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

config.instrument_div_multiplier=1.1 ## 非嵌套，没问题

## 以下示例展示如何修改一个嵌套参数
## 如果该元素在你的配置中尚不存在，
## 这么做没问题；但如果它已经存在，
## 这样写会覆盖掉该字段下所有其他参数——千万不要！

config.volatility_calculation=dict(days=20)

## 如果它已经存在，可以改为只更新某个 key：
config.volatility_calculation['days']=20

1
2
3
4
5
6
7
8

system.config.instrument_div_multiplier=1.1 ## 非嵌套，没问题

## 如果我们要修改嵌套项，应该只改其中一个元素，避免清空默认值：
# 正确方式：
system.config.volatility_calculation['days']=20

# 不要这样做：
# system.config.volatility_calculation=dict(days=20)

1
2

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system(config=my_config)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

## 假设你的配置项叫 my_config_item，在相关方法中：

 parameter=system.config.my_config_item

 ## 也可以使用嵌套配置项，例如按 instrument_code 作为 key 的字典（或者嵌套列表）
 parameter=system.config.my_config_dict[instrument_code]

 ## 列表同样适用：

 parameter=system.config.my_config_list[1]

 ## （注意：也可以使用 tuple，但 YAML 会比较难看，所以不建议这么做。）

1
2
3
4
5
6
7

my_config_item: "ni"
my_config_dict:
   US10: 45.0
   US5: 0.10
my_config_list:
   - "first item"
   - "second item"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from systems.provided.futures_chapter15.basesystem import futures_system
import yaml
from syscore.fileutils import resolve_path_and_filename_for_package

system = futures_system()
my_config = system.config

## 在这里对 my_config 做一些修改

filename = resolve_path_and_filename_for_package("private.this_system_name.config.yaml")

with open(filename, 'w') as outfile:
   outfile.write(yaml.dump(my_config, default_flow_style=True))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 假设 system 已经包含了带有估计值的系统
from systems.diagoutput import systemDiag

sysdiag = systemDiag(system)
sysdiag.yaml_config_with_estimated_parameters('someyamlfile.yaml',
                                              attr_names=['forecast_scalars',
                                                                  'forecast_weights',
                                                                  'forecast_div_multiplier',
                                                                  'forecast_mapping',
                                                                  'instrument_weights',
                                                                  'instrument_div_multiplier'])

1
2

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()

1
2
3

system=futures_system(data=my_data)
system=futures_system(config=my_config)
system=futures_system(data=my_data, config=my_config)

1
2

my_rules=dict(rule=a_new_rule)
system=futures_system(trading_rules=my_rules) ## 如果使用固定预测权重，这里很可能也需要一个新的配置

1
2

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()

1
2
3
4
5
6
7
8

data=csvFuturesSimData() ## 或者用户传入的 data 对象
config=Config("systems.provided.futures_chapter15.futuresconfig.yaml") ## 或者用户传入的 config 对象

## 用户可以选择性地传入 trading_rules（能被解析为一组交易规则的对象）；
## 如果留空（默认为 None），则使用配置中的规则。

system=System([Account(), Portfolios(), PositionSizing(), RawData(), ForecastCombine(),
                   ForecastScaleCap(), Rules(trading_rules)], data, config)

1
2

from systems.provided.futures_chapter15.estimatedsystem import futures_system
system=futures_system()

1
2
3
4
5
6
7
8

data=csvFuturesSimData() ## 或者用户传入的 data 对象
config=Config("systems.provided.futures_chapter15.futuresestimateconfig.yaml") ## 或者用户传入的 config 对象

## 用户可以选择性地传入 trading_rules（能被解析为一组交易规则的对象）；
## 如果留空（默认为 None），则使用配置中的规则。

system=System([Account(), Portfolios(), PositionSizing(), RawData(), ForecastCombine(),
                   ForecastScaleCap(), Rules(trading_rules)], data, config)

1

system.portfolio.get_notional_position("SOFR")

1

system.data.get_raw_price("SOFR")

1
2
3

system ## 列出所有阶段
system.accounts.methods() ## 列出某个阶段中的所有方法
system.data.methods() ## 对数据对象同样有效

1
2

system.config.trading_rules
system.config.instrument_div_multiplier=1.2

1
2
3
4
5
6

get_list_of_bad_markets
get_list_of_markets_not_trading_but_with_data
get_list_of_duplicate_instruments_to_remove
get_list_of_ignored_instruments_to_remove
get_list_of_instruments_to_remove
get_list_of_markets_with_trading_restrictions'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from copy import copy
from systems.provided.futures_chapter15.basesystem import futures_system

system=futures_system()
system.combForecast.get_combined_forecast("SOFR")

## 查看缓存中有什么？
system.cache.get_cache_refs_for_instrument("SOFR")

   [_get_forecast_scalar_fixed in forecastScaleCap for instrument SOFR [carry] , get_raw_forecast in rules for instrument SOFR [ewmac32_128]  ...


## 修改配置：
system.config.forecast_div_multiplier=0.1

## 由于结果已被缓存，这里得到的还是旧结果
system.combForecast.get_combined_forecast("SOFR")

## 但如果我们用新的配置重新创建系统……
system=futures_system(config=system.config)

## 检查缓存是否为空：
system.cache.get_cache_refs_for_instrument("SOFR")

## ……现在就会得到不同的结果
system.combForecast.get_combined_forecast("SOFR")

## 我们也可以关闭缓存
## 先清空缓存
system.cache.clear()

## ……此时缓存应该是空的
system.cache.get_cache_refs_for_instrument("SOFR")

## 现在关闭缓存
system.cache.set_caching_off()

## 再次获取数据：
system.combForecast.get_combined_forecast("SOFR")

## ……缓存仍然是空的
system.cache.get_cache_refs_for_instrument("SOFR")

1
2
3
4
5
6

from systems.provided.futures_chapter15.basesystem import futures_system

system = futures_system()
system.accounts.portfolio() ## 这里会运行整个回测，并把所有中间结果存入缓存

system.cache.pickle("private.this_system_name.system.pck") ## 文件扩展名可以任意

1
2
3
4
5
6

from systems.provided.futures_chapter15.basesystem import futures_system

system = futures_system()
system.cache.unpickle("private.this_system_name.system.pck")

system.accounts.portfolio() ## 这一步需要重新计算的内容会少很多

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()

# 第 2 步
system.accounts.portfolio().curve() ## 实际上相当于运行了一次完整回测

# 第 3 步
new_idm=1.1 ## 新的 IDM
system.config.instrument_div_multiplier=new_idm

# 第 4 步
system.cache.delete_all_items() ## 受保护的项目不会被删除
system.accounts.portfolio().curve() ## 重新运行回测

# 假设我们很满意——进入第 6 步
system.cache.delete_all_items(delete_protected=True)

## 或者，用修改后的配置重建系统：
new_config=system.config
system=futures_system(config=new_config)

## 第 7 步
system.accounts.portfolio().curve() ## 重新运行最终回测

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

 @dont_cache
 def _use_estimated_weights(self):
     return str2Bool(self.parent.config.use_forecast_weight_estimates)

 @dont_cache
 def _use_estimated_div_mult(self):
     # very simple
     return str2Bool(self.parent.config.use_forecast_div_mult_estimates)

 @input
 def get_forecast_cap(self):
     """
     Get the forecast cap from the previous module

     :returns: float

     KEY INPUT
     """

     return self.parent.forecastScaleCap.get_forecast_cap()

 @diagnostic()
 def get_trading_rule_list_estimated_weights(self, instrument_code):
     # snip

 @diagnostic(protected=True, not_pickable=True)
 def get_forecast_correlation_matrices_from_code_list(self, codes_to_use):
     # snip

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

## 为了获取数据，我们大概率需要这些

from sysdata.sim.csv_futures_sim_data import csvFuturesSimData
from sysdata.config.configdata import Config

## 导入所需的阶段
from systems.forecasting import Rules
from systems.basesystem import System
from systems.forecast_combine import ForecastCombine
from systems.forecast_scale_cap import ForecastScaleCap
from systems.rawdata import RawData
from systems.positionsizing import PositionSizing
from systems.portfolio import Portfolios
from systems.accounts.accounts_stage import Account


def futures_system(data=None, config=None, trading_rules=None):
    if data is None:
        data = csvFuturesSimData()

    if config is None:
        config = Config("systems.provided.futures_chapter15.futuresconfig.yaml")

    ## 保留动态加载交易规则的能力通常是件好事；
    ## 如果你不需要，也可以去掉 trading_rules 参数，直接写 rules=Rules()。
    rules = Rules(trading_rules)

    ## 构建 system
    system = System([Account(), Portfolios(), PositionSizing(), RawData(), ForecastCombine(),
                     ForecastScaleCap(), rules], data, config)

    return system

1
2
3
4
5

from systems.forecasting import Rules
from systems.basesystem import System
data=None ## 这样不会产生任何有用的结果

my_system=System([Rules()], data)

1
2
3

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
system

1

System with stages: accounts, portfolio, positionSize, rawdata, combForecast, forecastScaleCap, rules

1
2
3

from systems.provided.futures_chapter15.basesystem import futures_system
system=futures_system()
system.rawdata

1

SystemStage 'rawdata'

1

system.rawdata.get_raw_price("SOFR").tail(5)

1
2
3
4
5
6

              price
2015-04-16  97.9350
2015-04-17  97.9400
2015-04-20  97.9250
2015-04-21  97.9050
2015-04-22  97.8325

1
2
3
4
5
6
7
8
9

volatility_calculation:
  func: "sysquant.estimators.vol.robust_vol_calc"
  days: 35
  min_periods: 10
  vol_abs_min: 0.0000000001
  vol_floor: True
  floor_min_quant: 0.05
  floor_min_periods: 100
  floor_days: 500

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def trading_rule_function(data1):
   ## 对 data1 做一些处理

def trading_rule_function(data1, arg1=default_value):
   ## 对 data1 做一些处理
   ## 行为由 arg1 控制

def trading_rule_function(data1, data2):
   ## 对 data1 和 data2 做一些处理

def trading_rule_function(data1, data2, arg1=default_value, arg2=default_value):
   ## 对 data1 做一些处理
   ## 行为由 arg1 和 arg2 控制

1
2
3
4
5

from systems.trading_rules import TradingRule

TradingRule(ewmac)  ## 直接传函数对象
TradingRule("systems.provided.futures_chapter15.rules.ewmac")  ## 通过字符串引用函数

1

TradingRule(ewmac, data='rawdata.get_daily_prices', other_args=dict(Lfast=2, Lslow=8))

1

TradingRule(some_rule, data=['rawdata.get_daily_prices','data.get_raw_price'])

1

TradingRule(("systems.provided.futures_chapter15.rules.ewmac", ['rawdata.get_daily_prices','data.get_raw_price'], dict(Lfast=3, Lslow=12)))

1

TradingRule(dict(function="systems.provided.futures_chapter15.rules.ewmac", data=['rawdata.get_daily_prices','data.get_raw_price']))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

trading_rules:
  ewmac2_8:
     function: systems.futures.rules.ewmac
     data:
         - "data.daily_prices"
         - "rawdata.daily_returns_volatility"
     other_args:
         Lfast: 2
         Lslow: 8
     forecast_scalar: 10.6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

from systems.provided.futures_chapter15.basesystem import *
from systems.trading_rules import TradingRule

data = csvFuturesSimData()
config = Config(
   "systems.provided.futures_chapter15.futuresconfig.yaml")


# 首先，给 rawdata 增加一个新方法
# 除了常规的 instrument_code 外，它还接受一个关键字参数 span，我们将通过交易规则来控制它
class newRawData(RawData):
   def moving_average(self, instrument_code, span=8):
      price = self.get_daily_prices(instrument_code)
      return price.ewm(span=span).mean()


# 然后定义一个新的交易规则。multiplier 只是一个演示用的变量，说明你可以同时混合“普通参数”和数据参数
def new_ewma(fast_ewma, slow_ewma, vol, multiplier=1):
   raw_ewmac = fast_ewma - slow_ewma

   raw_ewmac = raw_ewmac * multiplier

   return raw_ewmac / vol.ffill()


# 下面定义第一条规则。注意 data 中用了两种移动平均线；
# 第一条的 span=2，第二条的 span=8
trading_rule1 = TradingRule(dict(function=new_ewma, data=['rawdata.moving_average', 'rawdata.moving_average',
                                                          'rawdata.daily_returns_volatility'],
                                 other_args=dict(_span=2, __span=8, multiplier=1)))

# 第二条规则重用了其中一条 ewma，但对 multiplier 和第一条 ewma 的 span 使用默认值
# （不算最佳实践，只是为了演示可能性）
trading_rule2 = TradingRule(dict(function=new_ewma, data=['rawdata.moving_average', 'rawdata.moving_average',
                                                          'rawdata.daily_returns_volatility'],
                                 other_args=dict(__span=32))

rules = Rules(dict(ewmac2_8=trading_rule1, ewmac8_32=trading_rule2))

system = System([
   Account(), Portfolios(), PositionSizing(), newRawData(),
   ForecastCombine(), ForecastScaleCap(), rules
], data, config)

# 现在可以像平常一样工作
system.rules.get_raw_forecast("DAX", "ewmac8_32")
system.rules.get_raw_forecast("DAX", "ewmac2_8")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

## 为了获取数据，我们大概率需要这些

from sysdata.sim.csv_futures_sim_data import csvFuturesSimData
from sysdata.config.configdata import Config
from systems.basesystem import System

## 导入所需阶段
from systems.forecasting import Rules
from systems.rawdata import RawData

data=csvFuturesSimData()
config=Config("systems.provided.futures_chapter15.futuresconfig.yaml")

rules=Rules()

## 构建系统
system=System([rules, RawData()], data, config)

rules

1
2

<snip>
Exception: A Rules stage needs to be part of a System to identify trading rules, unless rules are passed when object created

1
2
3

## 一旦 Rules 成为 system 的一部分，我们就能看到规则了
forecast=system.rules.get_raw_forecast('DAX','ewmac2_8')
rules

1

Rules object with rules ewmac32_128, ewmac64_256, ewmac16_64, ewmac8_32, ewmac4_16, ewmac2_8, carry

1
2

##
rules.trading_rules()

1
2
3
4
5
6
7

{'carry': TradingRule; function: <function carry at 0xb2e0f26c>, data: rawdata.daily_annualised_roll, rawdata.daily_returns_volatility and other_args: smooth_days,
 'ewmac16_64': TradingRule; function: <function ewmac at 0xb2e0f224>, data: rawdata.daily_prices, rawdata.daily_returns_volatility and other_args: Lfast, Lslow,
 'ewmac2_8': TradingRule; function: <function ewmac at 0xb2e0f224>, data: rawdata.daily_prices, rawdata.daily_returns_volatility and other_args: Lfast, Lslow,
 'ewmac32_128': TradingRule; function: <function ewmac at 0xb2e0f224>, data: rawdata.daily_prices, rawdata.daily_returns_volatility and other_args: Lfast, Lslow,
 'ewmac4_16': TradingRule; function: <function ewmac at 0xb2e0f224>, data: rawdata.daily_prices, rawdata.daily_returns_volatility and other_args: Lfast, Lslow,
 'ewmac64_256': TradingRule; function: <function ewmac at 0xb2e0f224>, data: rawdata.daily_prices, rawdata.daily_returns_volatility and other_args: Lfast, Lslow,
 'ewmac8_32': TradingRule; function: <function ewmac at 0xb2e0f224>, data: rawdata.daily_prices, rawdata.daily_returns_volatility and other_args: Lfast, Lslow}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

## 导入需要的阶段
from systems.forecasting import Rules

## 传入单条规则。以下几种写法都可以，详见“Trading rules”一节
trading_rule=TradingRule(ewmac)
trading_rule=(ewmac, 'rawdata.get_daily_prices', dict(Lfast=2, Lslow=8))
trading_rule=dict(function=ewmac, data='rawdata.get_daily_prices', other_args=dict(Lfast=2, Lslow=8))

rules=Rules(trading_rule)
## 规则会被自动赋予一个名字

## 传入规则列表。每条规则都可以用任意一种方式定义
trading_rule1=(ewmac, 'rawdata.get_daily_prices', dict(Lfast=2, Lslow=8))
trading_rule2=dict(function=ewmac, other_args=dict(Lfast=4, Lslow=16))

rules=Rules([trading_rule1, tradingrule2])
## 各规则会被自动赋予名字

## 传入规则字典。每条规则的定义方式同样可以不同
trading_rule1=(ewmac, 'rawdata.get_daily_prices', dict(Lfast=2, Lslow=8))
trading_rule2=dict(function=ewmac, other_args=dict(Lfast=4, Lslow=16))

rules=Rules(dict(ewmac2_8=trading_rule1, ewmac4_16=tradingrule2))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from systems.trading_rules import TradingRule, create_variations_oneparameter, create_variations

## 先为 ewmac 创建 3 个变体
## 默认 ewmac 的 Lslow=128
## 这里固定 Lslow 只调整 Lfast
rule = TradingRule("systems.provided.rules.ewmac.ewmac_forecast_with_defaults")
variations = create_variations_oneparameter(rule, [4, 10, 100], "ewmac_Lfast")

variations.keys()

1

dict_keys(['ewmac_Lfast_4', 'ewmac_Lfast_10', 'ewmac_Lfast_100'])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

## 现在同时调整 Lslow 和 Lfast
rule=TradingRule("systems.provided.rules.ewmac.ewmac_forecast_with_defaults")

## 每个具体规则由一个 dict 指定；我们也可以用 lambda 自动生成这个列表
variations=create_variations(rule, [dict(Lfast=2, Lslow=8), dict(Lfast=4, Lslow=16)], key_argname="Lfast")
variations.keys()
   dict_keys(['ewmac_Lfast_4', 'ewmac_Lfast_2'])

variations['Lfast_2'].other_args
   {'Lfast': 4, 'Lslow': 16}

1
2

## 构建系统
system=System([rules, RawData()], data, config)

1

del(config.forecast_weights)

1
2
3
4
5
6
7

from systems.provided.futures_chapter15.basesystem import futures_system

## 像前文示例一样创建 my_rules，例如：
trading_rule1=(ewmac, 'rawdata.get_daily_prices', dict(Lfast=2, Lslow=8))
trading_rule2=dict(function=ewmac, other_args=dict(Lfast=4, Lslow=16))

system=futures_system(trading_rules=dict(ewmac2_8=trading_rule1, ewmac4_16=tradingrule2)) ## 可能还需要调整配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from systems.provided.futures_chapter15.basesystem import futures_system
from systems.trading_rules import TradingRule

system = futures_system()

## 解析配置中的现有规则
## （如果你已经先跑过一次回测，这一步会在过程中自动完成）
system.rules.trading_rules()

#############
## 通过访问私有属性添加一条新规则
new_rule = TradingRule(
   "systems.provided.futures_chapter15.rules.ewmac")  ## 任何形式的 TradingRule 都可以
system.rules._trading_rules['new_rule'] = new_rule
#############


#############
## 修改 key 为 'ewmac2_8' 的既有规则
modified_rule = system.rules._trading_rules['ewmac2_8']
modified_rule.other_args['Lfast'] = 10

## 还可以做类似操作：
## modified_rule.function=new_function
## modified_rule.data='data.get_raw_price'
##

system.rules._trading_rules['ewmac2_8'] = modified_rule
#############


#############
## 删除一条规则（不推荐）
## 从固定预测权重列表或 rule_variations（用于估计预测权重）中移除该规则也能达到类似效果——而且你无论如何都要这么做
## 不在权重或变体列表中的规则不会参与计算，因此删除规则在速度或空间上没有实质收益
##
system.rules._trading_rules.pop("ewmac2_8")
#############