【量價因子 - 結合價格和成交量構建選股策略】整理轉分享

2022年12月17日14:04:04 財經 1241

1. 概述

本文以海通證券《選股因子系列研究(十二)——「量」與「價」的結合》的研究方法為模板，試圖分析量價相關關係作為因子的效果：

將股票在短期內的量價走勢分類為量價背離與量價同向，並通過量價相關性來衡量量價走勢的背離與同向程度
按照量價因子選股的月度多空收益在1%以上，得到了很顯著的alpha
純多頭組合在六年回測中年化收益達到22.4%，信息比率達到2.22
量價因子等權疊加了反轉因子後，六年回測年化收益達到26.0%，信息比率達到2.55

2. 量價因子構建

股票交易中，最顯然的指標無非價格和成交量，大多經典的技術指標其實都是圍繞著價格和成交量來構建，本文中嘗試將這兩者結合起來構建量價因子。中短周期上，量價走勢分類為量價背離與量價同向，並通過量價相關性來衡量量價走勢的背離與同向的程度。因此，量價相關性，也就是本文中的量價因子，可以簡單定義為：

一段時間窗口內，股票收盤價與股票日換手率之間的秩相關係數

本文中的量價相關係數計算，採取的時間窗口為15個交易日

下面給出本文中用來計算量價因子的程序代碼

import matplotlib.pyplot as plt
from matplotlib import rc
from matplotlib import dates
rc('mathtext', default='regular')
import seaborn as sns
sns.set_style('white')
import datetime
import numpy as np
import pandas as pd
import time
import scipy.stats as st
from CAL.PyCAL import *    # CAL.PyCAL中包含font

def getVolPriceCorrAll(universe, begin, end, window, file_name):
    # 計算各股票歷史區間window天窗口移動的量價相關係數
    
    # 拿取上海證券交易所日曆
    cal_dates = DataAPI.TradeCalGet(exchangeCD=u"XSHG", beginDate=begin, endDate=end).sort('calendarDate')
    cal_dates = cal_dates[cal_dates['isOpen']==1]
    all_dates = cal_dates['calendarDate'].values.tolist()                          # 工作日列表
    
    print str(window) + ' days Price-Volume-Corr will be calculated for ' + str(len(universe)) + ' stocks:'
    count = 0
    secs_time = 0
    start_time = time.time()
    
    ret_data = pd.DataFrame()   # 保存計算出來的收益率數據
    ret_data.to_csv(file_name)
    
    N = 10
    for i in range(len(universe)/N+1):
        sub_univ = universe[i*N:(i+1)*N]
        if len(sub_univ) == 0:
            continue
        data = DataAPI.MktEqudAdjGet(secID=sub_univ, beginDate=begin, endDate=end, 
                                     field='secID,tradeDate,turnoverRate,preClosePrice,closePrice')    # 拿取數據
        for stk in sub_univ:        # 對每一隻股票分別計算歷史window天前望收益率     
            tmp_ret_data = data[data.secID==stk].sort('tradeDate')
            
            corr_data = range(len(tmp_ret_data))
            for i in range(window-1, len(tmp_ret_data)):
                x = tmp_ret_data['turnoverRate'].values[i-window+1:i+1]
                y = tmp_ret_data['closePrice'].values[i-window+1:i+1]
                corr_data[i] = st.spearmanr(x, y)[0]
                
            # 計算前向收益率
            tmp_ret_data['corr'] = corr_data
            tmp_ret_data = tmp_ret_data[['tradeDate','corr']]
            tmp_ret_data.columns = ['tradeDate', stk]


            ret_data = pd.read_csv(file_name)
            if ret_data.empty:
                ret_data = tmp_ret_data
            else:
                ret_data = ret_data[ret_data.columns[1:]]
                ret_data = ret_data.merge(tmp_ret_data, on='tradeDate', how='outer')


            ret_data = ret_data.sort('tradeDate')
            ret_data.to_csv(file_name)
            
        # 列印進度部分
        count += 1
        if count > 0 and count % 2 == 0:
            finish_time = time.time()
            print count*N,
            print '  ' + str(np.round((finish_time-start_time) - secs_time, 0)) + ' seconds elapsed.'
            secs_time = (finish_time-start_time)
    return ret_data


def getBackwardReturnsAll(universe, begin, end, window, file_name):
    # 計算各股票歷史區間回報率，過去window天的收益率
    
    print str(window) + ' days backward returns will be calculated for ' + str(len(universe)) + ' stocks:'
    count = 0
    secs_time = 0
    start_time = time.time()
    
    N = 50
    ret_data = pd.DataFrame()
    for stk in universe:
        data = DataAPI.MktEqudAdjGet(secID=stk, beginDate=begin, endDate=end, 
                                     field='secID,tradeDate,closePrice')    # 拿取數據
        tmp_ret_data = data.sort('tradeDate')
        # 計算歷史窗口收益率
        tmp_ret_data['forwardReturns'] = tmp_ret_data['closePrice'] / tmp_ret_data['closePrice'].shift(window) - 1.0
        tmp_ret_data = tmp_ret_data[['tradeDate','forwardReturns']]
        tmp_ret_data.columns = ['tradeDate', stk]


        if ret_data.empty:
            ret_data = tmp_ret_data
        else:
            ret_data = ret_data.merge(tmp_ret_data, on='tradeDate', how='outer')


        # 列印進度部分
        count += 1
        if count > 0 and count % N == 0:
            finish_time = time.time()
            print count,
            print '  ' + str(np.round((finish_time-start_time) - secs_time, 0)) + ' seconds elapsed.'
            secs_time = (finish_time-start_time)
    
    ret_data.to_csv(file_name)
    return ret_data


def getForwardReturnsAll(universe, begin, end, window, file_name):
    # 計算各股票歷史區間前瞻回報率，未來window天的收益率
    
    print str(window) + ' days forward returns will be calculated for ' + str(len(universe)) + ' stocks:'
    count = 0
    secs_time = 0
    start_time = time.time()
    
    N = 50
    ret_data = pd.DataFrame()
    for stk in universe:
        data = DataAPI.MktEqudAdjGet(secID=stk, beginDate=begin, endDate=end, 
                                     field='secID,tradeDate,closePrice')    # 拿取數據
        tmp_ret_data = data.sort('tradeDate')
        # 計算歷史窗口前瞻收益率
        tmp_ret_data['forwardReturns'] = tmp_ret_data['closePrice'].shift(-window) / tmp_ret_data['closePrice']  - 1.0
        tmp_ret_data = tmp_ret_data[['tradeDate','forwardReturns']]
        tmp_ret_data.columns = ['tradeDate', stk]


        if ret_data.empty:
            ret_data = tmp_ret_data
        else:
            ret_data = ret_data.merge(tmp_ret_data, on='tradeDate', how='outer')


        # 列印進度部分
        count += 1
        if count > 0 and count % N == 0:
            finish_time = time.time()
            print count,
            print '  ' + str(np.round((finish_time-start_time) - secs_time, 0)) + ' seconds elapsed.'
            secs_time = (finish_time-start_time)
    
    ret_data.to_csv(file_name)
    return ret_data




def getMarketValueAll(universe, begin, end, file_name):
    # 獲取股票歷史每日市值
    
    print  'MarketValue will be calculated for ' + str(len(universe)) + ' stocks:'
    count = 0
    secs_time = 0
    start_time = time.time()
    
    N = 50
    ret_data = pd.DataFrame()
    for stk in universe:
        data = DataAPI.MktEqudAdjGet(secID=stk, beginDate=begin, endDate=end, 
                                     field='secID,tradeDate,marketValue')    # 拿取數據
        tmp_ret_data = data.sort('tradeDate')
        # 市值部分
        tmp_ret_data = tmp_ret_data[['tradeDate','marketValue']]
        tmp_ret_data.columns = ['tradeDate', stk]


        if ret_data.empty:
            ret_data = tmp_ret_data
        else:
            ret_data = ret_data.merge(tmp_ret_data, on='tradeDate', how='outer')


        # 列印進度部分
        count += 1
        if count > 0 and count % N == 0:
            finish_time = time.time()
            print count,
            print '  ' + str(np.round((finish_time-start_time) - secs_time, 0)) + ' seconds elapsed.'
            secs_time = (finish_time-start_time)
    
    ret_data.to_csv(file_name)
    return ret_data


def getWindowMeanTurnoverRateAll(universe, begin, end, window, file_name):
    # 獲取股票歷史滾動窗口平均換手率
    
    print  'windowMeanTurnoverRate will be calculated for ' + str(len(universe)) + ' stocks:'
    count = 0
    secs_time = 0
    start_time = time.time()
    
    N = 100
    ret_data = pd.DataFrame()
    for stk in universe:
        data = DataAPI.MktEqudAdjGet(secID=stk, beginDate=begin, endDate=end, 
                                     field='secID,tradeDate,turnoverRate')    # 拿取數據
        tmp_ret_data = data.sort('tradeDate')
        # 市值部分
        tmp_ret_data['windowMeanTurnoverRate'] = pd.rolling_mean(tmp_ret_data['turnoverRate'], window=window)
        tmp_ret_data = tmp_ret_data[['tradeDate','windowMeanTurnoverRate']]
        tmp_ret_data.columns = ['tradeDate', stk]


        if ret_data.empty:
            ret_data = tmp_ret_data
        else:
            ret_data = ret_data.merge(tmp_ret_data, on='tradeDate', how='outer')


        # 列印進度部分
        count += 1
        if count > 0 and count % N == 0:
            finish_time = time.time()
            print count,
            print '  ' + str(np.round((finish_time-start_time) - secs_time, 0)) + ' seconds elapsed.'
            secs_time = (finish_time-start_time)
    
    ret_data.to_csv(file_name)
    return ret_data

上面分別定義了計算本文關心的幾個變數的函數，其中包括：

價量相關係數，getVolPriceCorrAll
歷史收益率，getBackwardReturnsAll
未來收益率，getForwardReturnsAll
市值，getMarketValueAll
歷史窗口日均換手率，getWindowMeanTurnoverRateAll

下面利用這五個函數分別計算我們需要的各種變數（我們只用了全A股中的50隻作為示例，感興趣的讀者只需要將下面cell中第5行中的universe修改即可計算更大股票池的數據），並將這些變數保存在文件中以供調用。

begin_date = '20060101'  # 開始日期
end_date = '20160802'    # 結束日期


universe = set_universe('A')      # 股票池
universe = universe[0:50]         # 計算速度緩慢，僅以部分股票池作為sample


# ----------- 計算量價相關係數部分 ----------------
window_corr = 15                
print '======================='
start_time = time.time()
forward_returns_data = getVolPriceCorrAll(universe=universe, begin=begin_date, end=end_date, window=window_corr, file_name='VolPriceCorr_W15_FullA_sample.csv')
finish_time = time.time()
print ''
print str(finish_time-start_time) + ' seconds elapsed in total.'


# ----------- 計算股票歷史窗口（一個月）收益率部分 ----------------
window_return = 20                
print '======================='
start_time = time.time()
forward_returns_data = getBackwardReturnsAll(universe=universe, begin=begin_date, end=end_date, window=window_return, file_name='BackwardReturns_W20_FullA_Sample.csv')
finish_time = time.time()
print ''
print str(finish_time-start_time) + ' seconds elapsed in total.'


# ----------- 計算股票歷史窗口（三個月）收益率部分 ----------------
window_return = 60                
print '======================='
start_time = time.time()
forward_returns_data = getBackwardReturnsAll(universe=universe, begin=begin_date, end=end_date, window=window_return, file_name='BackwardReturns_W60_FullA_Sample.csv')
finish_time = time.time()
print ''
print str(finish_time-start_time) + ' seconds elapsed in total.'


# ----------- 計算股票前瞻收益率部分 ----------------
window_return = 20                
print '======================='
start_time = time.time()
forward_returns_data = getForwardReturnsAll(universe=universe, begin=begin_date, end=end_date, window=window_return, file_name='ForwardReturns_W20_FullA_Sample.csv')
finish_time = time.time()
print ''
print str(finish_time-start_time) + ' seconds elapsed in total.'


# ----------- 計算股票歷史市值部分 ----------------
print '======================='
start_time = time.time()
forward_returns_data = getMarketValueAll(universe=universe, begin=begin_date, end=end_date, file_name='MarketValues_FullA_Sample.csv')
finish_time = time.time()
print ''
print str(finish_time-start_time) + ' seconds elapsed in total.'


# ----------- 計算歷史月度日均換手率部分 ----------------
window = 20                
print '======================='
start_time = time.time()
forward_returns_data = getWindowMeanTurnoverRateAll(universe=universe, begin=begin_date, end=end_date, window=window, file_name='TurnoverRateWindowMean_W20_FullA_Sample.csv')
finish_time = time.time()
print ''
print str(finish_time-start_time) + ' seconds elapsed in total.'

3. 量價因子截面特徵

3.1 首先載入計算好的數據文件：

# 提取數據
corr_data = pd.read_csv('VolPriceCorr_W15_FullA.csv')                    # 15天窗口量價相關係數
forward_20d_return_data = pd.read_csv('ForwardReturns_W20_FullA.csv')    # 未來20天收益率    
backward_20d_return_data = pd.read_csv('BackwardReturns_W20_FullA.csv')  # 過去20天收益率 
backward_60d_return_data = pd.read_csv('BackwardReturns_W60_FullA.csv')  # 過去60天收益率 
mkt_value_data = pd.read_csv('MarketValues_FullA.csv')                    # 市值數據
turnover_rate_data = pd.read_csv('TurnoverRateWindowMean_W20_FullA.csv') # 過去20天日均換手率數據


corr_data['tradeDate'] = map(Date.toDateTime, map(DateTime.parseISO, corr_data['tradeDate']))
forward_20d_return_data['tradeDate'] = map(Date.toDateTime, map(DateTime.parseISO, forward_20d_return_data['tradeDate']))
backward_20d_return_data['tradeDate'] = map(Date.toDateTime, map(DateTime.parseISO, backward_20d_return_data['tradeDate']))
backward_60d_return_data['tradeDate'] = map(Date.toDateTime, map(DateTime.parseISO, backward_60d_return_data['tradeDate']))
mkt_value_data['tradeDate'] = map(Date.toDateTime, map(DateTime.parseISO, mkt_value_data['tradeDate']))
turnover_rate_data['tradeDate'] = map(Date.toDateTime, map(DateTime.parseISO, turnover_rate_data['tradeDate']))


corr_data = corr_data[corr_data.columns[1:]].set_index('tradeDate')
forward_20d_return_data = forward_20d_return_data[forward_20d_return_data.columns[1:]].set_index('tradeDate')
backward_20d_return_data = backward_20d_return_data[backward_20d_return_data.columns[1:]].set_index('tradeDate')
backward_60d_return_data = backward_60d_return_data[backward_60d_return_data.columns[1:]].set_index('tradeDate')
mkt_value_data = mkt_value_data[mkt_value_data.columns[1:]].set_index('tradeDate')
turnover_rate_data = turnover_rate_data[turnover_rate_data.columns[1:]].set_index('tradeDate')

下表中，展示了我們計算好的corr_data數據文件的一部分，主要為了說明我們接下來使用的數據dataframe的結構：

每一行為日期，每個交易日均有計算數據，從2006年到2016年8月
每一列為股票，股票池為全A股

corr_data.tail()

得到相關係數表：

3.2 量價相關因子截面特徵

接下來，我們簡單檢查一下我們計算得到的量價相關因子的截面特徵

# 量價相關性歷史表現


n_quantile = 10
# 和海通研報一樣，統計十分位數
cols_mean = ['meanQ'+str(i+1) for i in range(n_quantile)]
cols = cols_mean
corr_means = pd.DataFrame(index=corr_data.index, columns=cols)


# 計算相關係數分組平均值
for dt in corr_means.index:
    qt_mean_results = []


    # 相關係數去掉nan和絕對值大於1的
    tmp_corr = corr_data.ix[dt].dropna()
    tmp_corr = tmp_corr[(tmp_corr<=1.0) & (tmp_corr>=-1.0)]
    
    pct_quantiles = 1.0/n_quantile
    for i in range(n_quantile):
        down = tmp_corr.quantile(pct_quantiles*i)
        up = tmp_corr.quantile(pct_quantiles*(i+1))
        mean_tmp = tmp_corr[(tmp_corr<=up) & (tmp_corr>=down)].mean()
        qt_mean_results.append(mean_tmp)
    corr_means.ix[dt] = qt_mean_results


# corr_means是對歷史每一天，求量價相關係數在各個十分位裡面的平均值
corr_means.tail()

下圖給出了2006年至2016年間，在不同時點，將市場上所有股票按量價相關性分10組後，第1組、第5組以及第10組股票量價相關性的均值情況，即我們所說的量價相關性截面特徵

觀察下圖可知，量價相關性的截面特徵較為穩定

# 量價相關性歷史表現作圖


fig = plt.figure(figsize=(16, 6))
ax1 = fig.add_subplot(111)


lns1 = ax1.plot(corr_means.index, corr_means.meanQ1, label='Q1')
lns2 = ax1.plot(corr_means.index, corr_means.meanQ5, label='Q5')
lns3 = ax1.plot(corr_means.index, corr_means.meanQ10, label='Q10')


lns = lns1+lns2+lns3
labs = [l.get_label() for l in lns]
ax1.legend(lns, labs, bbox_to_anchor=[0.5, 0.1], loc='', ncol=3, mode="", borderaxespad=0., fontsize=12)
ax1.set_ylabel(u'量價相關係數', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'日期', fontproperties=font, fontsize=16)
ax1.set_title(u"量價相關性歷史表現", fontproperties=font, fontsize=16)
ax1.grid()

3.3 量價因子的預測能力初探

接下來，我們計算了每一天的量價因子和之後20日收益的秩相關係數

# 『過去十五天量價相關係數』和『之後20天收益』的秩相關係數計算


ic_data = pd.DataFrame(index=corr_data.index, columns=['IC','pValue'])


# 計算相關係數
for dt in ic_data.index:
    tmp_corr = corr_data.ix[dt]
    tmp_ret = forward_20d_return_data.ix[dt]
    cor = pd.DataFrame(tmp_corr)
    ret = pd.DataFrame(tmp_ret)
    cor.columns = ['corr']
    ret.columns = ['ret']
    cor['ret'] = ret['ret']
    cor = cor[~np.isnan(cor['corr'])][~np.isnan(cor['ret'])]
    if len(cor) < 5:
        continue
    # ic,p_value = st.pearsonr(q['Q'],q['ret'])                 # 計算相關係數   IC
    # ic,p_value = st.pearsonr(q['Q'].rank(),q['ret'].rank())   # 計算秩相關係數 RankIC
    ic, p_value = st.spearmanr(cor['corr'],cor['ret'])   # 計算秩相關係數 RankIC
    ic_data['IC'][dt] = ic
    ic_data['pValue'][dt] = p_value
    
# print len(ic_data['IC']), len(ic_data[ic_data.IC>0]), len(ic_data[ic_data.IC<0])
print 'mean of IC: ', ic_data['IC'].mean()
print 'median of IC: ', ic_data['IC'].median()
print 'the number of IC(all, plus, minus): ', (len(ic_data), len(ic_data[ic_data.IC>0]), len(ic_data[ic_data.IC<0]))

mean of IC:

-0.0415786327101 median of IC: -0.0477574767849 the number of IC(all, plus, minus): (2572, 778, 1760)

從上面計算結果和下圖可知，量價因子和未來20日收益的秩相關係數在大部分時間為負，量價因子對於未來20天的收益有預測性

# 『過去十五天量價相關係數』和『之後20天收益』的秩相關係數作圖


fig = plt.figure(figsize=(16, 6))
ax1 = fig.add_subplot(111)


lns1 = ax1.plot(ic_data.index, ic_data.IC, label='IC')


lns = lns1
labs = [l.get_label() for l in lns]
ax1.legend(lns, labs, bbox_to_anchor=[0.5, 0.1], loc='', ncol=3, mode="", borderaxespad=0., fontsize=12)
ax1.set_ylabel(u'相關係數', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'日期', fontproperties=font, fontsize=16)
ax1.set_title(u"量價因子和未來20日收益之間的秩相關係數", fontproperties=font, fontsize=16)
ax1.grid()

4. 量價因子歷史回測概述

本節使用2006年以來的數據對於量價相關性因子歷史表現進行回測，進一步簡單設計量價因子選股的幾個風險因子暴露情況。

4.1 量價因子選股的分組超額收益

n_quantile = 10
# 和海通研報一樣，統計十分位數
cols_mean = [i+1 for i in range(n_quantile)]
cols = cols_mean


excess_returns_means = pd.DataFrame(index=corr_data.index, columns=cols)


# 計算相關係數分組的超額收益平均值
for dt in excess_returns_means.index:
    qt_mean_results = []
    
    # 相關係數去掉nan和絕對值大於1的
    tmp_corr = corr_data.ix[dt].dropna()
    tmp_corr = tmp_corr[(tmp_corr<=1.0) & (tmp_corr>=-1.0)]
    tmp_return = forward_20d_return_data.ix[dt].dropna()
    tmp_return_mean = tmp_return.mean()
    
    pct_quantiles = 1.0/n_quantile
    for i in range(n_quantile):
        down = tmp_corr.quantile(pct_quantiles*i)
        up = tmp_corr.quantile(pct_quantiles*(i+1))
        i_quantile_index = tmp_corr[(tmp_corr<=up) & (tmp_corr>=down)].index
        mean_tmp = tmp_return[i_quantile_index].mean() - tmp_return_mean
        qt_mean_results.append(mean_tmp)
        
    excess_returns_means.ix[dt] = qt_mean_results


excess_returns_means.dropna(inplace=True)
excess_returns_means.tail()

上表計算結果，給出了2006年開始，每天進行量價因子十分位選股後，每個分組內股票在未來一個月相對於市場平均收益的超額收益均值
注意：十分位分組中，量價因子由小到大排序，即第一組為量價因子最小的組
下圖展示，量價因子十分位選股後，在未來一個月各個分組的超額收益，可以發現：因子多空收益明顯，且因子空頭收益更強

fig = plt.figure(figsize=(12, 6))
ax1 = fig.add_subplot(111)


excess_returns_means_dist = excess_returns_means.mean()
# lns1 = ax1.plot(excess_returns_means_dist.index, excess_returns_means_dist.values, '--o', label='IC')
excess_dist_plus = excess_returns_means_dist[excess_returns_means_dist>0]
excess_dist_minus = excess_returns_means_dist[excess_returns_means_dist<0]
lns2 = ax1.bar(excess_dist_plus.index, excess_dist_plus.values, align='center', color='r', width=0.35)
lns3 = ax1.bar(excess_dist_minus.index, excess_dist_minus.values, align='center', color='g', width=0.35)


ax1.set_xlim(left=0.5, right=len(excess_returns_means_dist)+0.5)
ax1.set_ylim(-0.01, 0.004)
ax1.set_ylabel(u'超額收益', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'十分位分組', fontproperties=font, fontsize=16)
ax1.set_xticks(excess_returns_means_dist.index)
ax1.set_xticklabels([int(x) for x in ax1.get_xticks()], fontproperties=font, fontsize=14)
ax1.set_yticklabels([str(x*100)+'0%' for x in ax1.get_yticks()], fontproperties=font, fontsize=14)
ax1.set_title(u"量價相關性選股因子超額收益", fontproperties=font, fontsize=16)
ax1.grid()

4.2 量價因子選股的市值分布特徵

檢查量價因子的小市值暴露情況。因為很多策略因為小市值暴露在A股市場表現優異。

n_quantile = 10
# 和海通研報一樣，統計十分位數
cols_mean = [i+1 for i in range(n_quantile)]
cols = cols_mean


mkt_value_means = pd.DataFrame(index=corr_data.index, columns=cols)


# 計算相關係數分組的超額收益平均值
for dt in mkt_value_means.index:
    qt_mean_results = []
    
    # 相關係數去掉nan和絕對值大於1的
    tmp_corr = corr_data.ix[dt].dropna()
    tmp_corr = tmp_corr[(tmp_corr<=1.0) & (tmp_corr>=-1.0)]
    tmp_mkt_value = mkt_value_data.ix[dt].dropna()
    tmp_mkt_value = tmp_mkt_value.rank()/len(tmp_mkt_value)
    
    pct_quantiles = 1.0/n_quantile
    for i in range(n_quantile):
        down = tmp_corr.quantile(pct_quantiles*i)
        up = tmp_corr.quantile(pct_quantiles*(i+1))
        i_quantile_index = tmp_corr[(tmp_corr<=up) & (tmp_corr>=down)].index
        mean_tmp = tmp_mkt_value[i_quantile_index].mean()
        qt_mean_results.append(mean_tmp)
        
    mkt_value_means.ix[dt] = qt_mean_results


mkt_value_means.dropna(inplace=True)
mkt_value_means.tail()

上表計算結果，給出了2006年開始，每天進行量價因子十分位選股後，每個分組內股票的市值百分位均值
下圖展示，量價因子十分位選股後，各個分組的市值百分位歷史均值：量價因子有略微的大市值暴露，與市值因子負相關

fig = plt.figure(figsize=(12, 6))
ax1 = fig.add_subplot(111)
ax2 = ax1.twinx()


mkt_value_means_dist = mkt_value_means.mean()
lns1 = ax1.bar(mkt_value_means_dist.index, mkt_value_means_dist.values, align='center', width=0.35)
lns2 = ax2.plot(excess_returns_means_dist.index, excess_returns_means_dist.values, 'o-r')


ax1.legend(lns1, ['market value(left axis)'], loc=2, fontsize=12)
ax2.legend(lns2, ['excess return(right axis)'], fontsize=12)
ax1.set_ylim(0.4, 0.6)
ax2.set_ylim(-0.01, 0.004)
ax1.set_xlim(left=0.5, right=len(mkt_value_means_dist)+0.5)
ax1.set_ylabel(u'市值百分位數', fontproperties=font, fontsize=16)
ax2.set_ylabel(u'超額收益', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'十分位分組', fontproperties=font, fontsize=16)
ax1.set_xticks(mkt_value_means_dist.index)
ax1.set_xticklabels([int(x) for x in ax1.get_xticks()], fontproperties=font, fontsize=14)
ax1.set_yticklabels([str(x*100)+'%' for x in ax1.get_yticks()], fontproperties=font, fontsize=14)
ax2.set_yticklabels([str(x*100)+'0%' for x in ax2.get_yticks()], fontproperties=font, fontsize=14)
ax1.set_title(u"量價相關性選股因子市值分布特徵", fontproperties=font, fontsize=16)
ax1.grid()

4.3 量價因子選股的換手率分布特徵

n_quantile = 10
# 和海通研報一樣，統計十分位數
cols_mean = [i+1 for i in range(n_quantile)]
cols = cols_mean
turnover_rate_means = pd.DataFrame(index=corr_data.index, columns=cols)


# 計算相關係數分組的超額收益平均值
for dt in turnover_rate_means.index:
    qt_mean_results = []
    
    # 相關係數去掉nan和絕對值大於1的
    tmp_corr = corr_data.ix[dt].dropna()
    tmp_corr = tmp_corr[(tmp_corr<=1.0) & (tmp_corr>=-1.0)]
    tmp_turnover_rate = turnover_rate_data.ix[dt].dropna()
    
    pct_quantiles = 1.0/n_quantile
    for i in range(n_quantile):
        down = tmp_corr.quantile(pct_quantiles*i)
        up = tmp_corr.quantile(pct_quantiles*(i+1))
        i_quantile_index = tmp_corr[(tmp_corr<=up) & (tmp_corr>=down)].index
        mean_tmp = tmp_turnover_rate[i_quantile_index].mean()
        qt_mean_results.append(mean_tmp)
        
    turnover_rate_means.ix[dt] = qt_mean_results


turnover_rate_means.dropna(inplace=True)
turnover_rate_means.tail()

上表計算結果，給出了2006年開始，每天進行量價因子十分位選股後，每個分組內股票的前一個月日均換手率的均值
下圖展示，量價因子十分位選股後，各個分組的1個月日均換手率均值：量價因子對於低換手率有一定風險暴露，換手率隨組別上升而逐漸升高

fig = plt.figure(figsize=(12, 6))
ax1 = fig.add_subplot(111)
ax2 = ax1.twinx()


turnover_rate_means_dist = turnover_rate_means.mean()
lns1 = ax1.bar(turnover_rate_means_dist.index, turnover_rate_means_dist.values, align='center', width=0.35)
lns2 = ax2.plot(excess_returns_means_dist.index, excess_returns_means_dist.values, 'o-r')


ax1.legend(lns1, ['turnover rate(left axis)'], loc=2, fontsize=12)
ax2.legend(lns2, ['excess return(right axis)'], fontsize=12)
ax1.set_ylim(0, 0.05)
ax2.set_ylim(-0.01, 0.004)
ax1.set_xlim(left=0.5, right=len(turnover_rate_means_dist)+0.5)
ax1.set_ylabel(u'換手率', fontproperties=font, fontsize=16)
ax2.set_ylabel(u'超額收益', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'十分位分組', fontproperties=font, fontsize=16)
ax1.set_xticks(turnover_rate_means_dist.index)
ax1.set_xticklabels([int(x) for x in ax1.get_xticks()], fontproperties=font, fontsize=14)
ax1.set_yticklabels([str(x*100)+'%' for x in ax1.get_yticks()], fontproperties=font, fontsize=14)
ax2.set_yticklabels([str(x*100)+'0%' for x in ax2.get_yticks()], fontproperties=font, fontsize=14)
ax1.set_title(u"量價相關性選股因子換手率分布特徵", fontproperties=font, fontsize=16)
ax1.grid()

4.4 量價因子選股的一個月反轉分布特徵

n_quantile = 10
# 和海通研報一樣，統計十分位數
cols_mean = [i+1 for i in range(n_quantile)]
cols = cols_mean
hist_returns_means = pd.DataFrame(index=corr_data.index, columns=cols)


# 計算相關係數分組的超額收益平均值
for dt in hist_returns_means.index:
    qt_mean_results = []
    
    # 相關係數去掉nan和絕對值大於1的
    tmp_corr = corr_data.ix[dt].dropna()
    tmp_corr = tmp_corr[(tmp_corr<=1.0) & (tmp_corr>=-1.0)]
    tmp_return = backward_20d_return_data.ix[dt].dropna()
    tmp_return_mean = tmp_return.mean()
    
    pct_quantiles = 1.0/n_quantile
    for i in range(n_quantile):
        down = tmp_corr.quantile(pct_quantiles*i)
        up = tmp_corr.quantile(pct_quantiles*(i+1))
        i_quantile_index = tmp_corr[(tmp_corr<=up) & (tmp_corr>=down)].index
        mean_tmp = tmp_return[i_quantile_index].mean() - tmp_return_mean
        qt_mean_results.append(mean_tmp)
        
    hist_returns_means.ix[dt] = qt_mean_results


hist_returns_means.dropna(inplace=True)
hist_returns_means.tail()

上表計算結果，給出了2006年開始，每天進行量價因子十分位選股後，每個分組內股票的前一個月超額漲幅(超出市場平均值)的均值
下圖展示，量價因子十分位選股後，各個分組的前一個月超額漲幅均值：量價因子對於一個月反轉因子有一定風險暴露（多頭組合即第一組中的股票前一個月平均跑輸市場）

fig = plt.figure(figsize=(12, 6))
ax1 = fig.add_subplot(111)
ax2 = ax1.twinx()


hist_returns_means_dist = hist_returns_means.mean()
lns1 = ax1.bar(hist_returns_means_dist.index, hist_returns_means_dist.values, align='center', width=0.35)
lns2 = ax2.plot(excess_returns_means_dist.index, excess_returns_means_dist.values, 'o-r')


ax1.legend(lns1, ['20 day return(left axis)'], loc=2, fontsize=12)
ax2.legend(lns2, ['excess return(right axis)'], fontsize=12)
ax1.set_ylim(-0.03, 0.07)
ax2.set_ylim(-0.01, 0.004)
ax1.set_xlim(left=0.5, right=len(hist_returns_means_dist)+0.5)
ax1.set_ylabel(u'歷史一個月收益率', fontproperties=font, fontsize=16)
ax2.set_ylabel(u'超額收益', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'十分位分組', fontproperties=font, fontsize=16)
ax1.set_xticks(hist_returns_means_dist.index)
ax1.set_xticklabels([int(x) for x in ax1.get_xticks()], fontproperties=font, fontsize=14)
ax1.set_yticklabels([str(x*100)+'%' for x in ax1.get_yticks()], fontproperties=font, fontsize=14)
ax2.set_yticklabels([str(x*100)+'0%' for x in ax2.get_yticks()], fontproperties=font, fontsize=14)
ax1.set_title(u"量價相關性選股因子一個月歷史收益率（一個月反轉因子）分布特徵", fontproperties=font, fontsize=16)
ax1.grid()

4.5 量價因子選股的三個月反轉分布特徵

n_quantile = 10
# 和海通研報一樣，統計十分位數
cols_mean = [i+1 for i in range(n_quantile)]
cols = cols_mean
hist_returns_means = pd.DataFrame(index=corr_data.index, columns=cols)


# 計算相關係數分組的超額收益平均值
for dt in hist_returns_means.index:
    qt_mean_results = []
    
    # 相關係數去掉nan和絕對值大於1的
    tmp_corr = corr_data.ix[dt].dropna()
    tmp_corr = tmp_corr[(tmp_corr<=1.0) & (tmp_corr>=-1.0)]
    tmp_return = backward_60d_return_data.ix[dt].dropna()
    tmp_return_mean = tmp_return.mean()
    
    pct_quantiles = 1.0/n_quantile
    for i in range(n_quantile):
        down = tmp_corr.quantile(pct_quantiles*i)
        up = tmp_corr.quantile(pct_quantiles*(i+1))
        i_quantile_index = tmp_corr[(tmp_corr<=up) & (tmp_corr>=down)].index
        mean_tmp = tmp_return[i_quantile_index].mean() - tmp_return_mean
        qt_mean_results.append(mean_tmp)
        
    hist_returns_means.ix[dt] = qt_mean_results


hist_returns_means.dropna(inplace=True)
hist_returns_means.tail()

上表計算結果，給出了2006年開始，每天進行量價因子十分位選股後，每個分組內股票的前三個月超額漲幅(超出市場平均值)的均值
下圖展示，量價因子十分位選股後，各個分組的前三個月超額漲幅均值：股票分組在三個月漲幅上的分布並未呈現出明顯的單調性，僅呈現出「兩頭高，中間低」的特點

fig = plt.figure(figsize=(12, 6))
ax1 = fig.add_subplot(111)
ax2 = ax1.twinx()


hist_returns_means_dist = hist_returns_means.mean()
lns1 = ax1.bar(hist_returns_means_dist.index, hist_returns_means_dist.values, align='center', width=0.35)
lns2 = ax2.plot(excess_returns_means_dist.index, excess_returns_means_dist.values, 'o-r')


ax1.legend(lns1, ['60 day return(left axis)'], loc=2, fontsize=12)
ax2.legend(lns2, ['excess return(right axis)'], fontsize=12)
ax1.set_ylim(-0.02, 0.04)
ax2.set_ylim(-0.01, 0.004)
ax1.set_xlim(left=0.5, right=len(hist_returns_means_dist)+0.5)
ax1.set_ylabel(u'歷史三個月收益率', fontproperties=font, fontsize=16)
ax2.set_ylabel(u'超額收益', fontproperties=font, fontsize=16)
ax1.set_xlabel(u'十分位分組', fontproperties=font, fontsize=16)
ax1.set_xticks(hist_returns_means_dist.index)
ax1.set_xticklabels([int(x) for x in ax1.get_xticks()], fontproperties=font, fontsize=14)
ax1.set_yticklabels([str(x*100)+'%' for x in ax1.get_yticks()], fontproperties=font, fontsize=14)
ax2.set_yticklabels([str(x*100)+'0%' for x in ax2.get_yticks()], fontproperties=font, fontsize=14)
ax1.set_title(u"量價相關性選股因子三個月歷史收益率（三個月反轉因子）分布特徵", fontproperties=font, fontsize=16)
ax1.grid()

5. 量價因子歷史回測凈值表現

接下來，考察上述量價因子的選股能力的回測效果。歷史回測的基本設置如下：

回測時段為2010年1月1日至2016年8月1日
股票池為A股全部股票
組合每15個交易日調倉，交易費率設為雙邊萬分之二
調倉時，漲停、停牌不買入，跌停、停牌不賣出；
每月底調倉時，選擇股票池中量價因子最小的20%的股票；

5.1 量價因子最小20%股票

start = '2010-01-01'                       # 回測起始時間
end = '2016-08-01'                         # 回測結束時間
benchmark = 'ZZ500'                        # 策略參考標準
universe = set_universe('A')               # 證券池，支持股票和基金
capital_base = 10000000                    # 起始資金
freq = 'd'                                 # 策略類型，'d'表示日間策略使用日線回測
refresh_rate = 15                          # 調倉頻率，表示執行handle_data的時間間隔


corr_data = pd.read_csv('VolPriceCorr_W15_FullA.csv')     # 讀取量價因子數據
corr_data = corr_data[corr_data.columns[1:]].set_index('tradeDate')
corr_dates = corr_data.index.values


quantile_five = 1                           # 選取股票的量價因子五分位數，1表示選取股票池中因子最小的10%的股票
commission = Commission(0.0002,0.0002)      # 交易費率設為雙邊萬分之二


def initialize(account):                   # 初始化虛擬賬戶狀態
    pass


def handle_data(account):                  # 每個交易日的買入賣出指令
    pre_date = account.previous_date.strftime("%Y-%m-%d")
    if pre_date not in corr_dates:            # 只在計算過量價因子的交易日調倉
        return
    
    # 拿取調倉日前一個交易日的量價因子，並按照相應十分位選擇股票
    pre_corr = corr_data.ix[pre_date]
    pre_corr = pre_corr.dropna()
    pre_corr = pre_corr[(pre_corr<=1.0) & (pre_corr>=-1.0)]
    
    pre_corr_min = pre_corr.quantile((quantile_five-1)*0.2)
    pre_corr_max = pre_corr.quantile(quantile_five*0.2)
    my_univ = pre_corr[pre_corr>=pre_corr_min][pre_corr<pre_corr_max].index.values
    
    # 調倉邏輯
    univ = [x for x in my_univ if x in account.universe]
    
    # 不在股票池中的，清倉
    for stk in account.valid_secpos:
        if stk not in univ:
            order_to(stk, 0)
    # 在目標股票池中的，等權買入
    for stk in univ:
        order_pct_to(stk, 1.1/len(univ))

bt_all = {}   # 用來保存三個策略運行結果：量價因子，20日反轉因子，量價因子與20日反轉因子等權重疊加
bt_all['corr'] = bt   # 保存量價因子回測結果

5.2 一個月反轉因子最小（近一個月漲幅最低的）20%股票

start = '2010-01-01'                       # 回測起始時間
end = '2016-08-01'                         # 回測結束時間
benchmark = 'ZZ500'                        # 策略參考標準
universe = set_universe('A')               # 證券池，支持股票和基金
capital_base = 10000000                    # 起始資金
freq = 'd'                                 # 策略類型，'d'表示日間策略使用日線回測
refresh_rate = 15                          # 調倉頻率，表示執行handle_data的時間間隔


revs_data = pd.read_csv('BackwardReturns_W20_FullA.csv')     # 讀取反轉因子數據
revs_data = revs_data[revs_data.columns[1:]].set_index('tradeDate')
revs_dates = revs_data.index.values


quantile_five = 1                           # 選取股票的20日反轉因子的五分位數，1表示選取股票池中因子最小的20%的股票
commission = Commission(0.0002,0.0002)     # 交易費率設為雙邊萬分之二


def initialize(account):                   # 初始化虛擬賬戶狀態
    pass


def handle_data(account):                  # 每個交易日的買入賣出指令
    pre_date = account.previous_date.strftime("%Y-%m-%d")
    if pre_date not in revs_dates:            # 只在計算過反轉因子的交易日調倉
        return
    
    # 拿取調倉日前一個交易日的反轉因子，並按照相應十分位選擇股票
    pre_revs = revs_data.ix[pre_date]
    pre_revs = pre_revs.dropna()
    
    pre_revs_min = pre_revs.quantile((quantile_five-1)*0.2)
    pre_revs_max = pre_revs.quantile(quantile_five*0.2)
    my_univ = pre_revs[pre_revs>=pre_revs_min][pre_revs<pre_revs_max].index.values
    
    # 調倉邏輯
    univ = [x for x in my_univ if x in account.universe]
    
    # 不在股票池中的，清倉
    for stk in account.valid_secpos:
        if stk not in univ:
            order_to(stk, 0)
    # 在目標股票池中的，等權買入
    for stk in univ:
        order_pct_to(stk, 1.1/len(univ))

bt_all['revs'] = bt  # 保存一個月反轉因子回測結果

5.3 量價因子疊加反轉因子選股

量價因子和反轉因子分別標準化，之後相加生成疊加因子，選疊加因子最小的20%股票

start = '2010-01-01'                       # 回測起始時間
end = '2016-08-01'                         # 回測結束時間
benchmark = 'ZZ500'                        # 策略參考標準
universe = set_universe('A')               # 證券池，支持股票和基金
capital_base = 10000000                    # 起始資金
freq = 'd'                                 # 策略類型，'d'表示日間策略使用日線回測
refresh_rate = 15                          # 調倉頻率，表示執行handle_data的時間間隔


corr_data = pd.read_csv('VolPriceCorr_W15_FullA.csv')     # 讀取量價因子數據
corr_data = corr_data[corr_data.columns[1:]].set_index('tradeDate')
corr_dates = corr_data.index.values


revs_data = pd.read_csv('BackwardReturns_W20_FullA.csv')     # 讀取反轉因子數據
revs_data = revs_data[revs_data.columns[1:]].set_index('tradeDate')


quantile_five = 1                           # 選取股票的因子五分位數，1表示選取股票池中因子最小的20%的股票
commission = Commission(0.0002,0.0002)     # 交易費率設為雙邊萬分之二


def initialize(account):                   # 初始化虛擬賬戶狀態
    pass


def handle_data(account):                  # 每個交易日的買入賣出指令
    pre_date = account.previous_date.strftime("%Y-%m-%d")
    if pre_date not in corr_dates:            # 只在計算過量價因子的交易日調倉
        return


    # 拿取調倉日前一個交易日的量價因子和反轉因子，並按照相應分位選擇股票
    pre_corr = corr_data.ix[pre_date]
    pre_corr = pre_corr[(pre_corr<=1.0) & (pre_corr>=-1.0)]
    pre_revs = revs_data.ix[pre_date]
    
    # 量價因子和反轉因子只做簡單的等權疊加
    pre_data = pd.Series(standardize(pre_corr.to_dict())) + pd.Series(standardize(pre_revs.to_dict()))   # 因子標準化使用了uqer的函數standardize
    pre_data = pre_data.dropna()
    
    pre_data_min = pre_data.quantile((quantile_five-1)*0.2)
    pre_data_max = pre_data.quantile(quantile_five*0.2)
    my_univ = pre_data[pre_data>=pre_data_min][pre_data<pre_data_max].index.values
    
    # 調倉邏輯
    univ = [x for x in my_univ if x in account.universe]
    
    # 不在股票池中的，清倉
    for stk in account.valid_secpos:
        if stk not in univ:
            order_to(stk, 0)
    # 在目標股票池中的，等權買入
    for stk in univ:
        order_pct_to(stk, 1.1/len(univ))

bt_all['corr + revs'] = bt

5.4 上述三個組合對比

此處對比，量價因子、反轉因子、量價因子疊加反轉因子這三個組合的回測結果

results = {}
for x in bt_all.keys():
    results[x] = {}
    results[x]['bt'] = bt_all[x]

fig = plt.figure(figsize=(10,8))
fig.set_tight_layout(True)
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)
ax1.grid()
ax2.grid()


for qt in ['corr','revs','corr + revs']:
    bt = results[qt]['bt']


    data = bt[[u'tradeDate',u'portfolio_value',u'benchmark_return']]
    data['portfolio_return'] = data.portfolio_value/data.portfolio_value.shift(1) - 1.0   # 總頭寸每日回報率
    data['portfolio_return'].ix[0] = data['portfolio_value'].ix[0]/  10000000.0 - 1.0
    data['excess_return'] = data.portfolio_return - data.benchmark_return                 # 總頭寸每日超額回報率
    data['excess'] = data.excess_return + 1.0
    data['excess'] = data.excess.cumprod()                # 總頭寸對沖指數後的凈值序列
    data['portfolio'] = data.portfolio_return + 1.0     
    data['portfolio'] = data.portfolio.cumprod()          # 總頭寸不對沖時的凈值序列
    data['benchmark'] = data.benchmark_return + 1.0
    data['benchmark'] = data.benchmark.cumprod()          # benchmark的凈值序列
    results[qt]['hedged_max_drawdown'] = max([1 - v/max(1, max(data['excess'][:i+1])) for i,v in enumerate(data['excess'])])  # 對沖後凈值最大回撤
    results[qt]['hedged_volatility'] = np.std(data['excess_return'])*np.sqrt(252)
    results[qt]['hedged_annualized_return'] = (data['excess'].values[-1])**(252.0/len(data['excess'])) - 1.0
    # data[['portfolio','benchmark','excess']].plot(figsize=(12,8))
    # ax.plot(data[['portfolio','benchmark','excess']], label=str(qt))
    ax1.plot(data['tradeDate'], data[['portfolio']], label=str(qt))
    ax2.plot(data['tradeDate'], data[['excess']], label=str(qt))
    


ax1.legend(loc=0, fontsize=12)
ax2.legend(loc=0, fontsize=12)
ax1.set_ylabel(u"凈值", fontproperties=font, fontsize=16)
ax2.set_ylabel(u"對沖凈值", fontproperties=font, fontsize=16)
ax1.set_title(u"量價因子和反轉因子選股能力對比 - 凈值走勢", fontproperties=font, fontsize=16)
ax2.set_title(u"量價因子和反轉因子選股能力對比 - 對沖中證500指數後凈值走勢", fontproperties=font, fontsize=16)

上圖中可以發現：

藍色曲線為量價因子，綠色為反轉因子，紅色為量價因子疊加反轉因子
量價因子的漫長的熊市中走勢穩健，並一直打敗反轉因子
反轉因子在15年之後表現出色
量價因子疊加反轉因子，能起到意想不到的疊加效果

5.5 量價因子選股 —— 不同五分位數組合回測走勢比較

# 可編輯部分與 strategy 模式一樣，其餘部分按本例代碼編寫即可


# -----------回測參數部分開始，可編輯------------
start = '2010-01-01'                       # 回測起始時間
end = '2016-08-01'                         # 回測結束時間
benchmark = 'ZZ500'                        # 策略參考標準
universe = set_universe('A')               # 證券池，支持股票和基金
capital_base = 10000000                    # 起始資金
freq = 'd'                                 # 策略類型，'d'表示日間策略使用日線回測
refresh_rate = 15                          # 調倉頻率，表示執行handle_data的時間間隔


corr_data = pd.read_csv('VolPriceCorr_W15_FullA.csv')     # 讀取量價因子數據
corr_data = corr_data[corr_data.columns[1:]].set_index('tradeDate')
corr_dates = corr_data.index.values
# ---------------回測參數部分結束----------------




# 把回測參數封裝到 SimulationParameters 中，供 quick_backtest 使用
sim_params = quartz.SimulationParameters(start, end, benchmark, universe, capital_base)
# 獲取回測行情數據
idxmap, data = quartz.get_daily_data(sim_params)
# 運行結果
results_corr = {}


# 調整參數(選取股票的量價因子五分位數)，進行快速回測
for quantile_five in range(1, 6):
    
    # ---------------策略邏輯部分----------------
    commission = Commission(0.0002,0.0002)      # 交易費率設為雙邊萬分之二


    def initialize(account):                   # 初始化虛擬賬戶狀態
        pass


    def handle_data(account):                  # 每個交易日的買入賣出指令
        pre_date = account.previous_date.strftime("%Y-%m-%d")
        if pre_date not in corr_dates:            # 只在計算過量價因子的交易日調倉
            return


        # 拿取調倉日前一個交易日的量價因子，並按照相應十分位選擇股票
        pre_corr = corr_data.ix[pre_date]
        pre_corr = pre_corr.dropna()
        pre_corr = pre_corr[(pre_corr<=1.0) & (pre_corr>=-1.0)]


        pre_corr_min = pre_corr.quantile((quantile_five-1)*0.2)
        pre_corr_max = pre_corr.quantile(quantile_five*0.2)
        my_univ = pre_corr[pre_corr>=pre_corr_min][pre_corr<pre_corr_max].index.values


        # 調倉邏輯
        univ = [x for x in my_univ if x in account.universe]


        # 不在股票池中的，清倉
        for stk in account.valid_secpos:
            if stk not in univ:
                order_to(stk, 0)
        # 在目標股票池中的，等權買入
        for stk in univ:
            order_pct_to(stk, 1.1/len(univ))
    # ---------------策略邏輯部分結束----------------


    # 把回測邏輯封裝到 TradingStrategy 中，供 quick_backtest 使用
    strategy = quartz.TradingStrategy(initialize, handle_data)
    # 回測部分
    bt, acct = quartz.quick_backtest(sim_params, strategy, idxmap, data, refresh_rate=refresh_rate, commission=commission)


    # 對於回測的結果，可以通過 perf_parse 函數計算風險指標
    perf = quartz.perf_parse(bt, acct)


    # 保存運行結果
    tmp = {}
    tmp['bt'] = bt
    tmp['annualized_return'] = perf['annualized_return']
    tmp['volatility'] = perf['volatility']
    tmp['max_drawdown'] = perf['max_drawdown']
    tmp['alpha'] = perf['alpha']
    tmp['beta'] = perf['beta']
    tmp['sharpe'] = perf['sharpe']
    tmp['information_ratio'] = perf['information_ratio']
    
    results_corr[quantile_five] = tmp
    print str(quantile_five),
print 'done'

1

2

3

4

5 done

fig = plt.figure(figsize=(10,8))
fig.set_tight_layout(True)
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)
ax1.grid()
ax2.grid()


for qt in results_corr:
    bt = results_corr[qt]['bt']


    data = bt[[u'tradeDate',u'portfolio_value',u'benchmark_return']]
    data['portfolio_return'] = data.portfolio_value/data.portfolio_value.shift(1) - 1.0   # 總頭寸每日回報率
    data['portfolio_return'].ix[0] = data['portfolio_value'].ix[0]/  10000000.0 - 1.0
    data['excess_return'] = data.portfolio_return - data.benchmark_return                 # 總頭寸每日超額回報率
    data['excess'] = data.excess_return + 1.0
    data['excess'] = data.excess.cumprod()                # 總頭寸對沖指數後的凈值序列
    data['portfolio'] = data.portfolio_return + 1.0     
    data['portfolio'] = data.portfolio.cumprod()          # 總頭寸不對沖時的凈值序列
    data['benchmark'] = data.benchmark_return + 1.0
    data['benchmark'] = data.benchmark.cumprod()          # benchmark的凈值序列
    results_corr[qt]['hedged_max_drawdown'] = max([1 - v/max(1, max(data['excess'][:i+1])) for i,v in enumerate(data['excess'])])  # 對沖後凈值最大回撤
    results_corr[qt]['hedged_volatility'] = np.std(data['excess_return'])*np.sqrt(252)
    results_corr[qt]['hedged_annualized_return'] = (data['excess'].values[-1])**(252.0/len(data['excess'])) - 1.0
    # data[['portfolio','benchmark','excess']].plot(figsize=(12,8))
    # ax.plot(data[['portfolio','benchmark','excess']], label=str(qt))
    ax1.plot(data['tradeDate'], data[['portfolio']], label=str(qt))
    ax2.plot(data['tradeDate'], data[['excess']], label=str(qt))
    


ax1.legend(loc=0, fontsize=12)
ax2.legend(loc=0, fontsize=12)
ax1.set_ylabel(u"凈值", fontproperties=font, fontsize=16)
ax2.set_ylabel(u"對沖凈值", fontproperties=font, fontsize=16)
ax1.set_title(u"量價因子 - 不同五分位數分組選股凈值走勢", fontproperties=font, fontsize=16)
ax2.set_title(u"量價因子 - 不同五分位數分組選股對沖中證500指數後凈值走勢", fontproperties=font, fontsize=16)

上面的圖片顯示「量價因子-不同五分位數分組選股」的凈值走勢，其中下面一張圖片展示出各組頭寸對沖完中證500指數後的凈值走勢，可以看到：

不同的五分位數組對應的凈值走勢順序區分度很高！

下面的表格展示出不同分位數組合的各項風險指標，每次調倉均買入量價因子最小的20%股票的策略，即最小分位數的組合(組合1)各項指標表現都非常出色：

# results 轉換為 DataFrame
import pandas
results_pd = pandas.DataFrame(results_corr).T.sort_index()


results_pd = results_pd[[u'alpha', u'beta', u'information_ratio', u'sharpe', 
                        u'annualized_return', u'max_drawdown', u'volatility', 
                         u'hedged_annualized_return', u'hedged_max_drawdown', u'hedged_volatility']]


for col in results_pd.columns:
    results_pd[col] = [np.round(x, 3) for x in results_pd[col]]
    
cols = [(u'風險指標', u'Alpha'), (u'風險指標', u'Beta'), (u'風險指標', u'信息比率'), (u'風險指標', u'夏普比率'),
        (u'純股票多頭時', u'年化收益'), (u'純股票多頭時', u'最大回撤'), (u'純股票多頭時', u'收益波動率'), 
        (u'對沖後', u'年化收益'), (u'對沖後', u'最大回撤'), 
        (u'對沖後', u'收益波動率')]
results_pd.columns = pd.MultiIndex.from_tuples(cols)
results_pd.index.name = u'五分位組別'
results_pd

5.6 量價因子疊加反轉因子選股 —— 不同五分位數組合回測走勢比較

量價因子和反轉因子分別標準化，之後直接等權相加生成疊加因子

# 可編輯部分與 strategy 模式一樣，其餘部分按本例代碼編寫即可


# -----------回測參數部分開始，可編輯------------
start = '2010-01-01'                       # 回測起始時間
end = '2016-08-01'                         # 回測結束時間
benchmark = 'ZZ500'                        # 策略參考標準
universe = set_universe('A')               # 證券池，支持股票和基金
capital_base = 10000000                    # 起始資金
freq = 'd'                                 # 策略類型，'d'表示日間策略使用日線回測
refresh_rate = 15                          # 調倉頻率，表示執行handle_data的時間間隔


corr_data = pd.read_csv('VolPriceCorr_W15_FullA.csv')     # 讀取量價因子數據
corr_data = corr_data[corr_data.columns[1:]].set_index('tradeDate')
corr_dates = corr_data.index.values


revs_data = pd.read_csv('BackwardReturns_W20_FullA.csv')     # 讀取反轉因子數據
revs_data = revs_data[revs_data.columns[1:]].set_index('tradeDate')


# ---------------回測參數部分結束----------------




# 把回測參數封裝到 SimulationParameters 中，供 quick_backtest 使用
sim_params = quartz.SimulationParameters(start, end, benchmark, universe, capital_base)
# 獲取回測行情數據
idxmap, data = quartz.get_daily_data(sim_params)
# 運行結果
results_corrPlusRevs = {}


# 調整參數(選取股票的因子五分位數)，進行快速回測
for quantile_five in range(1, 6):
    
    # ---------------策略邏輯部分----------------
    commission = Commission(0.0002,0.0002)      # 交易費率設為雙邊萬分之二


    def initialize(account):                   # 初始化虛擬賬戶狀態
        pass


    def handle_data(account):                  # 每個交易日的買入賣出指令
        pre_date = account.previous_date.strftime("%Y-%m-%d")
        if pre_date not in corr_dates:            # 只在計算過量價因子的交易日調倉
            return


        # 拿取調倉日前一個交易日的量價因子和反轉因子，並按照相應分位選擇股票
        pre_corr = corr_data.ix[pre_date]
        pre_corr = pre_corr[(pre_corr<=1.0) & (pre_corr>=-1.0)]
        pre_revs = revs_data.ix[pre_date]


        # 量價因子和反轉因子只做簡單的等權疊加
        pre_data = pd.Series(standardize(pre_corr.to_dict())) + pd.Series(standardize(pre_revs.to_dict()))
        pre_data = pre_data.dropna()


        pre_data_min = pre_data.quantile((quantile_five-1)*0.2)
        pre_data_max = pre_data.quantile(quantile_five*0.2)
        my_univ = pre_data[pre_data>=pre_data_min][pre_data<pre_data_max].index.values


        # 調倉邏輯
        univ = [x for x in my_univ if x in account.universe]


        # 不在股票池中的，清倉
        for stk in account.valid_secpos:
            if stk not in univ:
                order_to(stk, 0)
        # 在目標股票池中的，等權買入
        for stk in univ:
            order_pct_to(stk, 1.1/len(univ))
    # ---------------策略邏輯部分結束----------------


    # 把回測邏輯封裝到 TradingStrategy 中，供 quick_backtest 使用
    strategy = quartz.TradingStrategy(initialize, handle_data)
    # 回測部分
    bt, acct = quartz.quick_backtest(sim_params, strategy, idxmap, data, refresh_rate=refresh_rate, commission=commission)


    # 對於回測的結果，可以通過 perf_parse 函數計算風險指標
    perf = quartz.perf_parse(bt, acct)


    # 保存運行結果
    tmp = {}
    tmp['bt'] = bt
    tmp['annualized_return'] = perf['annualized_return']
    tmp['volatility'] = perf['volatility']
    tmp['max_drawdown'] = perf['max_drawdown']
    tmp['alpha'] = perf['alpha']
    tmp['beta'] = perf['beta']
    tmp['sharpe'] = perf['sharpe']
    tmp['information_ratio'] = perf['information_ratio']
    
    results_corrPlusRevs[quantile_five] = tmp
    print str(quantile_five),
print 'done'

1

2

3

4

5 done

fig = plt.figure(figsize=(10,8))
fig.set_tight_layout(True)
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)
ax1.grid()
ax2.grid()


for qt in results_corrPlusRevs:
    bt = results_corrPlusRevs[qt]['bt']


    data = bt[[u'tradeDate',u'portfolio_value',u'benchmark_return']]
    data['portfolio_return'] = data.portfolio_value/data.portfolio_value.shift(1) - 1.0   # 總頭寸每日回報率
    data['portfolio_return'].ix[0] = data['portfolio_value'].ix[0]/  10000000.0 - 1.0
    data['excess_return'] = data.portfolio_return - data.benchmark_return                 # 總頭寸每日超額回報率
    data['excess'] = data.excess_return + 1.0
    data['excess'] = data.excess.cumprod()                # 總頭寸對沖指數後的凈值序列
    data['portfolio'] = data.portfolio_return + 1.0     
    data['portfolio'] = data.portfolio.cumprod()          # 總頭寸不對沖時的凈值序列
    data['benchmark'] = data.benchmark_return + 1.0
    data['benchmark'] = data.benchmark.cumprod()          # benchmark的凈值序列
    results_corrPlusRevs[qt]['hedged_max_drawdown'] = max([1 - v/max(1, max(data['excess'][:i+1])) for i,v in enumerate(data['excess'])])  # 對沖後凈值最大回撤
    results_corrPlusRevs[qt]['hedged_volatility'] = np.std(data['excess_return'])*np.sqrt(252)
    results_corrPlusRevs[qt]['hedged_annualized_return'] = (data['excess'].values[-1])**(252.0/len(data['excess'])) - 1.0
    # data[['portfolio','benchmark','excess']].plot(figsize=(12,8))
    # ax.plot(data[['portfolio','benchmark','excess']], label=str(qt))
    ax1.plot(data['tradeDate'], data[['portfolio']], label=str(qt))
    ax2.plot(data['tradeDate'], data[['excess']], label=str(qt))
    


ax1.legend(loc=0, fontsize=12)
ax2.legend(loc=0, fontsize=12)
ax1.set_ylabel(u"凈值", fontproperties=font, fontsize=16)
ax2.set_ylabel(u"對沖凈值", fontproperties=font, fontsize=16)
ax1.set_title(u"量價因子與反轉因子等權疊加選股 - 不同五分位數分組選股凈值走勢", fontproperties=font, fontsize=16)
ax2.set_title(u"量價因子與反轉因子等權疊加選股 - 不同五分位數分組選股對沖中證500指數後凈值走勢", fontproperties=font, fontsize=16)

上面的圖片顯示「量價因子疊加反轉因子-不同五分位數分組選股」的凈值走勢，其中下面一張圖片展示出各組頭寸對沖完中證500指數後的凈值走勢，可以看到：

不同的五分位數組對應的凈值走勢順序區分度很高！

下面的表格展示出不同分位數組合的各項風險指標，每次調倉均買入量價因子反轉因子疊加後最小的20%股票的策略，即最小分位數的組合(組合1)各項指標表現都非常出色：

# results 轉換為 DataFrame
import pandas
results_pd = pandas.DataFrame(results_corrPlusRevs).T.sort_index()


results_pd = results_pd[[u'alpha', u'beta', u'information_ratio', u'sharpe', 
                        u'annualized_return', u'max_drawdown', u'volatility', 
                         u'hedged_annualized_return', u'hedged_max_drawdown', u'hedged_volatility']]


for col in results_pd.columns:
    results_pd[col] = [np.round(x, 3) for x in results_pd[col]]
    
cols = [(u'風險指標', u'Alpha'), (u'風險指標', u'Beta'), (u'風險指標', u'信息比率'), (u'風險指標', u'夏普比率'),
        (u'純股票多頭時', u'年化收益'), (u'純股票多頭時', u'最大回撤'), (u'純股票多頭時', u'收益波動率'), 
        (u'對沖後', u'年化收益'), (u'對沖後', u'最大回撤'), 
        (u'對沖後', u'收益波動率')]
results_pd.columns = pd.MultiIndex.from_tuples(cols)
results_pd.index.name = u'五分位組別'
results_pd

5.7 更長回測時間 —— 06年開始回測

量價因子和反轉因子分別標準化，之後直接等權相加生成疊加因子
此處選擇疊加因子最小的20%股票作為持倉組合

start = '2006-01-01'                       # 回測起始時間
end = '2016-08-01'                         # 回測結束時間
benchmark = 'ZZ500'                        # 策略參考標準
universe = set_universe('A')               # 證券池，支持股票和基金
capital_base = 2000000                     # 起始資金
freq = 'd'                                 # 策略類型，'d'表示日間策略使用日線回測
refresh_rate = 15                          # 調倉頻率，表示執行handle_data的時間間隔


corr_data = pd.read_csv('VolPriceCorr_W15_FullA.csv')     # 讀取量價因子數據
corr_data = corr_data[corr_data.columns[1:]].set_index('tradeDate')
corr_dates = corr_data.index.values


revs_data = pd.read_csv('BackwardReturns_W20_FullA.csv')     # 讀取反轉因子數據
revs_data = revs_data[revs_data.columns[1:]].set_index('tradeDate')


quantile_five = 1                           # 選取股票的因子五分位數，1表示選取股票池中因子最小的20%的股票
commission = Commission(0.0002,0.0002)     # 交易費率設為雙邊萬分之二


def initialize(account):                   # 初始化虛擬賬戶狀態
    pass


def handle_data(account):                  # 每個交易日的買入賣出指令
    pre_date = account.previous_date.strftime("%Y-%m-%d")
    if pre_date not in corr_dates:            # 只在計算過量價因子的交易日調倉
        return


    # 拿取調倉日前一個交易日的量價因子和反轉因子，並按照相應分位選擇股票
    pre_corr = corr_data.ix[pre_date]
    pre_corr = pre_corr[(pre_corr<=1.0) & (pre_corr>=-1.0)]
    pre_revs = revs_data.ix[pre_date]
    
    # 量價因子和反轉因子只做簡單的等權疊加
    pre_data = pd.Series(standardize(pre_corr.to_dict())) + pd.Series(standardize(pre_revs.to_dict()))
    pre_data = pre_data.dropna()
    
    pre_data_min = pre_data.quantile((quantile_five-1)*0.2)
    pre_data_max = pre_data.quantile(quantile_five*0.2)
    my_univ = pre_data[pre_data>=pre_data_min][pre_data<pre_data_max].index.values
    
    # 調倉邏輯
    univ = [x for x in my_univ if x in account.universe]
    
    # 不在股票池中的，清倉
    for stk in account.valid_secpos:
        if stk not in univ:
            order_to(stk, 0)
    # 在目標股票池中的，等權買入
    for stk in univ:
        order_pct_to(stk, 1.1/len(univ))

fig = plt.figure(figsize=(12,5))
fig.set_tight_layout(True)
ax1 = fig.add_subplot(111)
ax2 = ax1.twinx()
ax1.grid()


bt_quantile = bt
data = bt_quantile[[u'tradeDate',u'portfolio_value',u'benchmark_return']]
data['portfolio_return'] = data.portfolio_value/data.portfolio_value.shift(1) - 1.0
data['portfolio_return'].ix[0] = data['portfolio_value'].ix[0]/  2000000.0 - 1.0
data['excess_return'] = data.portfolio_return - data.benchmark_return
data['excess'] = data.excess_return + 1.0
data['excess'] = data.excess.cumprod()
data['portfolio'] = data.portfolio_return + 1.0
data['portfolio'] = data.portfolio.cumprod()
data['benchmark'] = data.benchmark_return + 1.0
data['benchmark'] = data.benchmark.cumprod()
# ax.plot(data[['portfolio','benchmark','excess']], label=str(qt))
ax1.plot(data['tradeDate'], data[['portfolio']], label='portfolio(left)')
ax1.plot(data['tradeDate'], data[['benchmark']], label='benchmark(left)')
ax2.plot(data['tradeDate'], data[['excess']], label='hedged(right)', color='r')


ax1.legend(loc=2)
ax2.legend(loc=0)
ax2.set_ylim(bottom=0.5, top=5)
ax1.set_ylabel(u"凈值", fontproperties=font, fontsize=16)
ax2.set_ylabel(u"對沖指數凈值", fontproperties=font, fontsize=16)
ax2.set_ylabel(u"對沖指數凈值", fontproperties=font, fontsize=16)
ax1.set_title(u"量價因子反轉因子疊加選股的前20%股票回測走勢", fontproperties=font, fontsize=16)

上圖可以看到從06年起的回測結果，展示出量價因子反轉因子疊加後的穩定的alpha輸出

我們根據量價因子疊加反轉因子選取股票組合，表現最好的組合其06年以來年化收益達到41.4%，alpha達到22.6%，beta僅為0.88，展示出穩定盈利的能力。

財經

每日債市速遞 | 現券延續強勢，國債期貨多品種創新高 - 天天要聞

每日債市速遞 | 現券延續強勢，國債期貨多品種創新高

// 債市綜述 //1、公開市場操作央行6月25日以利率招標方式開展了3000億元7天期逆回購操作，中標利率為1.8%。Wind數據顯示，當日860億元逆回購到期，因此單日凈投放2140億元。（*數據來源：Wind-央行動態PBOC）2、資金面周二央行公開市場逆回購大額投放呵護跨季，銀行間資金市場隔夜回購加權利率微降，但跨季的七天期...

06月26日 2322

攜手為全球可持續發展貢獻力量 - 天天要聞

攜手為全球可持續發展貢獻力量

來源:人民日報海外版夜幕降臨下的湖州美景。屠旭東攝（人民視覺）本次論壇還組織與會嘉賓前往浙江省安吉縣余村實地參觀考察。圖為中外嘉賓在余村了解當地從「靠山吃山」到「富山養山」的綠色發展之路。本報記者孫亞慧攝6月22日，歐美同學會第三屆國際智

06月26日 1214

驍龍8Gen3將生成式人工智慧植入智能手機，讓AI打造觸手可及 - 天天要聞

驍龍8Gen3將生成式人工智慧植入智能手機，讓AI打造觸手可及

隨著半導體技術越發成熟，憑藉處理器層級的製程、頻率、存儲等硬體提升帶來的性能升級已經不像之前那麼明顯，很難滿足用戶對產品換代升級的需求，而「AI」的加入，為智能手機打開了一個全新的世界。

06月26日 4537

1700多名各國代表，200餘場主題活動，夏季達沃斯尋找增長新前沿 - 天天要聞

1700多名各國代表，200餘場主題活動，夏季達沃斯尋找增長新前沿

來源：環球時報【環球時報綜合報道】時隔5年，世界目光再次聚焦大連。6月25日至27日，世界經濟論壇第十五屆新領軍者年會（又稱「夏季達沃斯論壇」）在大連市舉行。國務院總理李強在年會開幕式致辭中表示，當前世界百年變局加速演進，全球經濟發展面臨

06月26日 1321

神舟十八號成就不少，神十九乘組確定，指令長可能是誰？劉伯明亮相 - 天天要聞

神舟十八號成就不少，神十九乘組確定，指令長可能是誰？劉伯明亮相

神舟十八號在中國空間站之中，穩定推進任務，並且已經實現了不少的突破，然而，神舟十九號載人飛船任務航天員乘組確定，關於指令長的問題，大家也在熱議，這一次任務可能是誰呢？

06月26日 9663

精鑄成型結構件行業需求有望進一步提升 - 天天要聞

精鑄成型結構件行業需求有望進一步提升

鑄造是指將熔融的金屬澆入鑄型，凝固後獲得具有一定形狀、尺寸和性能金屬零件毛坯的成型方法。精密鑄造是用精密造型方法獲得精準尺寸鑄件工藝的總稱。相較於傳統鑄造工藝，精密鑄造產出的鑄件尺寸更加精確，適用於高端製造業領域。精密鑄造主要包括熔模鑄造、陶瓷型鑄造、金屬型鑄

06月26日 7534

A股：市場再迎黑天鵝，隨後又緊急證偽，今天會讓多頭徹底釋放嗎 - 天天要聞

A股：市場再迎黑天鵝，隨後又緊急證偽，今天會讓多頭徹底釋放嗎

周三即將開盤了，今天有一件非同尋常的事情、不得不說。一些惡意搞破壞的人，這下算是踢到硬石頭了。市場能不能出現反轉？趕緊說幾句。就在昨天收盤後，市場再傳摩根大通看空大A、認為大盤將要跌到2398點！真是說得有鼻子有眼啊，連具體點位都給出來了。

06月26日 1984

室內兒童樂園，開發多功能遊玩區域，還能提升客流量？ - 天天要聞

室內兒童樂園，開發多功能遊玩區域，還能提升客流量？

尤其是對於面積大的兒童樂園來說，遊樂設備是非常豐富的，可玩性也是非常高，如果規劃得好，必將帶來非常可觀的客群和收益，也能有效地避開同質化的競爭。

06月26日 6046

無線充移動電源主控晶元選型？不如看看這篇文章 - 天天要聞

無線充移動電源主控晶元選型？不如看看這篇文章

無線充電自從誕生以來，就極大的方便了我們的生活，隨著時間的推移無線充電技術也日趨成熟。自從iPhone12之後新增Magsafe磁吸無線充功能，直接解決了用戶使用無線充電器時需要手動對準的痛點。

06月26日 4220

日本央行為鷹派打開雙重驚喜的大門 - 天天要聞

日本央行為鷹派打開雙重驚喜的大門

日本央行發出信號，其 7 月份的量化緊縮（QT）計劃可能比市場預期的要大，甚至可能伴隨著加息，因為它正在逐步撤出仍然龐大的貨幣刺激措施。過去一周發出的鷹派暗示凸顯了央行在日元再次下跌後面臨的壓力，這可能會通過拔高進口成本，並將通脹率推高至

06月26日 1909