多因子组合

Step1_获取数据

from fxdayu_data import DataAPI
from datetime import datetime
import alphalens
import pandas as pd
start = datetime(2017,1,1)
end = datetime(2017,11,11)
period = 5
codes = DataAPI.info.codes('hs300')
factors = ('PB','LCAP','HBETA', 'ROE', 'InvestCashGrowRate', 'ROC20')
PN = DataAPI.factor(codes, factors, start=start, end=end)
prices = DataAPI.candle(codes, 'D', 'close', start=start, end=end).minor_xs('close')
print(PN)

<class 'pandas.core.panel.Panel'>
Dimensions: 300 (items) x 207 (major_axis) x 6 (minor_axis)
Items axis: 000001.XSHE to 603993.XSHG
Major_axis axis: 2017-01-03 15:00:00 to 2017-11-10 15:00:00
Minor_axis axis: HBETA to ROE

Step2_数据预处理

横截面标准化/去极值/加干扰

from fxdayu_alphaman.factor.factor import Factor
from fxdayu_alphaman.factor.admin import Admin
origin_factors = {name: item for name, item in PN.transpose(2,1,0).iteritems()}
# 实例化
f = Factor()
#横截面标准化/去极值
PN_handle = pd.Panel({name: f.standardize(f.winsorize(frame)) for name, frame in origin_factors.items()})
# 加干扰
PN_disturbed = pd.Panel({name: f.get_disturbed_factor(frame) for name, frame in PN_handle.iteritems()})

Step3_权重优化生成新因子

1_获取IC的DataFrame

2_获取IC权重的DataFrame

3_计算最优权重组合的新因子值的MultiIndex

f_admin = Admin()
# 获取IC的DataFrame
ic_df = f_admin.get_factors_ic_df(
    {name: item.stack() for name, item in PN_disturbed.iteritems()},
    pool=codes, start=start, end=end, price=prices, quantiles=5, periods=(5,))
# 获取IC权重的DataFrame
ic_weight_df = f_admin.get_ic_weight_df(ic_df[period], period, rollback_period=10)
# 计算最优权重组合的新因子值的MultiIndex
new_factor = f_admin.ic_cov_weighted_factor({name: item.stack() for name, item in PN_disturbed.iteritems()}, ic_weight_df=ic_weight_df)

factor = new_factor.multifactor_value
print(factor.tail())

                                   factor
date                asset                
2017-11-10 15:00:00 601997.XSHG -0.338474
                    601998.XSHG  0.630329
                    603160.XSHG  2.109389
                    603858.XSHG  0.168304
                    603993.XSHG  1.060125

Step4_用Alphalens观察绩效

1_获取factor_data

2_计算mean_return_by_q, std_err_by_q

3_展示Quantile与IC图表

4_计算多空累积收益

factor_data = alphalens.utils.get_clean_factor_and_forward_returns(factor, prices, quantiles=5)
mean_return_by_q, std_err_by_q = alphalens.performance.mean_return_by_quantile(factor_data, by_date=True)

import matplotlib.pyplot as plt
alphalens.plotting.plot_cumulative_returns_by_quantile(mean_return_by_q, period)
plt.show()

ic = alphalens.performance.factor_information_coefficient(factor_data)
alphalens.plotting.plot_ic_hist(ic)
mean_monthly_ic = alphalens.performance.mean_information_coefficient(factor_data, by_time='M')
alphalens.plotting.plot_monthly_ic_heatmap(mean_monthly_ic)
plt.show()

# 多空累积收益
factor_returns = alphalens.performance.factor_returns(factor_data)
alphalens.plotting.plot_cumulative_returns(factor_returns[10])
plt.show()

IC滚动选因子再选股

big_factor = ['LCAP','ROE']

import numpy as np
def cal_big(ic_df):
    # 设置IC阈值为0.03
    big_ic = ic_df[big_factor]
    big_ic[big_ic<0.03]=np.nan
    big_ic[big_ic>=0.03]=1
    return big_ic

def big_select(rows, n=30):
    # 只选最大的30只
    time, row = rows
    row = row.dropna().index
    dct = {}
    if len(row) == 0:
        return dct
    target = DataAPI.factor(codes, row, length=1).iloc[:, -1, :].T
    for name, s in target.iteritems():
        for code in s.nlargest(n).index:
            dct[code] = 1
    return dct

select_big = pd.DataFrame(list(map(big_select, cal_big(ic_df[5]).iterrows())), index=PN.major_axis[:])

big_result = select_big.stack()

使用alphaman计算绩效，再用图片显示

from fxdayu_alphaman.selector.admin import Admin as s_admin
s_admin = s_admin()
big_performance = s_admin.calculate_performance("Roll_IC",
                               big_result[big_result>0], #结果大于0的（选出的）
                               start,
                               end,
                               periods=(5,))

import alphalens
def plot_performance(performance):
    alphalens.plotting.plot_cumulative_returns_by_quantile(performance["mean_return"],period=5)
    plt.show()
plot_performance(big_performance)