自己动手写一个印钞机 第五章

摘要: 非均衡胜负收益带来的必然非均衡胜负比例，目标由因子的能力解决一部分，模识别提升关键的一部分

作者：阿布🐶

未经本人允许禁止转载

ipython notebook git版本

目录章节地址：
自己动手写一个印钞机 第一章
自己动手写一个印钞机 第二章
自己动手写一个印钞机 第三章
自己动手写一个印钞机 第四章
自己动手写一个印钞机 第五章
自己动手写一个印钞机 第六章
自己动手写一个印钞机 第七章

简书目录章节地址：
自己动手写一个印钞机 第一章
自己动手写一个印钞机 第二章
自己动手写一个印钞机 第三章
自己动手写一个印钞机 第四章
自己动手写一个印钞机 第五章
自己动手写一个印钞机 第六章
自己动手写一个印钞机 第七章
自己动手写一个印钞机 附录章

股票量化专题地址，请关注，谢谢！

非均衡胜负收益带来的必然非均衡胜负比例，目标由因子的能力解决一部分，模识别提升关键的一部分

上一章使用gmm-hmm统计分析分类，进行模式识别，大体思路已经说明，这一章开始，具体完善这个方法，提高胜率这一章将引入裁判机制，主裁与辅助裁判

依然是从加载数据开始

fn = ZEnv.g_project_root + '/data/cache/golden_n6_test_abu'
key = 'golden_n6_test_abu'
orders_pd_test = ZCommonUtil.load_hdf5(fn, key)
orders_pd_test.shape
# out
(4837, 31)

fn =  ZEnv.g_project_root + '/data/cache/golden_n6_train_abu'
key = 'golden_n6_train_abu'
orders_pd_train = ZCommonUtil.load_hdf5(fn, key)
orders_pd_train.shape
# out
(42538, 31)

和之前不一样的地方，使用全量测试集数据，没有分割测试集与训练集的数据为的是之后构建主裁将使用这份全量的数据作为训练集，不再切割的目的是担心gmm－hmm只是识别了这段时间内的特征，对同一时段内的不同stock交易可以生效，但是实盘就不管用了，这样的话，我们不切割数据，训练完整个模型之后再向前回溯一整年的数据作为测试数
7fe0
据集

fn = ZEnv.g_project_root + '/data/cache/orders_pd_ump_hit_predict_abu'
key = 'orders_pd_ump_hit_predict_abu'
orders_pd_ump = ZCommonUtil.load_hdf5(fn, key)
orders_pd_ump.shape
# out
(47374, 39)

上一章只用到了UmpMainClass 也就是主裁，本周引入辅助裁判概念，这里的实例就是跳空裁判对这里的跳空实现感兴趣的请参考文章的第一章关于跳空的示例，也可查看源代码TLineJump.py

jump ump 辅助裁决

# 只针对有21天内有跳空行为的交易，一下子就只剩下5035了，只简单跳空强度和跳空间隔天数两个特征组成
ump_jump = UmpJumpClass(orders_pd_ump, MlFiterJumpPdClass, dd_threshold=21)
ZLog.info(ump_jump.fiter.df.shape)
ump_jump.fiter.df.head()
# out
(5035, 3)

# 这个你应该熟悉了，看看这些数据的交易大体情况，第一个不过滤数据，即所有传进去的4w多条交易
ump_jump.show_general()
# 过滤数据，只统计符合条件的数据，即那5千多条的情况
ump_jump.show_general(use_fiter=True)

all fit order = (44906, 39)
win rate = 0.500757137131
profit_cg.sum() = 272.117613217
win mean = 0.0743788075658 loss_mean = -0.0626291433739

all fit order = (5035, 39)
win rate = 0.498907646475
profit_cg.sum() = 20.2331512267
win mean = 0.0673137719871 loss_mean = -0.0591414557032

从上面可以发现跳空监控区，收益小于整个区间

死心不改的仍然使用svm对模型想要抽取特征，结果🙈

ump_jump.fiter().estimator.svc()
ump_jump.fiter().train_test_split_xy()
# out
(5035, 2)
(4531, 2)
(504, 2)
accuracy = 0.56
precision_score = 0.57
recall_score = 0.54
precision    recall  f1-score   support

0.0       0.55      0.59      0.57       247
1.0       0.57      0.54      0.56       257

avg / total       0.56      0.56      0.56       504

Confusion Matrix  [[145 102]
[119 138]]
Predicted
|  0  |  1  |
|-----|-----|
0 | 145 | 102 |
Actual   |-----|-----|
1 | 119 | 138 |
|-----|-----|

下面继续使用gmm-hmm方式进行特征抽取, 由于数据不多，从18个分类到42个分类，阀值还是选择65%

ump_jump.gmm_component_filter(p_ncs=np.arange(18, 42), threshold=0.65)

如下所示找个数量和失败率都很高的分类看看发现特征了吗？跳空缺口的能量大概在－1.6左右，跳空时间间隔大约是9-11这个类别里因子触发的70%交易都以失败告终，所以呢？拦截呗！（拦截这个词对我有种特殊的情怀，那段美好的青春岁月好怀念👻）

ump_jump.nts['21_18']

由于简书只能截图显示表格，完整请参阅git上ipython notebook版本



下面统计一下跳空能量的分布情况，进一步总结特征

import scipy.stats as scs
import MlFiterBinsCs
ZLog.info(scs.normaltest(ump_jump.fiter.df.jump_power))
MlFiterBinsCs.show_orders_hist(ump_jump.fiter.df, s_list = ['jump_power'])
# out
NormaltestResult(statistic=11612.386867948926, pvalue=0.0)

jump_power show hist and qcuts
(-1.0692, -1.000217]    504
(-1.243, -1.149]        504
(-1.669, -1.499]        504
(-2.304, -1.932]        504
[-123.0916, -3.0491]    504
(-1.149, -1.0692]       503
(-1.366, -1.243]        503
(-1.499, -1.366]        503
(-1.932, -1.669]        503
(-3.0491, -2.304]       503
Name: jump_power, dtype: int64

如下jump power选取llps没有执行最优化求解，因为数据量太少，按照分类数目要求大于20, 其它0， 0， 0.65来跑跑看看先

llps = ump_jump.cprs[(ump_jump.cprs['lps'] <= 0) & (ump_jump.cprs['lms'] <= 0 )
& (ump_jump.cprs['lrs'] >=0.65) & (  (ump_jump.cprs['lcs'] >= 20)
| (ump_jump.cprs['lrs'] == 1) )]
llps

预测应用这个后的效果能体高0.013

ump_jump.choose_cprs_component(llps)
# out
nts_pd.shape = (182, 6)
nts_pd loss rate = 0.681318681319
improved rate = 0.0131082423039
predict win rate = 0.512015888779

本地序列化

ump_jump.dump_clf(llps)

好了，准备进入正题，做好准备，前方高能

只有一个主裁是不够的，我们需要构造多个主裁，多个辅助裁判，还有边裁（边裁下一章介绍）

deg ump 主裁，只使用全局最优llps

from MlFiterDegPd import MlFiterDegPdClass
ump_deg = UmpMainClass(orders_pd_ump, MlFiterDegPdClass)
ump_deg.fiter.df.head(2)

ump_deg.gmm_component_filter(p_ncs=np.arange(18, 85), threshold=0.68)

# 只使用全局凸优化寻找最优
brust_min = ump_deg.brust_min()
llps = ump_deg.cprs[(ump_deg.cprs['lps'] <= brust_min[0]) & (ump_deg.cprs['lms'] <= brust_min[1] ) &
(ump_deg.cprs['lrs'] >= brust_min[2])]
ump_deg.choose_cprs_component(llps)
ump_deg.dump_clf(llps)
＃ out
nts_pd.shape = (513, 7)
nts_pd loss rate = 0.690058479532
improved rate = 0.00434240413308
predict win rate = 0.505099541264

wave ump第二主裁

ump_wave = UmpMainClass(orders_pd_ump, MlFiterWavePdClass)
ump_wave.fiter.df.head(2)

ump_wave.gmm_component_filter(p_ncs=np.arange(18, 85), threshold=0.63)

brust_min = ump_wave.brust_min()
llps = ump_wave.cprs[(ump_wave.cprs['lps'] <= brust_min[0]) & (ump_wave.cprs['lms'] <= brust_min[1] ) &
(ump_wave.cprs['lrs'] >= brust_min[2])]
ump_wave.choose_cprs_component(llps)
ump_wave.dump_clf(llps)
# out
nts_pd.shape = (1126, 7)
nts_pd loss rate = 0.639431616341
improved rate = 0.00699238409121
predict win rate = 0.507749521222

第三主裁 ump_main

# 构造方式换汤不换药，可以继续封装优化
from MlFiterMainPd import MlFiterMainPdClass
ump_main = UmpMainClass(orders_pd_ump, MlFiterMainPdClass)
ump_main.fiter.df.head(2)

ump_main.gmm_component_filter(p_ncs=np.arange(18, 80), threshold=0.65)

brust_min = ump_main.brust_min()
llps = ump_main.cprs[(ump_main.cprs['lps'] <= brust_min[0]) & (ump_main.cprs['lms'] <= brust_min[1] ) &
(ump_main.cprs['lrs'] >= brust_min[2])]
ump_main.choose_cprs_component(llps)
ump_main.dump_clf(llps)
＃ out
nts_pd.shape = (804, 7)
nts_pd loss rate = 0.661691542289
improved rate = 0.00578987217744
predict win rate = 0.506547009308

至此，所有主裁构建完成，下一章开始构造边裁，所有裁判都到位后，咱们的球赛就会开场！

下一章地址
自己动手写一个印钞机 第六章

感谢🙏您能有耐心看到这里

如果有什么问题可以加阿布的微信

微信号：aaaabbbuu