说明
No Measurement , No Improvement
这套并不是标准量化交易指标，一方面我对那套指标的确也不是很熟，另外我觉得可能自己琢磨一套会更实用一些。主要考虑以下几方面：
- 1 交易的数量
- 2 盈利特性：单均盈利率
- 3 交易持续周期
- 4 最大持有的股票数
- 5 输赢：赢率和真实赢率
- 6 盈亏比
- 7 最大回撤
总体上说：
- 我希望算法产生的交易够多，但不要太多，这样可以具有统计性，又不至于偏向高频；
- 交易持续周期会影响到资金的占用、利用率等；
- 最大持有的股票数一方面可以使整个组合表现出更好的稳定性，当然也会影响到资金占用；
- 从信号的产生机制上，一定会混杂很多白噪声，所以要分为赢率和真实赢率；
- 盈亏比则是考验算法的生存性；
- 最大回撤则是投资风险的度量。回撤在所难免，关键要看能不能接受，值不值得；
内容
通过信号机制产生候选交易，通过模型来识别优质的交易，通过策略来进行修正
假设有一种信号机制（买入和卖出），可以为股票生成若干候选交易，我们希望对这些候选交易进行评估：
- 1 可以根据信号筛选交易
- 2 可以根据股票进行筛选
- 3 可以根据交易期间进行筛选
1 候选交易
根据买入和卖出信号集，我们可以获得足够的候选交易hs300_df
2 根据信号集进行筛选
信号集有一个选择字段是signal_tuple（我隐藏了），第一步将关注的候选集根据信号拆分出来。其他可选的是股票列表和时间。
tem_df1 = process_filter_signal_df(hs300_df)
3 根据筛选后的信号集计算基本指标
随意选定一只股票，看起来还不错，一共466个候选订单，真实赢率29%，单均盈利率是7%，盈亏比为3.4。
some_code = '600010'
tem_df2 = tem_df1[tem_df1['code'] == some_code]
process_kpi001_base(tem_df2)
{'total_orders': 466,
'win_rate': 0.4291845493562232,
'real_win_rate': 0.2918454935622318,
'win_v_loss': 3.4094531520791054,
'hold_stocks': 1,
'mean_margin': 0.07076018194400928}
Note: 候选订单并不是模拟交易的订单，可能会更多一些。候选订单的目的是尽量多的生成可能的交易，供模型学习。
4 期间表现
为了更直观的看到订单的实时表现，我们需要构造交易活动期间的所有数据：根据信号对的起始时间，通过merge全量分钟数据构造交易的活动（明细）数据
通过活动数据，我们可以观察：
- 1 每个订单的最大、最小涨跌以及最大回撤
- 2 若干个订单总的资金敞口和回撤
我们要计算两类数据：
- 1 交易在打开和平仓之间的明细数据，用来看资金敞口。
- 2 结合明细数据，在每笔订单的平仓点更新资本的数值，从而计算回撤
从单个的例子可以看到：
- 1 最大回撤比较高。主要原因是冲顶后，没有及时控制（虽然还是赚的）。
- 2 资金敞口很高。因为没有控制候选交易的数量，可以给每支股票一个cap。
- 3 赢单的亏损一般不会超过10%。这样可以设置止损。
- 4 输单的回撤事实上没有赢单大。因此回撤控制是用来确保更大的利益。
res_600010_dict ,detail_600010_dict= process_kpi002_performance_of_a_code(tem_df1,'600010')
res_600010_dict
{'max_drawback': -0.3254396180829447,
'max_exposure': 112383526.72755373,
'median_hold_days': 27.0,
'median_order_drawback': -0.13348810214741724,
'median_margin': -0.00986446020488569,
'real_win_min_interest': count mean std min 25% 50% 75% \
real_win
0 330.0 -0.060642 0.044292 -0.179422 -0.088277 -0.054769 -0.020774
1 136.0 -0.033090 0.014999 -0.084479 -0.044288 -0.036120 -0.027810
max
real_win
0 -0.002000
1 0.006458 ,
'real_win_max_draw_back': count mean std min 25% 50% 75% \
real_win
0 330.0 -0.095822 0.058116 -0.195652 -0.133609 -0.094828 -0.037787
1 136.0 -0.288716 0.054608 -0.313901 -0.313901 -0.313901 -0.313901
max
real_win
0 0.000000
1 -0.171184 ,
'real_lose_max_interest': count mean std min 25% 50% 75% \
real_lose
0 434.0 0.286946 0.374751 -0.008085 0.009760 0.079744 0.870202
1 32.0 0.031577 0.027086 -0.002000 0.005677 0.029256 0.059415
max
real_lose
0 0.952228
1 0.084441 ,
'real_lose_draw_back': count mean std min 25% 50% 75% \
real_lose
0 434.0 -0.150239 0.108157 -0.313901 -0.313901 -0.130222 -0.057851
1 32.0 -0.177587 0.017701 -0.195652 -0.195652 -0.177778 -0.166667
max
real_lose
0 0.000000
1 -0.132231 }
将多只股票的结果混合
code_detail_dict_list = [detail_600010_dict,detail_600031_dict,detail_300677_dict]
res_dict1 = process_kpi003_merge_codes(code_detail_dict_list)
{'median_hold_days': 13.0,
'median_order_drawback': -0.10698824984539267,
'median_margin': -0.00986446020488569,
'real_win_min_interest': count mean std min 25% 50% 75% \
real_win
0 583.0 -0.053453 0.044081 -0.200425 -0.076391 -0.043757 -0.017635
1 173.0 -0.035720 0.023631 -0.148880 -0.044288 -0.036120 -0.025843
max
real_win
0 -0.000747
1 0.006458 ,
'real_win_max_draw_back': count mean std min 25% 50% 75% \
real_win
0 583.0 -0.084104 0.058984 -0.375151 -0.130222 -0.075816 -0.030368
1 173.0 -0.267715 0.072453 -0.359838 -0.313901 -0.313901 -0.171184
max
real_win
0 0.000000
1 -0.074689 ,
'real_lose_max_interest': count mean std min 25% 50% 75% \
real_lose
0 705.0 0.259113 0.625734 -0.008085 0.007892 0.043737 0.201414
1 51.0 0.038536 0.053529 -0.002000 0.005958 0.015402 0.059415
max
real_lose
0 6.809396
1 0.318473 ,
'real_lose_draw_back': count mean std min 25% 50% 75% \
real_lose
0 705.0 -0.122146 0.100985 -0.359838 -0.171184 -0.094828 -0.040484
1 51.0 -0.181062 0.040239 -0.375151 -0.195652 -0.177778 -0.164822
max
real_lose
0 0.00000
1 -0.10279 ,
'max_exposure': 121383774.86651154,
'max_drawback': -0.25227245169791146}
附录：函数
过滤信号集
def process_filter_signal_df(raw_singal_df, signal_pair = 'xxxx' ,code_group = None , dt_var = 'buy_dt' ,dt_start = '2017-01-01 09:30:00',dt_end = '2022-01-01 09:30:00',
target_var = 'target_gt0.1'):
tem_df = raw_singal_df
singal_sel = tem_df['signal_tuple'] == signal_pair
if code_group is None:
code_sel = tem_df['code'] != ''
else:
code_sel = tem_df['code'].apply(lambda x: True if x in code_group else False)
dt_sel = tem_df[dt_var].apply(lambda x: True if x >= dt_start and x < dt_end else False )
the_sel = singal_sel & code_sel & dt_sel
tem_df1 = tem_df[the_sel]
return tem_df1
序列的回撤计算
import numpy as np
# 最小值比去第一个值的差,回撤
def single_draw_back(dim1_array):
nume = dim1_array.min()
denom =dim1_array[0]
return (nume -denom) / denom
# 计算一个序列的回撤
def cal_draw_back1(dim1_list , init_cap= None):
cap_list = list(dim1_list)
min_cap = min(cap_list) -1
max_cap = max(cap_list) +1
first_cap = cap_list[0]
before = init_cap or first_cap
after = max_cap
# 有一个会被diff拿掉
cap_list.insert(0,before )
cap_list.insert(0,before -1 )
cap_list.append(after)
cap_s = pd.Series(cap_list)
cap_s1 =cap_s.diff().dropna().apply(lambda x: 1 if x >0 else 0 )
# 如果序列不含初始资本，那么就要插入；否则插入初值即可
peak_list = np.argwhere((np.array(cap_s1.iloc[:-1] ==1 )) & (np.array(cap_s1.iloc[1:] ==0 )))
cap_list2 = cap_list[1:-1]
peak_pos_array = peak_list.ravel()
cap_array = np.array(cap_list2)
res_list = [0]
peak_pos_array_len = len(peak_pos_array)
if peak_pos_array_len:
for i in range(peak_pos_array_len):
tem_res = single_draw_back(cap_array[peak_pos_array[i]:])
res_list.append(tem_res)
return min(res_list)
计算基本KPI
def process_kpi001_base(tem_df1, target_var = 'target_gt0.1'):
res_dict = {}
# 1 总笔数
res_dict['total_orders'] = len(tem_df1)
# 2 赢率
res_dict['win_rate'] = tem_df1['is_win'].mean()
# 3 真实赢率
res_dict['real_win_rate'] = tem_df1[target_var].mean()
# 4 盈亏比
win_amount = tem_df1['net_profit'][tem_df1['is_win'] ==1].sum()
loss_amount = abs(tem_df1['net_profit'][tem_df1['is_win'] ==0].sum())
res_dict['win_v_loss'] = win_amount/loss_amount
# 5 最大持有的股票数
res_dict['hold_stocks'] = len(set(tem_df1['code']))
# 6 盈利率
res_dict['mean_margin'] = tem_df1['margin'].mean()
return res_dict
计算期间表现KPI
# some_code = '600010'
# tem_df2 = tem_df1[tem_df1['code'] == some_code]
def process_kpi002_performance_of_a_code(tem_df1,some_code, minute_df_name = 'S12_ddx_df',minute_df_path1 = './hs300_data_v3/%s/',init_cap = None,
real_win_thres = 0.1,real_lose_thres = -0.1):
res_dict = {}
detail_dict = {}
# 匹配一只股票的分钟数据，返回分钟明细
tem_df2 = tem_df1[tem_df1['code'] == some_code]
# 获取一只股票的分钟数据
minute_df = fs.from_pickle(minute_df_name, minute_df_path1 % some_code)
minute_df['dt'] = minute_df['date'] + ' ' + minute_df['minutes']
minute_df_keep_cols = ['dt','LOW']
minute_df1 = minute_df[minute_df_keep_cols]
# 先将每个订单按照买卖时间填充
all_dt_minutes = sorted(list(set(minute_df1['dt'])))
order_res_df_list = []
order_performance_rec_list= []
order_close_df_list = []
# 按订单逐个计算
for i in range(len(tem_df2)):
buy_keep_cols = ['order_num','code','buy_dt','buy_price','buy_vol','buy_amt','sell_dt','margin']
some_order_dict = dict(tem_df2[buy_keep_cols].iloc[i])
pos_a = all_dt_minutes.index(some_order_dict['buy_dt'])
pos_b = all_dt_minutes.index(some_order_dict['sell_dt'])
some_order_df = pd.DataFrame()
# 1 获取持续的时间列表
some_order_df['dt'] = all_dt_minutes[pos_a : pos_b + 1]
# 2 买入时信息
some_order_df['order_num'] = some_order_dict['order_num']
some_order_df['code'] = some_order_dict['code']
some_order_df['buy_price'] = some_order_dict['buy_price']
some_order_df['buy_vol'] = some_order_dict['buy_vol']
some_order_df['buy_amt'] = some_order_dict['buy_amt']
# 3 （假设）卖出时
some_order_df1 = pd.merge(some_order_df, minute_df1, how='left', on='dt')
some_order_df1['sell_amt'] = some_order_df1['LOW'] * some_order_df1['buy_vol']
# 4 订单统计
some_order_df1['fee'] = some_order_df1['sell_amt']* 0.002
some_order_df1['gross_profit'] = some_order_df1['sell_amt'] - some_order_df1['buy_amt']
some_order_df1['net_profit'] = some_order_df1['gross_profit'] - some_order_df1['fee']
some_order_df1['is_win'] = some_order_df1['net_profit'].apply(lambda x: 1 if x >0 else 0)
some_order_df1['margin'] = some_order_df1['net_profit']/ some_order_df1['buy_amt']
some_order_df1['capital'] = some_order_df1['buy_amt'] + some_order_df1['net_profit']
# 5 订单重要指标统计
order_performance_dict = {}
order_performance_dict['order_id'] = some_order_dict['code'] + '_' +some_order_dict['order_num']
order_performance_dict['max_interest'] = some_order_df1['margin'].max()
order_performance_dict['min_interest'] = some_order_df1['margin'].min()
order_performance_dict['max_draw_back'] = cal_draw_back1(some_order_df1['capital'] )
order_performance_dict['hold_minutes'] = len(some_order_df1)
order_performance_dict['hold_days'] = int(len(some_order_df1) /240) + 1
order_performance_dict['close_margin'] = some_order_dict['margin']
order_performance_rec_list.append(order_performance_dict)
res_keep_cols = ['dt','order_num','code', 'buy_amt', 'net_profit']
order_res_df_list.append(some_order_df1[res_keep_cols])
order_close_df_list.append(some_order_df1[res_keep_cols].iloc[-1:])
# 合并计算结果
order_performance_df = pd.DataFrame(order_performance_rec_list)
order_res_df = pd.concat(order_res_df_list, ignore_index=True)
# 明细数据汇总（多笔订单数据）
order_res_df1= order_res_df.groupby(['dt']).sum()
# 平仓数据
order_close_df = pd.concat(order_close_df_list, ignore_index=True)
order_close_s = order_close_df.groupby(['dt'])['net_profit'].sum()
init_cap = init_cap or order_res_df1['buy_amt'].max()
new_cap_df_list = []
clost_dt_list = sorted(list(order_close_s.index))
for i in range(len(clost_dt_list)):
if i ==0:
sub_df = order_res_df1[order_res_df1.index <= clost_dt_list[i]]
else:
sub_df = order_res_df1[(order_res_df1.index <= clost_dt_list[i]) & ((order_res_df1.index > clost_dt_list[i-1]) )]
sub_df['updated_capital'] = sub_df['net_profit'] + init_cap
new_cap_df_list.append(sub_df)
init_cap += order_close_s[i]
new_cap_df = pd.concat(new_cap_df_list)
order_performance_df['real_win'] = order_performance_df['close_margin'].apply(lambda x: 1 if x >= real_win_thres else 0 )
order_performance_df['real_lose'] = order_performance_df['close_margin'].apply(lambda x: 1 if x < real_lose_thres else 0 )
# 汇总数据 -- 直接输出
res_dict['max_drawback'] = cal_draw_back1(new_cap_df['updated_capital'])
res_dict['max_exposure'] = order_res_df1['buy_amt'].max()
res_dict['median_hold_days'] = order_performance_df['hold_days'].median()
res_dict['median_order_drawback'] = order_performance_df['max_draw_back'].median()
res_dict['median_margin'] = order_performance_df['close_margin'].median()
# 赢的单子不会输很多
res_dict['real_win_min_interest'] = order_performance_df.groupby(['real_win'])['min_interest'].describe()
# 赢的单子回撤比较大
res_dict['real_win_max_draw_back'] = order_performance_df.groupby(['real_win'])['max_draw_back'].describe()
# 输的单子波动小，甚至有机会赚
res_dict['real_lose_max_interest'] = order_performance_df.groupby(['real_lose'])['max_interest'].describe()
# 输的单子甚至不如不输的单子回撤大
res_dict['real_lose_draw_back'] = order_performance_df.groupby(['real_lose'])['max_draw_back'].describe()
# 明细数据 -- 用于进一步合并
# 观察交易的盈亏特点
detail_dict['order_performance_df'] = order_performance_df
# 交易的分钟明细数据
detail_dict['order_res_df1'] = order_res_df1
# 交易的资产变动数据
detail_dict['new_cap_df'] = new_cap_df
return res_dict,detail_dict
混合多只票的KPI
def process_kpi003_merge_codes(code_detail_dict_list):
perfomance_df_list = []
order_res_df_list = []
capital_df_list = []
res_dict = {}
for the_dict in code_detail_dict_list:
tem_performance = the_dict['order_performance_df']
perfomance_df_list.append(tem_performance)
tem_order_df = the_dict['order_res_df1']
order_res_df_list.append(tem_order_df)
tem_cap_df = the_dict['new_cap_df'].reset_index()
capital_df_list.append(tem_cap_df)
concat_performance_df = pd.concat(perfomance_df_list, ignore_index=True)
concat_order_res_df = pd.concat(order_res_df_list).reset_index()
concat_order_res_df1 = concat_order_res_df.groupby(['dt']).sum()
merge_capital_df = pd.DataFrame()
tem_set = set([])
for tem_cap_df in capital_df_list:
tem_set = tem_set | set(tem_cap_df['dt'])
merge_capital_df['dt'] = sorted(list(tem_set))
capital_df_list1 = []
for tem_cap_df in capital_df_list:
tem_cap_df1 = pd.merge(merge_capital_df,tem_cap_df,how='left').fillna(method='pad')
capital_df_list1.append(tem_cap_df1)
concat_capital_df = pd.concat(capital_df_list1,ignore_index=True)
concat_capital_df1 = concat_capital_df.groupby(['dt'])['updated_capital'].sum().reset_index()
res_dict['median_hold_days'] = concat_performance_df['hold_days'].median()
res_dict['median_order_drawback'] = concat_performance_df['max_draw_back'].median()
res_dict['median_margin'] = concat_performance_df['close_margin'].median()
# 赢的单子不会输很多
res_dict['real_win_min_interest'] = concat_performance_df.groupby(['real_win'])['min_interest'].describe()
# 赢的单子回撤比较大
res_dict['real_win_max_draw_back'] = concat_performance_df.groupby(['real_win'])['max_draw_back'].describe()
# 输的单子波动小，甚至有机会赚
res_dict['real_lose_max_interest'] = concat_performance_df.groupby(['real_lose'])['max_interest'].describe()
# 输的单子甚至不如不输的单子回撤大
res_dict['real_lose_draw_back'] = concat_performance_df.groupby(['real_lose'])['max_draw_back'].describe()
res_dict['max_exposure'] = concat_order_res_df1['buy_amt'].max()
res_dict['max_drawback'] = cal_draw_back1(concat_capital_df1['updated_capital'])
return res_dict