vectorbt学习_44DMA之四滑窗网格参数优选

本文在上一篇文章(vectorbt学习_17DMA之三滑窗网格参数优选)面临问题
时间切分后，根据切分后的行情数据，重新计算技术指标，会存在一部分行情作为技术指标的预热时间被消耗掉。
比如：训练集，验证集时间(80,40), slow_windows=30，慢均线需要30天才有有效值。
则意味着训练集需要只有50(80-30)天，预测集10(40-30)天，技术指标slow_ma有有效取值。实际训练，验证集为(50,10)，与本意偏差较大。

勘误：此篇文章部分截图可能有误，此文章的后继文章“DMA之六滑窗网格参数优选”修复此问题。请查阅后文。

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,网格参数-指标计算和可视化#

仅可视化第一列

1
price=ohlcv_wbuf['Close']
2
windows = np.arange(10, 50)
3

4
fast_ma, slow_ma = vbt.MA.run_combs(price, windows, r=2, short_names=['fast', 'slow'])
5

6
print(fast_ma.ma.shape)
7
print(slow_ma.ma.shape)
8

9
# Remove time buffer
10
fast_ma = fast_ma[wobuf_mask]
11
slow_ma = slow_ma[wobuf_mask]
12

13
# there should be no nans after removing time buffer
14
assert(~fast_ma.ma.isnull().any().any())
15
assert(~slow_ma.ma.isnull().any().any())
16

17
print(fast_ma.ma.shape)
18
print(slow_ma.ma.shape)
19

20

21
fig = ohlcv['Close'].vbt.plot(trace_kwargs=dict(name='Price'))
22
fig = fast_ma.ma.iloc[:,0].vbt.plot(trace_kwargs=dict(name="Fast MA col %d"%fast_ma.ma.iloc[:,0].name), fig=fig)
23
fig = slow_ma.ma.iloc[:,0].vbt.plot(trace_kwargs=dict(name="Slow MA col %d"%slow_ma.ma.iloc[:,0].name), fig=fig)
24
fig.show_svg()

1
(978, 780)
2
(978, 780)
3
(728, 780)
4
(728, 780)

svg

21,网格参数-信号计算和可视化#

仅可视化第一列

1
dmac_size.shape: (728, 780)
2
dmac_size.iloc[:3,:3]:
3
fast_window                  10
4
slow_window                  11    12    13
5
date
6
2020-01-02 00:00:00+00:00  True  True  True
7
2020-01-03 00:00:00+00:00  True  True  True
8
2020-01-06 00:00:00+00:00  True  True  True

svg

1
Start                                 2020-01-02 00:00:00+00:00
2
End                                   2022-12-30 00:00:00+00:00
3
Period                                                      728
4
Total                                                423.078205
5
Rate [%]                                              58.115138
6
First Index                           2020-01-02 02:00:00+00:00
7
Last Index                  2022-12-27 06:59:04.615384576+00:00
8
Norm Avg Index [-1, 1]                                -0.179136
9
Distance: Min                                               1.0
10
Distance: Max                                         75.946154
11
Distance: Mean                                         1.720602
12
Distance: Std                                          5.889353
13
Total Partitions                                      14.607692
14
Partition Rate [%]                                     3.501842
15
Partition Length: Min                                  3.239744
16
Partition Length: Max                                 85.138462
17
Partition Length: Mean                                36.392118
18
Partition Length: Std                                 27.476308
19
Partition Distance: Min                                4.425641
20
Partition Distance: Max                               75.946154
21
Partition Distance: Mean                              29.174564
22
Partition Distance: Std                               26.152924
23
Name: agg_func_mean, dtype: object

22,行情,信号的滑窗处理#

注意点：
01，训练集和验证集比例3：1，或者2：1，对应：window_len和set_lens为4<1>(或3<1>)，过大了历史包袱沉重，无法及时响应最新行情，过小了则容易参数跳变，形成类似过拟合效果

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

代码中

1
# todo这里是自然日计算的，但后面训练，验证集个数计算都完全正确，哪里应该和预想的不一致
2
合理的。实测bar_days= 60时
3

4
print(in_indexes[0][0])
5
print(in_indexes[1][0])
6
print(in_indexes[0][53:55])
7

8
2019-01-02 00:00:00+00:00
9
2019-03-25 00:00:00+00:00
10
DatetimeIndex(['2019-03-25 00:00:00+00:00', '2019-03-26 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_0', freq=None)
11
可见第二行第一个位于第一行第53个，不足设置的60,就是由于切分优先保证了数据的足量，但是数据间隔方面则可能有所重叠。

1
# 滚动周期参数设置和大致效果可视化
2
start_end_days=int((end_date-start_date).days) #todo 这里是自然日计算的，但后面训练，验证集个数计算都完全正确，哪里应该和预想的不一致
3
bar_days= 80         # 训练，验证集时间长度，以此为单位
4
test_bar_num=2      # 训练集时间长度
5
verify_bar_num=1    # 验证集时间长度
6
verify_overlap=0 # 验证集重叠时间长度
7
pre_test_days=0    # 由于测试集一部分时间用于计算指标，导致实际训练时间不足，这个是一定程度补充的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

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

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

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

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

36
print('in_price.shape:',in_price.shape )  # in-sample
37
print('out_price.shape:',out_price.shape)
38
print('in_price.index:',in_price.index)
39
print('in_price.columns:',in_price.columns)
40
print('in_price[0:3]:',in_price[0:3])
41

42
print('in_indexes[:5]:',in_indexes[:3])

1
split_kwargs: {'n': 11, 'window_len': 240, 'set_lens': (80,), 'left_to_right': False}

svg

1
in_price.shape: (160, 11)
2
out_price.shape: (80, 11)
3
in_price.index: RangeIndex(start=0, stop=160, step=1)
4
in_price.columns: Int64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype='int64', name='split_idx')
5
in_price[0:3]: split_idx     0      1      2      3      4      5       6       7       8       9       10
6
0          49.17  58.15  51.20  43.39  48.15  97.90  167.98  239.52  202.00  251.77  253.14
7
1          48.06  56.16  49.50  43.15  49.73  96.55  164.08  225.00  214.11  252.50  266.49
8
2          50.65  55.36  50.29  43.79  52.25  94.50  168.03  208.99  227.02  246.86  266.08
9
in_indexes[:5]: [DatetimeIndex(['2019-01-02 00:00:00+00:00', '2019-01-03 00:00:00+00:00', '2019-01-04 00:00:00+00:00', '2019-01-07 00:00:00+00:00', '2019-01-08 00:00:00+00:00', '2019-01-09 00:00:00+00:00', '2019-01-10 00:00:00+00:00', '2019-01-11 00:00:00+00:00', '2019-01-14 00:00:00+00:00', '2019-01-15 00:00:00+00:00',
10
               ...
11
               '2019-08-14 00:00:00+00:00', '2019-08-15 00:00:00+00:00', '2019-08-16 00:00:00+00:00', '2019-08-19 00:00:00+00:00', '2019-08-20 00:00:00+00:00', '2019-08-21 00:00:00+00:00', '2019-08-22 00:00:00+00:00', '2019-08-23 00:00:00+00:00', '2019-08-26 00:00:00+00:00', '2019-08-27 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_0', length=160, freq=None), DatetimeIndex(['2019-04-24 00:00:00+00:00', '2019-04-25 00:00:00+00:00', '2019-04-26 00:00:00+00:00', '2019-04-29 00:00:00+00:00', '2019-04-30 00:00:00+00:00', '2019-05-06 00:00:00+00:00', '2019-05-07 00:00:00+00:00', '2019-05-08 00:00:00+00:00', '2019-05-09 00:00:00+00:00', '2019-05-10 00:00:00+00:00',
12
               ...
13
               '2019-12-04 00:00:00+00:00', '2019-12-05 00:00:00+00:00', '2019-12-06 00:00:00+00:00', '2019-12-09 00:00:00+00:00', '2019-12-10 00:00:00+00:00', '2019-12-11 00:00:00+00:00', '2019-12-12 00:00:00+00:00', '2019-12-13 00:00:00+00:00', '2019-12-16 00:00:00+00:00', '2019-12-17 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_1', length=160, freq=None), DatetimeIndex(['2019-08-12 00:00:00+00:00', '2019-08-13 00:00:00+00:00', '2019-08-14 00:00:00+00:00', '2019-08-15 00:00:00+00:00', '2019-08-16 00:00:00+00:00', '2019-08-19 00:00:00+00:00', '2019-08-20 00:00:00+00:00', '2019-08-21 00:00:00+00:00', '2019-08-22 00:00:00+00:00', '2019-08-23 00:00:00+00:00',
14
               ...
15
               '2020-03-26 00:00:00+00:00', '2020-03-27 00:00:00+00:00', '2020-03-30 00:00:00+00:00', '2020-03-31 00:00:00+00:00', '2020-04-01 00:00:00+00:00', '2020-04-02 00:00:00+00:00', '2020-04-03 00:00:00+00:00', '2020-04-07 00:00:00+00:00', '2020-04-08 00:00:00+00:00', '2020-04-09 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_2', length=160, freq=None)]

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

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

3
print('in_price.shape:',in_price.shape )  # in-sample
4
print('out_price.shape:',out_price.shape)
5

6

7
print(in_indexes[0][0])
8
print(in_indexes[1][0])
9
print(in_indexes[0][53:55])
10

11
print("###################")
12

13
(in_dmac_size,in_dmac_size_indexes),(out_dmac_size,out_dmac_size_indexes) = roll_in_and_out_samples(dmac_size, **split_kwargs)
14

15
print('in_dmac_size.shape:',in_dmac_size.shape)
16
print('in_dmac_size.iloc[:5,:5]:')
17
print(in_dmac_size.iloc[:5,:5])

1
in_price.shape: (160, 11)
2
out_price.shape: (80, 11)
3
2019-01-02 00:00:00+00:00
4
2019-04-24 00:00:00+00:00
5
DatetimeIndex(['2019-03-25 00:00:00+00:00', '2019-03-26 00:00:00+00:00'], dtype='datetime64[ns, UTC]', name='split_0', freq=None)
6
###################
7
in_dmac_size.shape: (160, 8580)
8
in_dmac_size.iloc[:5,:5]:
9
split_idx       0
10
fast_window    10
11
slow_window    11    12    13    14    15
12
0            True  True  True  True  True
13
1            True  True  True  True  True
14
2            True  True  True  True  True
15
3            True  True  True  True  True
16
4            True  True  True  True  True

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

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    0.235446
3
1   -1.630616
4
2    0.598889
5
3    2.647397
6
4    4.501923
7
Name: sharpe_ratio, dtype: float64
8
split_idx
9
0   -0.929956
10
1    2.065991
11
2    4.100300
12
3    4.801291
13
4    0.688785
14
Name: sharpe_ratio, dtype: float64

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

1
(8580,)
2
fast_window  slow_window  split_idx
3
10           11           0            0.235446
4
             12           0            0.235446
5
             13           0            0.235446
6
             14           0            0.235446
7
             15           0            0.235446
8
                                         ...
9
46           48           10           1.161184
10
             49           10           1.325572
11
47           48           10           1.088731
12
             49           10           1.129224
13
48           49           10           0.958552
14
Name: sharpe_ratio, Length: 8580, dtype: float64
15
(8580,)
16
fast_window  slow_window  split_idx
17
10           11           0           -0.703309
18
             12           0           -0.703309
19
             13           0           -0.703309
20
             14           0           -0.929956
21
             15           0           -0.929956
22
                                         ...
23
46           48           10          -0.119443
24
             49           10           0.516152
25
47           48           10          -0.119443
26
             49           10          -0.160922
27
48           49           10          -0.160922
28
Name: sharpe_ratio, Length: 8580, 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([(35, 49, 0),
2
            (10, 30, 1),
3
            (10, 15, 2),
4
            (11, 15, 3),
5
            (10, 11, 4)],
6
           names=['fast_window', 'slow_window', 'split_idx'])
7
[[35 49]
8
 [10 30]
9
 [10 15]
10
 [11 15]
11
 [10 11]]

svg

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

1
print('out_dmac_size.shape:',out_dmac_size.shape)
2
print('in_best_index.shape:',in_best_index.shape)
3
print('in_best_index:',in_best_index)
4
print('out_dmac_size.columns:',out_dmac_size.columns)
5
# out_dmac_size[(0,10,12)]
6
print('out_dmac_size.columns.names:',out_dmac_size.columns.names)
7
print('in_best_index.names:',in_best_index.names)
8

9
# 调整 out_dmac_size 的列索引级别顺序，使其与 in_best_index 的级别顺序一致
10
out_dmac_size_reindexed = out_dmac_size.swaplevel('split_idx', 'fast_window', axis=1).swaplevel('slow_window', 'split_idx', axis=1).sort_index(axis=1)
11
# 使用调整后的列索引进行 iloc 操作
12
# out_dmac_size_reindexed.columns
13
result = out_dmac_size_reindexed[in_best_index]
14
# out_dmac_size.iloc[in_best_index]
15

16
print('out_dmac_size_reindexed[in_best_index].shape:',out_dmac_size_reindexed[in_best_index].shape)
17

18
# out_dmac_size_reindexed[in_best_index].astype(np.int)

1
out_dmac_size.shape: (80, 8580)
2
in_best_index.shape: (11,)
3
in_best_index: MultiIndex([(35, 49,  0),
4
            (10, 30,  1),
5
            (10, 15,  2),
6
            (11, 15,  3),
7
            (10, 11,  4),
8
            (42, 43,  5),
9
            (10, 15,  6),
10
            (27, 34,  7),
11
            (10, 11,  8),
12
            (26, 45,  9),
13
            (13, 30, 10)],
14
           names=['fast_window', 'slow_window', 'split_idx'])
15
out_dmac_size.columns: MultiIndex([( 0, 10, 11),
16
            ( 0, 10, 12),
17
            ( 0, 10, 13),
18
            ( 0, 10, 14),
19
            ( 0, 10, 15),
20
            ( 0, 10, 16),
21
            ( 0, 10, 17),
22
            ( 0, 10, 18),
23
            ( 0, 10, 19),
24
            ( 0, 10, 20),
25
            ...
26
            (10, 45, 46),
27
            (10, 45, 47),
28
            (10, 45, 48),
29
            (10, 45, 49),
30
            (10, 46, 47),
31
            (10, 46, 48),
32
            (10, 46, 49),
33
            (10, 47, 48),
34
            (10, 47, 49),
35
            (10, 48, 49)],
36
           names=['split_idx', 'fast_window', 'slow_window'], length=8580)
37
out_dmac_size.columns.names: ['split_idx', 'fast_window', 'slow_window']
38
in_best_index.names: ['fast_window', 'slow_window', 'split_idx']
39
out_dmac_size_reindexed[in_best_index].shape: (80, 11)
40

41

42

43

44

45

46

47
    id  col        size  entry_idx  entry_price  entry_fees  exit_idx  exit_price  exit_fees           pnl    return  direction  status  parent_id
48
0    0    0  199.762836          0    49.934525   24.937656        79       46.85        0.0   -641.111119 -0.064271          0       0          0
49
1    1    1  222.599259          0    44.811750   24.937656        79       58.80        0.0   3088.836429  0.309656          0       0          1
50
2    2    2  182.338041          0    54.706425   24.937656        79       88.73        0.0   6178.854345  0.619430          0       0          2
51
3    3    3  114.462060          0    87.147325   24.937656        79      183.53        0.0  11007.221874  1.103474          0       0          3
52
4    4    4   59.581957          0   167.417500   24.937656        79      176.88        0.0    538.856616  0.054020          0       0          4
53
5    5    5   56.155465          0   177.632975   24.937656        79      250.50        0.0   4066.944030  0.407711          0       0          5
54
6    6    6   39.282222          0   253.933250   24.937656        79      321.74        0.0   2638.662163  0.264526          0       0          6
55
7    7    7   33.080178         35   301.541975   24.937656        79      240.60        0.0  -2040.909064 -0.204601          0       0          7
56
8    8    8   41.989226          0   237.562425   24.937656        79      314.89        0.0   3221.987364  0.323004          0       0          8
57
9    9    9   33.376449          0   298.865300   24.937656        79      274.21        0.0   -847.844011 -0.084996          0       0          9
58
10  10   10   39.143143         44   254.835500   24.937656        79      266.59        0.0    435.170415  0.043626          0       0         10
59
fast_window  slow_window  split_idx
60
35           49           0           -0.929956
61
10           30           1            2.065991
62
             15           2            4.100300
63
11           15           3            4.801291
64
10           11           4            0.688785
65
Name: sharpe_ratio, dtype: float64

24,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夏普比，而非收益率。所以数据点高低并不反映收益率。所以，以上结论需要稍斟酌，并不完全准确。

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

1
# 验证集：原始价格变动
2
out_price_org=out_price.iloc[-1, :]/out_price.iloc[0, :]
3
print('out_price_org shape:',out_price_org.shape)
4
print(out_price_org.head(5))
5

6
# 验证集：持有收益率
7
def simulate_holding(price, **kwargs):
8
    pf = vbt.Portfolio.from_holding(price, **kwargs)
9
    return pf.total_return()
10

11
out_hold_return = simulate_holding(out_price, **pf_kwargs)
12
print("############")
13
print('out_hold_return shape:',out_hold_return.shape)
14
print(out_hold_return.head(5))
15

16

17
print("############")
18
print('out_test_return shape:',out_test_return.shape)
19
print(out_test_return.head(5))
20

21

22
cv_results_df = pd.DataFrame({
23
    'out_price_org':  out_price_org.cumprod(),
24
    'out_hold_return': (out_hold_return.values+1).cumprod(),
25
    'out_test_return': (out_test_return.values+1).cumprod()
26
})
27

28
color_dmac_pfschema = vbt.settings['plotting']['color_schema']
29

30

31
cv_results_df.vbt.plot(
32
    trace_kwargs=[
33
        dict(line_color=color_schema['blue']),
34
        dict(line_color=color_schema['blue'], line_dash='dash'),
35
        dict(line_color=color_schema['blue'], line_dash='dot')
36
    ]
37
).show_svg()

1
out_price_org shape: (11,)
2
split_idx
3
0    0.940574
4
1    1.315436
5
2    1.625985
6
3    2.111239
7
4    1.059162
8
dtype: float64
9
############
10
out_hold_return shape: (11,)
11
split_idx
12
0   -0.064111
13
1    0.308884
14
2    0.617885
15
3    1.100722
16
4    0.053886
17
Name: total_return, dtype: float64
18
############
19
out_test_return shape: (11,)
20
fast_window  slow_window  split_idx
21
35           49           0           -0.064111
22
10           30           1            0.308884
23
             15           2            0.617885
24
11           15           3            1.100722
25
10           11           4            0.053886
26
Name: total_return, dtype: float64

svg

可见，整体结果尚可，上涨幅度基本吃到位，由于单纯依赖技术指标退出，没有止损。所以回撤也是无法避免的。

进一步思考 (非滚动模式)网格参数寻优得到的固定参数，其实是使用未来信息的(未来行情)，不符合实际，也就是实际上无法落地。（5月份时，无法知道未来5-10月份，某个参数会取得较好收益）
滚动的网格参数寻优更符合实际，不含未来信息（可落地）。
时间周期越长，基于(非滚动模式)网格参数寻优取得较高收益概率越大，本质上是对历史的拟合。
但是滚动的测试未必，由于其未使用未来信息，如果策略本身无效，则大概率围绕0波动，类似随机。

26,计算正确性验证(略)#

1
a,准备校验数据，数据展示
2
b,行情->指标 计算正确
3
0
4
23
5
26
6
22
7
24
8
28
9
c,指标->信号 计算正确
10
d,信号->交易 计算正确

黄金矿工