馬科維茨投資組合有效集、最優投資組合

目的

按照馬科維茨的均值方差理論，構建股票的可行集，得到有效前沿，並根據夏普比率獲得有效前沿上的最優投資組合，並按照一定的無風險資產配置進行投資，使用測試集檢驗該種方法的有效程度。

數據來源

1.使用tushare的python數據包。
2.以’300458’, ‘000948’, ‘300327’,‘300735’, '603496’五隻股票作爲測試。
3.選擇2018.1.1-2018.12.31的股票作爲訓練集，2019.1.1-2019.12.31的股票作爲測試集。

理論依據

1.收益的度量：使用日收益率作爲證券收益率的隨機變量，第t期的日收益率計算公式爲：

其中爲Pt第t期的收盤價，Pt-1爲第t-1期的收盤價。
第i種證券的平均收益率表示爲：

此處使用算術平均的方法求得平均收益率，其中蘊涵了一個假設：過去的每一期收益率發生的概率是相等的。（在無法得知過去收益率分佈的情況下可據此近似計算，或採用幾何平均的計算方法）

2.風險的度量：使用證券日收益率的波動程度表示證券的風險，即證券日收益率的標準差，第i種證券的標準差計算公式爲：

3.約束條件：構建投資組合的可行集應該滿足一下三個約束條件：

式（1）表示投資組合的收益率；

式（2）表示投資組合的風險，表示第種證券和第種證券的協方差；

式（3）表示不允許賣空的情況下，所有證券的持有比例加起來爲1.

過程

1.兩隻股票的情形

使用’300735’,和’603496’兩隻股票構建投資組合，繪製組合的“收益-風險“圖形如下：

圖1

2.五隻股票的情形
使用’300458’,‘000948’, ‘300327’, ‘300735’, '603496’五隻股票構建投資組合，繪製其可行集如下：

圖2
對比圖1和圖2可看出，當投資組合中證券數量增多時，收益率不僅沒有下降，風險還隨之減少了。

根據馬科維茨的理論，我們可以選取的投資組合位於有效前沿上。爲了進一步篩選有效前沿上的投資組合，我們採用夏普比率進行篩選，取有效前沿上的夏普比率最高的投資組合爲最佳投資組合。夏普比率計算公式如下所示：

其中爲投資組合的收益率，無風險資產的收益率，我們假設不持有無風險資產，則夏普比率變爲：

由夏普比率可繪製資本市場線（CML）如圖2紅線所示，紅點處即爲夏普比率最高的投資組合

#股票的相關係數、收益率的均值和方差

import tushare as ts
import pandas as pd
import math

def get_yield_rate(code, Start, End):   #獲取股票的單期收益率
    df = ts.get_hist_data(code, start=Start, end=End) #從接口獲取股票數據
    close = df['close'] #收盤價
    lagclose = close.shift(-1)  #讓收盤價滯後-1期
    yield_rate = (close-lagclose)/lagclose  #計算單期收益率
    yield_rate.name = 'yield_rate'  #給series設置名字
    yield_rate = pd.DataFrame(yield_rate)   #將series變爲DataFrame
    yield_rate = yield_rate.fillna(method='backfill', axis=0)  #向上填充列
    yield_rate = yield_rate.fillna(method='ffill', axis=0)     #向下填充列
    return yield_rate

def EX(yield_rate): #計算收益率的均值
    result = 0
    for i in yield_rate.index:
        result = result + yield_rate.loc[i, 'yield_rate']
    mean_value = result/len(yield_rate)
    return mean_value
def X_EX(yield_rate):   #計算X-EX
    mean_value = EX(yield_rate)
    yield_rate['mean_value'] = mean_value
    result = yield_rate['yield_rate'] - yield_rate['mean_value']
    return result
def CovXY(yield_rate1, yield_rate2):    #計算Cov(X,Y)
    x_Ex = X_EX(yield_rate1)
    y_Ey = X_EX(yield_rate2)
    result = x_Ex * y_Ey
    result.name = '(X-EX)(Y-EY)'
    result = pd.DataFrame(result)
    mean = 0
    for i in result.index:
        mean = mean + result.loc[i, '(X-EX)(Y-EY)']
    Cov = mean/len(yield_rate1)
    return Cov
def DX(yield_rate): #計算方差
    x_Ex = X_EX(yield_rate)
    x_Ex2 = x_Ex * x_Ex
    x_Ex2.name = '(X-EX)^2'
    x_Ex2 = pd.DataFrame(x_Ex2)
    result = 0
    for i in x_Ex2.index:
        result = result + x_Ex2.loc[i, '(X-EX)^2']
    Dx = result/len(yield_rate)
    return Dx
def ruo(code1, code2, Start, End):
    yield_rate1 = get_yield_rate(code1, Start, End)
    yield_rate2 = get_yield_rate(code2, Start, End)
    Cov = CovXY(yield_rate1, yield_rate2)
    Dx = DX(yield_rate1)
    Dy = DX(yield_rate2)
    R = Cov/((math.sqrt(Dx))*math.sqrt(Dy))
    return R


def get_EX(code, Start, End):   #返回均值
    yield_rate = get_yield_rate(code, Start, End)
    Ex = EX(yield_rate)
    return Ex
def get_DX(code, Start, End):   #返回方差
    yield_rate = get_yield_rate(code, Start, End)
    Dx = DX(yield_rate)
    return Dx

#股票的相關係數矩陣

import security_data
import pandas as pd

def get_ruo(list, Start, End):  #建立相關係數矩陣
    ruo_df = pd.DataFrame()
    for i in list:
        ruo_df.loc[i, ] = 0
        for j in list:
            ruo = security_data.ruo(i, j, Start, End)
            ruo_df.loc[i, j] = ruo
    return ruo_df
def get_Ex_Dx(list, Start, End):    #計算均值和方差
    Ex_Dx_df = pd.DataFrame()
    for i in list:
        Ex = security_data.get_EX(i, Start, End)
        Dx = security_data.get_DX(i, Start, End)
        Ex_Dx_df.loc[i, 'EX'] = Ex
        Ex_Dx_df.loc[i, 'DX'] =Dx
    return Ex_Dx_df


def get_correlation_matrix(Start, End, security_list):
    ruo_df = get_ruo(security_list, Start, End)
    Ex_Dx_df = get_Ex_Dx(security_list, Start, End)
    return ruo_df, Ex_Dx_df

#比較股票的相關係數

import security_data as sd
import tushare as ts
import pandas as pd

def get_code():
    code_list = []
    df = ts.get_sz50s()
    for i in df.loc[:, 'code']:
        code_list.append(i)
    return code_list
def get_ruo(Start, End):
    ruo_df = pd.DataFrame()
    code_list = get_code()
    for i in code_list:
        for j in code_list:
            ruo = sd.ruo(i, j, Start, End)
            if ruo <= 0:
                ruo_df.loc[i, j] = ruo
                print(i, j, ruo_df.loc[i, j])
    return ruo_df



Start = '2019-01-01'
End = '2019-12-24'
ruo_df = get_ruo(Start, End)
print(ruo_df)

#繪製兩兩股票的有效邊界

import correlation as cor
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import math
import tushare as ts


def effecient_set(r1, r2, D1, D2, ruo_12):  #繪製兩隻股票的有效邊界
    x = []
    y = []
    if r1 > r2:
        a = np.linspace(r2, r1, 50)
    else:
        a = np.linspace(r1, r2, 50)
    for i in a:
        x.append(i)
        y.append((math.sqrt(math.pow(((i - r2) * math.sqrt(D1) + (r1 - i) * math.sqrt(D2)), 2) +
                            2 * (i - r2) * (r1 - i) * (ruo_12 - 1) * math.sqrt(D1) * math.sqrt(D2))) \
                 / abs(r1 - r2))
    plt.plot(y, x)

def begin(Start, End):
    code_list = []
    df = ts.get_sz50s()
    for i in df.loc[:, 'code']:
        code_list.append(i)
    ruo_df, Ex_Dx_df = cor.get_correlation_matrix(Start, End, code_list)
    plt.figure()
    for i in range(len(code_list)-1):
        for j in range(len(code_list)-i-1):
            r1 = Ex_Dx_df.loc[code_list[i], 'EX']
            r2 = Ex_Dx_df.loc[code_list[i+j+1], 'EX']
            D1 = Ex_Dx_df.loc[code_list[i], 'DX']
            D2 = Ex_Dx_df.loc[code_list[i+j+1], 'DX']
            ruo_12 = ruo_df.loc[code_list[i], code_list[i+j+1]]
            effecient_set(r1, r2, D1, D2, ruo_12)
    plt.show()

Start = '2019-01-01'
End = '2019-12-24'
begin(Start, End)

#有效前沿 effciency_set

import correlation as cor
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import math
import tushare as ts
import random
import time

def get_original_weight(number):   #獲得50只股票的隨機權重
    x = np.random.rand(number)
    ratio = 1/sum(x)
    x = x * ratio
    x = list(x)
    return x

def get_rp(weight, Ex_Dx_df):   #計算總收益率
    rp = 0
    count = 0
    for i in Ex_Dx_df.index:
        rp = rp + Ex_Dx_df.loc[i, 'EX'] * weight[count]
        count = count + 1
    return rp

def get_sgm_p(weight, ruo_df, Ex_Dx_df):    #計算總風險
    sgm_p = 0
    count1 = -1
    for i in Ex_Dx_df.index:
        count1 = count1 + 1
        weight1 = weight[count1]
        sgm1 = math.sqrt(Ex_Dx_df.loc[i, 'DX'])
        count2 = -1
        for j in Ex_Dx_df.index:
            count2 = count2 + 1
            weight2 = weight[count2]
            sgm2 = math.sqrt(Ex_Dx_df.loc[j, 'DX'])
            ruo12 = ruo_df.loc[i, j]
            sgm_p = sgm_p + weight1 * weight2 * sgm1 * sgm2 * ruo12
    return math.sqrt(sgm_p)

def plot_CML(sgm_i, sharp_ratio):
    x = []
    y = []
    a = np.linspace(0, sgm_i, 50)
    for i in a:
        x.append(i)
        y.append(i * sharp_ratio)
    plt.plot(x, y, c='r')

def get_weight(Start, End, code_list, portfolio_number):
    x = []
    y = []
    sharp_ratio = 0
    ruo_df, Ex_Dx_df = cor.get_correlation_matrix(Start, End, code_list)
    for i in range(portfolio_number):
        weight = get_original_weight(len(code_list))
        rp = get_rp(weight, Ex_Dx_df)
        sgm_p = get_sgm_p(weight, ruo_df, Ex_Dx_df)
        y.append(rp)
        x.append(sgm_p)
        sharp_ratio_temp = rp / sgm_p
        if sharp_ratio_temp > sharp_ratio:
            sharp_ratio = sharp_ratio_temp
            ri = rp
            sgm_i = sgm_p
            weight_final = weight

    plt.figure()
    plt.xlim([0, 0.04])  # 設置繪圖X邊界
    plt.ylim([0, 0.004])
    plt.scatter(x, y)
    plot_CML(sgm_i, sharp_ratio)
    plt.scatter(sgm_i, ri)
    plt.show()
    print('ri:', ri, 'sgm_i:', sgm_i)
    print('weight:', weight_final)


start = time.clock()


Start = '2018-01-01'
End = '2018-12-31'
code_list = ['300458', '000948', '300327', '300735', '603496']
get_weight(Start, End, code_list, 1000000)



elapsed = (time.clock() - start)
print("Time used:",elapsed)


#ri_19 = 0.002507473327125009
#sgm_i_19 = 0.027271707336635868
#weight_19: [0.560259898457182, 0.0011445939423587268, 0.18022505839139358, 0.25549792575307023, 0.0028725234559953145]

#ri_18: 0.0007537633778995758 sgm_i_18: 0.03786930749207172
#weight_18: [0.005199184879159315, 0.01004921278630503, 0.0032974530547201057, 0.9789594590449071, 0.0024946902349084646]
list = ['600000', '600009', '600016', '600028', '600030', '600031', '600036', '600048', '600050', '600104', '600196', '600276', '600309', '600340', '600519', '600547', '600585', '600690', '600703', '600837', '600887', '601012', '601066', '601088', '601111', '601138', '601166', '601186', '601211', '601236', '601288', '601318', '601319', '601328', '601336', '601390', '601398', '601601', '601628', '601668', '601688', '601766', '601818', '601857', '601888', '601939', '601988', '601989', '603259', '603993']

#測試投資組合收益率 test_set


import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import math
import tushare as ts
import random
import time
#import efficiency_set as es
import security_data as sd


def test(code_list, Start, End):
    return_all = []
    #weight = es.get_weight(Start, End, code_list, portfolio_number)
    weight = [0.005199184879159315, 0.01004921278630503, 0.0032974530547201057, 0.9789594590449071, 0.0024946902349084646]
    for c in range(len(code_list)):
        yield_rate = sd.get_yield_rate(code_list[c], Start, End)
        return_item = 1
        for i in yield_rate.index:
            return_item = return_item * (1 + yield_rate.loc[i, 'yield_rate'])
        return_item = return_item * weight[c]
        return_all.append(return_item)
    print(return_all)
    sum = 0
    for i in return_all:
        sum = sum + i
    print('sum:', sum)


Start = '2019-01-01'
End = '2019-12-31'
code_list = ['300458', '000948', '300327', '300735', '603496']
test(code_list, Start, End)

#capm模型分析股票收益率 capm

import tushare as ts
import pandas as pd
import numpy as np
import security_data as sd
import time

def get_yield_rate(code, Start, End):   #獲取股票的單期收益率
    df = ts.get_hist_data(code, start=Start, end=End) #從接口獲取股票數據
    close = df['close'] #收盤價
    lagclose = close.shift(-1)  #讓收盤價滯後-1期
    yield_rate_series = (close-lagclose)/lagclose  #計算單期收益率
    yield_rate_series.name = 'yield_rate'  # 給series設置名字
    yield_rate_df = pd.DataFrame(yield_rate_series)  # 將series變爲DataFrame
    yield_rate_df = yield_rate_df.fillna(method='backfill', axis=0)  # 向上填充列
    yield_rate_df = yield_rate_df.fillna(method='ffill', axis = 0)  # 向下填充列
    return yield_rate_df

#以滬深300構建市場組合
def get_market_portfolio(Start, End):
    hs300_df = ts.get_hs300s()
    code_list = []  #儲存滬深300的股票代碼
    weight = [] #儲存滬深300的股票權重
    yield_rate_init = pd.DataFrame()
    for i in hs300_df.loc[:, 'code']:
        code_list.append(i)
    for i in hs300_df.loc[:, 'weight']:
        weight.append(i)
    M_yield_rate = get_yield_rate(code_list[0], Start, End)
    M_yield_rate.loc[:, 'yield_rate'] = 0   #初始化市場組合M日收益率
    for code_number in range(len(code_list)):
        yield_rate = get_yield_rate(code_list[code_number], Start, End)
        M_yield_rate = pd.merge(M_yield_rate, yield_rate, how='left', on='date')
        M_yield_rate = M_yield_rate.fillna(method='backfill', axis=0)  # 向上填充列
        M_yield_rate = M_yield_rate.fillna(method='ffill', axis=0)  # 向下填充列
        M_yield_rate = M_yield_rate.fillna(0)  # 若存在股票尚未上市的情況，用0填充所有收益率
        yield_rate_init['yield_rate'] = M_yield_rate.loc[:, 'yield_rate_x'] + weight[code_number]*M_yield_rate.loc[:, 'yield_rate_y']
        M_yield_rate = yield_rate_init
        yield_rate_init = pd.DataFrame()
    return M_yield_rate

time_start = time.clock()



Start = '2018-01-01'
End = '2018-12-31'
code = '600000'
item_yield_rate = get_yield_rate(code, Start, End)
M_yield_rate = get_market_portfolio(Start, End)
Cov = sd.CovXY(M_yield_rate, item_yield_rate)
Dm = sd.DX(M_yield_rate)
rm = sd.EX(M_yield_rate)
ri = (Cov/Dm)*rm
print(ri)



elapsed = (time.clock() - time_start)
print("Time used:", elapsed)