破解Alpha对冲策略——观《量化分析师Python日记第14天》有感

发布于 2022-02-20 22:26:13 字数 37848 浏览 968 评论 0 收藏 0

写在最前面：

不知不觉逛社区快半年了，通过优矿平台认识了很多大牛，真心获益匪浅，不管是编程方面还是金融方面，在此真心感谢优矿平台，为你们的分享精神点个赞！
再来说说写作目的吧，估计自己还算是个社区活跃用户，之前也分享过一些实用的帖子，然后某一天系统就发通知说感谢我对优矿的支持，内存已经帮我加到1GB，有效期1个月，从此妈妈再也不用担心我跑策略out of memory了，嘿嘿~所以呢，一方面传承优矿分享交流精神，另一方面也希望通过多为社区做贡献获得1GB内存更长时间，来个永久版最好啦！

本篇缘由：

最近市场的起起伏伏真是惊心动被迫，股指期货投机交易也被狠狠的限制了，各种公募私募产品清盘处理。。。
我开始思考，是市场的问题还是投资者的问题，究竟怎样的策略才能成为常胜将军，如果可以选择，我宁可做市场上的寿星而不是明星。
优矿给了我这个启示，感谢社区大牛薛昆Kelvin的帖子量化分析师的Python日志第14天，告诉我该如何去做Alpha对冲策略
如果你读到这里，强烈建议你先去认真读完上述帖子，然后接着往下看。
上述帖子，对Alpha对冲策略从理论原理再到代码实现都进行了详细的讲解，但是对于其中提到的一些新的函数（而且是特别重要的函数讲述的不是特别清楚，只是说了一下大体方向），于是乎，笔者就顺藤摸瓜，探探究竟。本篇就是讲述自己对上述帖子的一些测试和自我体会，当然也秉承分享精神，展示笔者得意的Fama-french三因子策略。。。老舍不得的了，一定要给我加内存啊！！

关于本篇：

本篇首先对帖子中出现的不太清晰的函数进行相关猜测与测试，包括因子信号处理函数:去极值（winsorize）、中性化（neutralize）、标准化（standardize）
随后，对组合构建函数simple_long_only进行猜测
最后，以Fama-French三因子构建策略进行回测展示

首先来看三个因子处理函数，笔者结合各家券商研究报告中提到的类似处理进行大胆猜测，并进行测试

首先是去极值函数winsorize，大量券商研究报告都提到了这个方法，业内常用所谓的“3σ”原则，也就是先根据因子样本计算出标准差，然后将其中大于 u+3σ 的置换为u+3σ，将小于u-3σ 的置换为u-3σ，这样做的好处是可以消除因子极值对因子实际效果造成的不必要影响，下面举例来说明

Tips：读者可以首先在code模式下输入 winsorize? 然后运行便可以得到该函数的说明文档。

import numpy as np
import pandas as pd

universe = set_universe('SH50')  # 以上证50市盈率因子进行说明
data = DataAPI.MktStockFactorsOneDayGet(tradeDate='20150916', secID=universe, field='ticker,PE',pandas='1').set_index('ticker')
data = data['PE'].to_dict()  # winsorize之前数据
new_data = winsorize(data)  # winsorize之后数据
df = pd.DataFrame(data=0, index=map(lambda x: x[:6], universe), columns=['before winsorize','after winsorize'])
df['before winsorize'][data.keys()] = data.values()  # 对比两者数据进行展示
df['after winsorize'][new_data.keys()] = new_data.values()
df.reset_index(inplace=True)

接下来，我们可以看看winsorize前后数据的变化

df

	index	before winsorize	after winsorize
0	600000	5.9624	5.962400
1	600104	7.0826	7.082600
2	600050	33.0181	33.018100
3	600036	7.7177	7.717700
4	600030	8.8612	8.861200
5	600028	14.9741	14.974100
6	600016	7.1609	7.160900
7	600015	6.1384	6.138400
8	600519	16.0515	16.051500
9	601006	10.1080	10.108000
10	601398	5.8342	5.834200
11	600048	6.7609	6.760900
12	601628	17.1175	17.117500
13	601166	5.7557	5.755700
14	601318	10.6240	10.624000
15	601328	7.1577	7.157700
16	601088	11.7254	11.725400
17	601857	24.8742	24.874200
18	601601	13.9766	13.976600
19	601169	6.7160	6.716000
20	600837	10.0223	10.022300
21	601668	7.6202	7.620200
22	601288	5.7281	5.728100
23	601818	6.6163	6.616300
24	600111	77.2052	77.205200
25	601989	167.9813	130.981297
26	601766	65.9834	65.983400
27	600585	10.3818	10.381800
28	600010	-419.8877	-86.645491
29	601901	13.5459	13.545900
30	600256	45.9370	45.937000
31	600887	21.8070	21.807000
32	601688	10.9483	10.948300
33	600999	10.3119	10.311900
34	600518	24.2080	24.208000
35	600406	49.2598	49.259800
36	600018	25.5060	25.506000
37	600637	89.8189	89.818900
38	600089	20.5017	20.501700
39	601998	7.0787	7.078700
40	600109	21.8898	21.889800
41	600150	508.1892	130.981297
42	600690	12.3600	12.360000
43	600583	10.8489	10.848900
44	600893	68.7643	68.764300
45	601988	6.7982	6.798200
46	601390	23.0430	23.043000
47	600958	12.0603	12.060300
48	601186	17.4490	17.449000
49	601800	13.6934	13.693400

可以很明显看到，大部分值都没变，第25、28、41行所在股票的PE值得到了处理，过大或者过小都会被视为极值，会得到调整。笔者也计算了u+3σ，发现调整结果并没有完全按照3σ原则，但是winsorize的作用已经得到了测试检验。

下面绘制一个对比图可以更明显看到winsorize前后数据的变化

df.plot(figsize=(14,7))

<matplotlib.axes.AxesSubplot at 0x42bfa10>

接下来是中性化函数neutralize

neutralize函数不太好做测试，但是根据neutralize的说明文档，可以猜个大概出来。该函数的定义形式是neutralize(raw_data, target_date, risk_module='short', industry_type='SW1')，可以看到函数需要选择风险模型、行业分类，由此不难推测出，输入原始因子数据，由于原始因子数据是所有行业的，这里可能按照行业分类，对因子进行了行业中性处理（大概可以理解为将因子间的行业差异消除了，比如互联网行业和银行之间的PE本来就不在一个level上，neutralize之后可能就消除了这个因素，有点像对季节数据进行季节平滑处理）

再来看看标准化函数standardize

这个函数应该非常好理解，也非常好测试，很多券商的研究报告都有提到过该处理方法，简单来讲就是（因子值 - 因子均值）/ 因子标准差，下面接前面的例子对standardize进行测试

data1 = standardize(data)
df1 = pd.DataFrame(data=0, index=map(lambda x: x[:6], universe), columns=['raw data','standardize function','standardize myself'])
df1['raw data'][data.keys()] = data.values()  # 原始数据
df1['standardize function'][data1.keys()] = data1.values()  # 通过standardize函数计算的值
df1['standardize myself'] = (df1['raw data'] - df1['raw data'].mean()) / df1['raw data'].std() # 自己计算的值
df1

	raw data	standardize function	standardize myself
600000	5.9624	-0.178463	-0.178463
600104	7.0826	-0.167042	-0.167042
600050	33.0181	0.097395	0.097395
600036	7.7177	-0.160566	-0.160566
600030	8.8612	-0.148907	-0.148907
600028	14.9741	-0.086580	-0.086580
600016	7.1609	-0.166243	-0.166243
600015	6.1384	-0.176669	-0.176669
600519	16.0515	-0.075595	-0.075595
601006	10.1080	-0.136195	-0.136195
601398	5.8342	-0.179770	-0.179770
600048	6.7609	-0.170322	-0.170322
601628	17.1175	-0.064726	-0.064726
601166	5.7557	-0.180571	-0.180571
601318	10.6240	-0.130934	-0.130934
601328	7.1577	-0.166276	-0.166276
601088	11.7254	-0.119704	-0.119704
601857	24.8742	0.014361	0.014361
601601	13.9766	-0.096751	-0.096751
601169	6.7160	-0.170779	-0.170779
600837	10.0223	-0.137069	-0.137069
601668	7.6202	-0.161560	-0.161560
601288	5.7281	-0.180852	-0.180852
601818	6.6163	-0.171796	-0.171796
600111	77.2052	0.547924	0.547924
601989	167.9813	1.473472	1.473472
601766	65.9834	0.433507	0.433507
600585	10.3818	-0.133403	-0.133403
600010	-419.8877	-4.520406	-4.520406
601901	13.5459	-0.101142	-0.101142
600256	45.9370	0.229116	0.229116
600887	21.8070	-0.016912	-0.016912
601688	10.9483	-0.127627	-0.127627
600999	10.3119	-0.134116	-0.134116
600518	24.2080	0.007568	0.007568
600406	49.2598	0.262995	0.262995
600018	25.5060	0.020802	0.020802
600637	89.8189	0.676533	0.676533
600089	20.5017	-0.030221	-0.030221
601998	7.0787	-0.167081	-0.167081
600109	21.8898	-0.016068	-0.016068
600150	508.1892	4.942212	4.942212
600690	12.3600	-0.113234	-0.113234
600583	10.8489	-0.128641	-0.128641
600893	68.7643	0.461861	0.461861
601988	6.7982	-0.169941	-0.169941
601390	23.0430	-0.004310	-0.004310
600958	12.0603	-0.116289	-0.116289
601186	17.4490	-0.061346	-0.061346
601800	13.6934	-0.099638	-0.099638

可以看到，猜测完全正确，得到的结果一模一样！！

好了，三个因子处理函数已经猜完了，再来看看大头吧，组合构建函数simple_long_only，同样，结合帮助文档来看。

在《量化分析师日记》中对该函数的说明是：“组合构建综合考虑各因子大小，行业配置等因素，默认返回前30%的股票”。给我的直观理解是，倘若给定100个股票，那么函数就根据股票的因子值以及行业分类选出其中最好的30%只股票，也就是30只股票以及他们各自的建仓权重。至于内部怎么实现的，我也只能猜测，估计选出来的30只股票行业配置要比较均匀，而且要因子值要优于没有被选中的股票，比如我要选低估值的股票，那么就优先选择低PE的，但是又不能直接选PE排名30%以下的那30只股票，因为还要考虑到行业配置均匀的问题，不然选出来的很可能都是同一个行业的（比如银行、钢铁之类的），所以，个人猜测组合构建函数就是在因子值和行业配置均匀之间进行博弈，求得一个最优组合。。。下面，还是写出猜想过程。

factor = standardize(neutralize(winsorize(data),'20150916'))   #  将原始数据进行处理，得到最终因子值
weight = simple_long_only(factor, '20150915')  # 根据因子构建组合，获得权重
df_factor = pd.DataFrame(data=np.nan, index=map(lambda x: x[:6], universe), columns=['factor','weight'])  # 将因子值和最后的持仓权重对比
df_factor['factor'][factor.keys()] = factor.values()
df_factor['weight'][weight.keys()] = weight.values()
df_factor

| | factor | weight | } --- | --- | | 600000 | -3.236122e-01 | NaN | | 600104 | -7.364325e-15 | NaN | | 600050 | 3.671396e-15 | 0.015365 | | 600036 | 7.982552e-01 | 0.084137 | | 600030 | -3.042384e-01 | NaN | | 600028 | -2.572782e-01 | NaN | | 600016 | -1.811580e-01 | NaN | | 600015 | -2.869542e-01 | NaN | | 600519 | 4.488652e-01 | 0.044730 | | 601006 | -3.457882e-02 | NaN | | 601398 | 2.537750e-01 | 0.026748 | | 600048 | 6.228453e-15 | 0.047034 | | 601628 | 5.374184e-01 | NaN | | 601166 | -7.274821e-01 | NaN | | 601318 | 1.013404e+00 | 0.053078 | | 601328 | 4.274117e-01 | 0.045050 | | 601088 | -6.332870e-01 | NaN | | 601857 | -2.000576e-01 | NaN | | 601601 | -1.666304e-01 | NaN | | 601169 | -4.956554e-01 | NaN | | 600837 | 6.762916e-01 | 0.035421 | | 601668 | -9.654556e-01 | NaN | | 601288 | -1.756114e-01 | NaN | | 601818 | -5.174820e-03 | NaN | | 600111 | -4.047149e-14 | NaN | | 601989 | 2.298816e+00 | NaN | | 601766 | -1.463175e-14 | NaN | | 600585 | -2.109168e-14 | NaN | | 600010 | 3.274110e-14 | 0.016346 | | 601901 | 9.923986e-01 | 0.051978 | | 600256 | 2.572782e-01 | 0.025743 | | 600887 | -4.488652e-01 | NaN | | 601688 | 1.289595e-01 | NaN | | 600999 | -1.478773e-01 | NaN | | 600518 | -2.324500e-14 | NaN | | 600406 | 1.344937e+00 | 0.018264 | | 600018 | 3.457882e-02 | 0.043647 | | 600637 | 1.551461e-14 | 0.043608 | | 600089 | -1.344937e+00 | NaN | | 601998 | 1.893061e-01 | NaN | | 600109 | -2.198574e+00 | NaN | | 600150 | 2.320845e+00 | 0.025369 | | 600690 | 2.358953e-14 | 0.027154 | | 600583 | 8.333446e-01 | 0.022058 | | 600893 | -4.619661e+00 | NaN | | 601988 | 5.269000e-01 | 0.055536 | | 601390 | 6.569516e-01 | 0.045871 | | 600958 | -5.311522e-01 | NaN | | 601186 | 3.286287e-02 | NaN | | 601800 | 2.756411e-01 | NaN |

从上面的对比可以看到：

总共50只股票，最后只选取了19只，比较接近30%的比例，证明了之前的猜测由于我们假设的是要买高PE的，所以可以看到，最后选出的19只股票的因子值（PE）相对没有选中的都比较高，而且绝大多数权重都和因子值呈比例出现，至于没有呈现比例的应该是基于行业配置均匀的考虑，所以说之前的猜想还是非常靠谱的，有兴趣的读者可以自行进一步研究。

同样，也给出对比分析图

df_factor.plot(secondary_y='weight',figsize=(14,7))

<matplotlib.axes.AxesSubplot at 0x403e590>

终于写到最后一部分，内心是无比的纠结。。

有了因子处理以及组合构建之后，我们就可以自己找因子来构建组合了，大赛方还专门有获取因子数据的DataAPI，真心赞一个！

那么，我就要开始分享我的策略了。。。优矿工作人员看到的话一定要给我加内存，或者什么VIP账号啊啊啊！！！

策略思路来源就是经典的Fama-French三因子模型，三因子模型告诉我们，股票的收益可以由这三个因子来解释：市场beta、股票市值、股票估值；同时，低估值、低市值的股票能够获得超额收益

那么，估值可以用市盈率来衡量(PE)，市值可以用流通市值来衡量（LFLO），下面就给出策略回测效果

PS：回测区间从2012年8月1日~2015年8月1日，股票池为中证800，每月第一个交易日建仓

# 导入包
from CAL.PyCAL import *
import numpy as np
import pandas as pd

# 构建日期列表，以保证每月第一个交易日建仓
data=DataAPI.TradeCalGet(exchangeCD=u"XSHG",beginDate=u"20120731",field=['calendarDate','isWeekEnd','isMonthEnd'],pandas="1")
data = data[data['isMonthEnd'] == 1]
date_list = map(lambda x: x[0:4]+x[5:7]+x[8:10], data['calendarDate'].values.tolist())

start = '2012-08-01'                       # 回测起始时间
end = '2015-08-01'     # 回测结束时间
universe = set_universe('HS300') + set_universe('ZZ500')   # 股票池
benchmark = 'HS300'                       # 策略参考标准
capital_base = 10000000                     # 起始资金
freq = 'd'                              # 策略类型，'d'表示日间策略使用日线回测，'m'表示日内策略使用分钟线回测
refresh_rate = 1                          # 调仓频率
commission = Commission(buycost=0.0008, sellcost=0.0008)

# 日期处理相关
cal = Calendar('China.SSE')
period = Period('-1B')

def initialize(account):                   # 初始化虚拟账户状态
    pass

def handle_data(account):                  # 每个交易日的买入卖出指令

    today = account.current_date
    today = Date.fromDateTime(account.current_date)  # 向前移动一个工作日
    yesterday = cal.advanceDate(today, period)
    yesterday = yesterday.toDateTime().strftime('%Y%m%d')
    if yesterday in date_list:

        Factor1 = DataAPI.MktStockFactorsOneDayGet(tradeDate=yesterday,secID=account.universe[:400],field=['secID','PE','LFLO'],pandas="1")
        Factor2 = DataAPI.MktStockFactorsOneDayGet(tradeDate=yesterday,secID=account.universe[400:],field=['secID','PE','LFLO'],pandas="1")
        Factor = pd.concat([Factor1, Factor2])
        Factor['ticker'] = Factor['secID'].apply(lambda x: x[0:6])
        Factor.set_index('ticker',inplace=True)

        # 市盈率PE
        Factor['PE'] = 1.0 / Factor['PE']  # 低市盈率
        factor = Factor['PE'].dropna().to_dict()
        signal_PE = standardize(neutralize(winsorize(factor),yesterday))   # 因子处理

        # 对数流通市值LFLO
        Factor['LFLO'] = 1.0 / Factor['LFLO']  # 低市值
        factor = Factor['LFLO'].dropna().to_dict()
        signal_LFLO = standardize(neutralize(winsorize(factor),yesterday))  # 因子处理

        # 构建组合score矩阵
        Total_Score = pd.DataFrame(index=Factor.index, columns=factor_name, data=0)
        Total_Score['PE'][signal_PE.keys()] = signal_PE.values()
        Total_Score['LFLO'][signal_LFLO.keys()] = signal_LFLO.values()
        Total_Score['total_score'] = np.dot(Total_Score, np.array([0.5, 0.5]))  # 综合两个因子的大小，不失一般性，等权求和
        total_score = Total_Score['total_score'].to_dict()

        wts = simple_long_only(total_score,yesterday)  # 组合构建函数
        Factor['wts'] = np.nan
        Factor['wts'][wts.keys()] = wts.values()
        Factor = Factor[~np.isnan(Factor['wts'])]
        Factor.set_index('secID', inplace=True)
        Factor.drop(factor_name, axis=1, inplace=True)

        # 先卖出
        sell_list = account.valid_secpos
        for stk in sell_list:
            order_to(stk, 0)

        # 再买入
        buy_list = Factor.index
        total_money = account.referencePortfolioValue
        prices = account.referencePrice 
        for stk in buy_list:
            if np.isnan(prices[stk]) or prices[stk] == 0:  # 停牌或是还没有上市等原因不能交易
                continue
            order(stk, int(total_money * Factor.loc[stk]['wts'] / prices[stk] /100)*100)
    else:
        return

接下来，用组合累计收益减去基准累计收益就得到alpha收益，如下所示：

((bt['portfolio_value']/bt['portfolio_value'][0] - 1) - ((1 + bt['benchmark_return']).cumprod() - 1)).plot(figsize=(14,7))

<matplotlib.axes.AxesSubplot at 0x25067110>