vectorbt学习_43DMA之三滑窗网格参数优选

本文在上一篇文章(vectorbt学习_17DMA之二网格参数优选)基础上，采用滚动窗口+网格参数优选，分析出动态最优参数。

01,基础配置信息#

1
#conda envs:vectorbt_env
2
import warnings
3
import vectorbt as vbt
4
import numpy as np
5
import pandas as pd
6
from datetime import datetime, timedelta
7
import pytz
8
from dateutil.parser import parse
9
import ipywidgets as widgets
10
from copy import deepcopy
11
from tqdm import tqdm
12
import imageio
13
from IPython import display
14
import plotly.graph_objects as go
15
import itertools
16
import dateparser
17
import gc
18
import math
19
from tools import dbtools
20

21
warnings.filterwarnings("ignore")
22

23
pd.set_option('display.max_rows',500)
24
pd.set_option('display.max_columns',500)
25
pd.set_option('display.width',1000)

02,行情获取和可视化#

a,时间交易参数配置#

1
# Enter your parameters here
2
seed = 42
3
symbol = '002594.XSHE'
4
metric = 'total_return'
5

6
start_date = datetime(2020, 1, 1, tzinfo=pytz.utc)  # time period for analysis, must be timezone-aware
7
end_date = datetime(2023,1,1, tzinfo=pytz.utc)
8
time_buffer = timedelta(days=100)  # buffer before to pre-calculate SMA/EMA, best to set to max window
9
freq = '1D'
10

11
vbt.settings.portfolio['init_cash'] = 10000.  # 100$
12
vbt.settings.portfolio['fees'] = 0.0025  # 0.25%
13
vbt.settings.portfolio['slippage'] = 0.0025  # 0.25%

b,获取行情和行情mask#

1
# Download data with time buffer
2
cols = ['Open', 'High', 'Low', 'Close', 'Volume']
3
# ohlcv_wbuf = vbt.YFData.download(symbol, start=start_date-time_buffer, end=end_date).get(cols)
4

5
ohlcv_wbuf=dbtools.MySQLData.download(symbol).get() # 自带工具类查询
6
assert(~ohlcv_wbuf.empty)
7
ohlcv_wbuf = ohlcv_wbuf.astype(np.float64)
8

9
print("origin ohlcv_wbuf size:",ohlcv_wbuf.shape)
10
print(ohlcv_wbuf.columns)
11

12

13
# Create a copy of data without time buffer
14
wobuf_mask = (ohlcv_wbuf.index >= start_date) & (ohlcv_wbuf.index <= end_date) # mask without buffer
15

16
ohlcv = ohlcv_wbuf.loc[wobuf_mask, :]
17

18
print("wobuf_mask ohlcv size:",ohlcv.shape)
19

20
# Plot the OHLC data
21
ohlcv.vbt.ohlcv.plot().show_svg() # 绘制蜡烛图
22
# remove show_svg() to display interactive chart!

1
origin ohlcv_wbuf size: (978, 5)
2
Index(['Open', 'High', 'Low', 'Close', 'Volume'], dtype='object')
3
wobuf_mask ohlcv size: (728, 5)

svg

20,行情的滑窗处理#

注意点：
01，训练集和验证集比例3：1，或者2：1，对应：window_len和set_lens为4<1>(或3<1>)，过大了历史包袱沉重，无法及时响应最新行情，过小了则容易参数跳变，形成类似过拟合效果
02，直观感受是验证集最好收尾相接，实际并非最佳，验证集过短会导致无法触发信号生成，从而形成无交易区间。

a,参数设置和效果预览#

1
# 滚动周期参数设置和大致效果可视化
2
start_end_days=((end_date-start_date).days*5/7)
3
bar_days= 80         # 训练，验证集时间长度，以此为单位
4
test_bar_num=2      # 训练集时间长度
5
verify_bar_num=1    # 验证集时间长度
6
verify_overlap=0 # 验证集重叠时间长度
7
pre_test_days=40    # 由于测试集一部分时间用于计算指标，导致实际训练时间不足，这个是一定程度补充的days周期
8
# n取值需要满足:确保验证集合收尾相接
9
# => (n-1)*(verify_bar_num-verify_overlap)+(verify_bar_num+test_bar_num)=start_end_days/bar_days
10
# => n=(start_end_days/bar_days-test_bar_num-verify_overlap)/(verify_bar_num-verify_overlap)
11
calc_n=(start_end_days/bar_days-test_bar_num-verify_overlap)/(verify_bar_num-verify_overlap)
12

13
split_kwargs = dict(
14
    n=int(calc_n),
15
    window_len=int(bar_days*(test_bar_num+verify_bar_num)+pre_test_days),
16
    set_lens=(int(bar_days*verify_bar_num),),
17
    left_to_right=False
18
)  # 10 windows, each 2 years long, reserve 180 days for test
19
# 合理设置n，最好确保验证集，连续且无重复
20
pf_kwargs = dict(
21
    direction='both',  # long and short
22
    freq='d'
23
)
24
windows = np.arange(10, 50)
25

26

27

28
def roll_in_and_out_samples(price, **kwargs):
29
    return price.vbt.rolling_split(**kwargs)
30

31
price=ohlcv['Close']
32
# 验证：单列数据验证，橘黄色验证集连续且无重复
33
roll_in_and_out_samples(price, **split_kwargs, plot=True, trace_names=['in-sample', 'out-sample']).show_svg()
34

35
# 大致观察数据特征
36
(in_price, in_indexes), (out_price, out_indexes) = roll_in_and_out_samples(price, **split_kwargs)
37

38
print(in_price.shape, len(in_indexes))  # in-sample
39
print(out_price.shape, len(out_indexes))  # out-sample
40
print(in_price.columns)
41
print(in_price[0:3])
42

43
# 这里仅仅用于print数据是否符合期望。
44
def simulate_all_params(price, windows, **kwargs):
45
    fast_ma, slow_ma = vbt.MA.run_combs(price, windows, r=2, short_names=['fast', 'slow'])
46
    entries = fast_ma.ma_crossed_above(slow_ma)
47
    exits = fast_ma.ma_crossed_below(slow_ma)
48
    pf = vbt.Portfolio.from_signals(price, entries, exits, **kwargs)
49
    return pf.sharpe_ratio()
50
# Simulate all params for in-sample ranges
51
in_sharpe = simulate_all_params(in_price, windows, **pf_kwargs)
52
print(in_sharpe[:3])

svg

1
(200, 7) 7
2
(80, 7) 7
3
Int64Index([0, 1, 2, 3, 4, 5, 6], dtype='int64', name='split_idx')
4
split_idx      0      1      2       3       4       5       6
5
0          48.17  56.98  81.93  175.29  169.00  223.97  310.26
6
1          48.04  56.98  82.92  177.97  164.51  227.50  311.99
7
2          48.28  58.00  82.18  173.24  169.07  241.23  306.78
8
fast_window  slow_window  split_idx
9
10           11           0           -0.354158
10
                          1            1.117491
11
                          2            0.551415
12
Name: sharpe_ratio, dtype: float64

b,根据滑窗参数切分行情数据#

1
(in_price, in_indexes), (out_price, out_indexes) = roll_in_and_out_samples(price, **split_kwargs)
2

3
print(in_price.shape, len(in_indexes))  # in-sample
4
print(out_price.shape, len(out_indexes))  # out-sample
5

6
print(in_indexes[0:3])
7

8
print("###################")
9
print(in_indexes[0][0])
10
print(in_indexes[1][0])
11
print(in_indexes[0][25:27])

1
(200, 7) 7
2
(80, 7) 7
3
[DatetimeIndex(['2020-01-02 00:00:00+00:00', '2020-01-03 00:00:00+00:00', '2020-01-06 00:00:00+00:00', '2020-01-07 00:00:00+00:00', '2020-01-08 00:00:00+00:00', '2020-01-09 00:00:00+00:00', '2020-01-10 00:00:00+00:00', '2020-01-13 00:00:00+00:00', '2020-01-14 00:00:00+00:00', '2020-01-15 00:00:00+00:00',
4
               ...
5
               '2020-10-20 00:00:00+00:00', '2020-10-21 00:00:00+00:00', '2020-10-22 00:00:00+00:00', '2020-10-23 00:00:00+00:00', '2020-10-26 00:00:00+00:00', '2020-10-27 00:00:00+00:00', '2020-10-28 00:00:00+00:00', '2020-10-29 00:00:00+00:00', '2020-10-30 00:00:00+00:00', '2020-11-02 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_0', length=200, freq=None), DatetimeIndex(['2020-04-27 00:00:00+00:00', '2020-04-28 00:00:00+00:00', '2020-04-29 00:00:00+00:00', '2020-04-30 00:00:00+00:00', '2020-05-06 00:00:00+00:00', '2020-05-07 00:00:00+00:00', '2020-05-08 00:00:00+00:00', '2020-05-11 00:00:00+00:00', '2020-05-12 00:00:00+00:00', '2020-05-13 00:00:00+00:00',
6
               ...
7
               '2021-02-03 00:00:00+00:00', '2021-02-04 00:00:00+00:00', '2021-02-05 00:00:00+00:00', '2021-02-08 00:00:00+00:00', '2021-02-09 00:00:00+00:00', '2021-02-10 00:00:00+00:00', '2021-02-18 00:00:00+00:00', '2021-02-19 00:00:00+00:00', '2021-02-22 00:00:00+00:00', '2021-02-23 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_1', length=200, freq=None), DatetimeIndex(['2020-08-14 00:00:00+00:00', '2020-08-17 00:00:00+00:00', '2020-08-18 00:00:00+00:00', '2020-08-19 00:00:00+00:00', '2020-08-20 00:00:00+00:00', '2020-08-21 00:00:00+00:00', '2020-08-24 00:00:00+00:00', '2020-08-25 00:00:00+00:00', '2020-08-26 00:00:00+00:00', '2020-08-27 00:00:00+00:00',
8
               ...
9
               '2021-05-31 00:00:00+00:00', '2021-06-01 00:00:00+00:00', '2021-06-02 00:00:00+00:00', '2021-06-03 00:00:00+00:00', '2021-06-04 00:00:00+00:00', '2021-06-07 00:00:00+00:00', '2021-06-08 00:00:00+00:00', '2021-06-09 00:00:00+00:00', '2021-06-10 00:00:00+00:00', '2021-06-11 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_2', length=200, freq=None)]
10
###################
11
2020-01-02 00:00:00+00:00
12
2020-04-27 00:00:00+00:00
13
DatetimeIndex(['2020-02-14 00:00:00+00:00', '2020-02-17 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_0', freq=None)

21,滑窗的收益数据计算#

a,持有参数收益#

在此区间，基础标的物表现

1
def simulate_holding(price, **kwargs):
2
    pf = vbt.Portfolio.from_holding(price, **kwargs)
3
    return pf.sharpe_ratio()
4

5
in_hold_sharpe = simulate_holding(in_price, **pf_kwargs)
6
print(in_hold_sharpe.head(5))
7

8
out_hold_sharpe = simulate_holding(out_price, **pf_kwargs)
9
print(out_hold_sharpe.head(5))

1
split_idx
2
0    3.604669
3
1    3.897711
4
2    2.890238
5
3    1.095362
6
4    1.425303
7
Name: sharpe_ratio, dtype: float64
8
split_idx
9
0    1.849248
10
1    1.152267
11
2    1.266940
12
3   -0.093093
13
4    1.274854
14
Name: sharpe_ratio, dtype: float64

b,网格参数收益(训练集和验证集)#

1
def simulate_all_params(price, windows, **kwargs):
2
    fast_ma, slow_ma = vbt.MA.run_combs(price, windows, r=2, short_names=['fast', 'slow'])
3
    entries = fast_ma.ma_crossed_above(slow_ma)
4
    exits = fast_ma.ma_crossed_below(slow_ma)
5
    pf = vbt.Portfolio.from_signals(price, entries, exits, **kwargs)
6
    return pf.sharpe_ratio()
7
# Simulate all params for in-sample ranges
8
in_sharpe = simulate_all_params(in_price, windows, **pf_kwargs)
9
print(in_sharpe.shape)
10
print(in_sharpe)
11

12

13
# Simulate all params for out-sample ranges
14
out_sharpe = simulate_all_params(out_price, windows, **pf_kwargs)
15
print(out_sharpe)

1
(5460,)
2
fast_window  slow_window  split_idx
3
10           11           0           -0.354158
4
                          1            1.117491
5
                          2            0.551415
6
                          3            0.336980
7
                          4           -0.918363
8
                                         ...
9
48           49           2           -0.758895
10
                          3           -0.629667
11
                          4           -0.100832
12
                          5           -1.404637
13
                          6           -0.398260
14
Name: sharpe_ratio, Length: 5460, dtype: float64
15
fast_window  slow_window  split_idx
16
10           11           0            1.827234
17
                          1           -1.103760
18
                          2           -2.128081
19
                          3           -1.757578
20
                          4            1.088042
21
                                         ...
22
48           49           2                 inf
23
                          3            1.676608
24
                          4           -3.392528
25
                          5            3.175129
26
                          6           -2.545182
27
Name: sharpe_ratio, Length: 5460, dtype: float64

c,训练集上的最佳参数用于验证集#

大致思路：
01,获取各split_idx的最佳收益(sharp_radio)的参数组合idxmax,也就是fast_window,slow_window,split_idx，三维索引元组
02,按照split_idx进行聚类，取得各split_idx对应的最佳参数。实际含义就是各滑动窗口的最佳参数

1
def get_best_index(performance, higher_better=True):
2
    if higher_better:
3
        return performance[performance.groupby('split_idx').idxmax()].index
4
    return performance[performance.groupby('split_idx').idxmin()].index
5
in_best_index = get_best_index(in_sharpe)
6

7
print(in_best_index[:5])
8

9

10
def get_best_params(best_index, level_name):
11
    return best_index.get_level_values(level_name).to_numpy()
12
in_best_fast_windows = get_best_params(in_best_index, 'fast_window')
13
in_best_slow_windows = get_best_params(in_best_index, 'slow_window')
14
in_best_window_pairs = np.array(list(zip(in_best_fast_windows, in_best_slow_windows)))
15

16
print(in_best_window_pairs[:5][:])
17
pd.DataFrame(in_best_window_pairs, columns=['fast_window', 'slow_window']).vbt.plot().show_svg()

1
MultiIndex([(40, 44, 0),
2
            (12, 13, 1),
3
            (10, 13, 2),
4
            (10, 40, 3),
5
            (12, 37, 4)],
6
           names=['fast_window', 'slow_window', 'split_idx'])
7
[[40 44]
8
 [12 13]
9
 [10 13]
10
 [10 40]
11
 [12 37]]

svg

将滚动获取的最佳参数用于验证集，统计收益信息

1
def simulate_best_params(price, best_fast_windows, best_slow_windows, **kwargs):
2
    fast_ma = vbt.MA.run(price, window=best_fast_windows, per_column=True)
3
    slow_ma = vbt.MA.run(price, window=best_slow_windows, per_column=True)
4
    entries = fast_ma.ma_crossed_above(slow_ma)
5
    exits = fast_ma.ma_crossed_below(slow_ma)
6
    pf = vbt.Portfolio.from_signals(price, entries, exits, **kwargs)
7
    return pf.sharpe_ratio()
8

9
# Use best params from in-sample ranges and simulate them for out-sample ranges
10
out_test_sharpe = simulate_best_params(out_price, in_best_fast_windows, in_best_slow_windows, **pf_kwargs)
11
print(out_test_sharpe.head(5))

1
ma_window  ma_window  split_idx
2
40         44         0           -0.863821
3
12         13         1            0.441460
4
10         13         2           -0.895217
5
           40         3            3.233424
6
12         37         4            2.764636
7
Name: sharpe_ratio, dtype: float64

22,sharp ratio的汇总可视化#

1
cv_results_df = pd.DataFrame({
2
    'in_sample_hold': in_hold_sharpe.values,
3
    'in_sample_median': in_sharpe.groupby('split_idx').median().values,
4
    'in_sample_best': in_sharpe[in_best_index].values,
5
    'out_sample_hold': out_hold_sharpe.values,
6
    'out_sample_median': out_sharpe.groupby('split_idx').median().values,
7
    'out_sample_test': out_test_sharpe.values
8
})
9

10
color_schema = vbt.settings['plotting']['color_schema']
11

12
cv_results_df.vbt.plot(
13
    trace_kwargs=[
14
        dict(line_color=color_schema['blue']),
15
        dict(line_color=color_schema['blue'], line_dash='dash'),
16
        dict(line_color=color_schema['blue'], line_dash='dot'),
17
        dict(line_color=color_schema['orange']),
18
        dict(line_color=color_schema['orange'], line_dash='dash'),
19
        dict(line_color=color_schema['orange'], line_dash='dot')
20
    ]
21
).show_svg()

svg

关注点：

蓝色部分正常排序是(从上到下)：点线，实现，线段，

橘色部分

实线对实线
说明测试集和验证集的周期收益情况，二者同时出现0轴同侧较好（同时上涨，同时下跌，保持行情的稳定性or延续性）

线段对线段
二者一方面随着各自颜色的实线趋势变化（受各自实线影响较大），其他应该无必然联系

点线对点线
蓝色点高于橘色点线，蓝色是训练集内最佳，橘色则是训练集得到最优参数用于验证集结果收益，大概率低于验证集。

测试，验证集时间长度差异，引入偏差
由于测试集一般是验证集的2-3倍（或更多），对于单边行情(假如上涨)，则(测试集的)实线收益。蓝色线大概率位于橘色线上方。
如果下跌，则相反。蓝色由于时间长，大概率位于橘色下方。

注意： 01，202406，对于当前case，y周取值为sharp ratio夏普比，而非收益率。所以数据点高低并不反映收益率。所以，以上结论需要稍斟酌，并不完全准确。

23,滚动回测收益可视化#

svg

可见，整体结果并不很理想，由于参数是滚动的，相比固定参数，期望取得更好收益，实际上并非如此。
大概率是由于技术指标的预热问题，下一篇会修复此问题。

黄金矿工