0. Backgound

有效前沿是在给定投资范围，return-risk约束条件下同等风险情况下收益最大的的资产配置集合。
说白了，就是给一堆可投资券，求各种配比的组合下，相同return方差最小（或者相同方差return最大）的点集合。
更形象来说，就是在return-σ象限把投资组合的各种配比可能性都点在图上，左上方的edge就是这个有效前沿。

1. 导入模块

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

#用于正常显示中文标签
plt.rcParams["font.sans-serif"]=["SimHei"]
plt.rcParams["axes.unicode_minus"] = False
# 启动windpy接口
from WindPy import w
w.start()

2. 准备函数

def risk_free_rate(date):
    r = w.wsd("SHIBOR6M.IR", "close,settle", date, date, "")
    if r.ErrorCode !=0:
        print("WIND数据读取有误，ErrorCode=" + str(r.ErrorCode))
        sys.exit()
    r = r.Data[0][0]/100
    return r

def stock_close_data(stock_list,start_date,end_date):
    stock_input = ",".join(stock_list)
    data = w.wsd(stock_input, "close",start_date , end_date, "PriceAdj=F") #使用前复权处理
    if data.ErrorCode!=0:
        print("WIND数据读取有误，ErrorCode="+r.ErrorCode)
        sys.exit()
        print(data)
    data = pd.DataFrame(data.Data,index = stock_list,columns = data.Times).T
    return data

def generate_random_weight(num, stock_list):
    weight = np.random.uniform(1,100,size = [num,len(stock_list)])
    
    for i in range(0, num):
        a_sum = 0.0
        for j in range(0,len(stock_list)):
            a_sum = a_sum +weight[i][j]
        for k in range(0,len(stock_list)):
            weight[i][k]=round(float(weight[i][k]/a_sum),4)                            
    print("随机权重Ready！")
    return weight

def portfolio_return(weight, mean, num, stock_list):
    portfolio_re = np.random.uniform(0,0,size =num)
    for i in range(0,num):
        for j in range(0,len(stock_list)):
            portfolio_re[i] = portfolio_re[i] + weight[i][j] * mean[j]
    print("收益计算OKK！")
    return portfolio_re

def portfolio_standard_deviation(weight, cov_matrix, num, stock_list):
    portfolio_standard_dev = np.random.uniform(0,0,size=num)
    for i in range(0, num):
        var = np.dot(weight[i],cov_matrix)
        var = np.dot(var,weight[i].T)  # 组合方差
        portfolio_standard_dev[i] = np.sqrt(var)
    print("标准差搞定！")
    return portfolio_standard_dev

def max_portfolio_return(p_return):
    '''收益最大组合'''
    p_return_list = list(p_return)
    p_return_max = max(p_return_list)
    p_return_max_index = p_return_list.index(p_return_max)
    return p_return_max_index, p_return_max

def min_portfolio_std(p_std):
    '''方差最小组合'''
    p_std_list = list(p_std)
    p_std_min = min(p_std_list)
    p_std_min_index = p_std_list.index(p_std_min)
    return p_std_min_index, p_std_min

def compute_sharp_ratio(returns, s_deviation, rfr):
    '''
    计算各组合的sharp_r = sharp_ratio_list, max_spr, max_spr_index
    '''
    sharp_ratio = np.random.uniform(0,0,len(returns))
    for i in range(0,len(sharp_ratio)):
        sharp_ratio[i] = (returns[i] - rfr) / s_deviation[i]
    sharp_ratio_list = list(sharp_ratio)
    
    return sharp_ratio, max(sharp_ratio_list), sharp_ratio_list.index(max(sharp_ratio_list))

def show_frontier(returns, s_deviation, max_return, min_std,sharp_r):
    # 设置坐标轴的lable
    plt.xlabel(" σ ")
    plt.ylabel(" return % ")
    colors1 = "#0080FF"    #组合点的颜色
    colors2 = "#CC0000"    #最大收益点
    colors3 = "#669900"    #最小方差点
    colors4 = "#FE9A2E"    #最大sharpRatio
    s = np.pi * 0.4 ** 2   # 普通组合点的大小
    s1 = np.pi * 2 ** 2    # 最大瘦一点、最小方差点大小
    
    plt.title("马科维茨有效前沿")   
    plt.scatter(s_deviation, returns, c=colors1, alpha=0.2,s=s)
    plt.scatter(s_deviation[max_return[0]],max_return[1],c=colors2,alpha=0.8, s=s1, label = "最大收益")
    plt.scatter(min_std[1],returns[min_std[0]],c=colors3,alpha=0.8,s=s1, label = "最小方差")
    plt.scatter(s_deviation[sharp_r[2]],returns[sharp_r[2]],c=colors4,alpha = 0.8,s=s1, label = "最大SharpRatio")
    
    plt.legend(loc = "best")
    plt.plot()
    plt.show()
    return

3. 取数、作图

stock_list = ["600159.SH","000858.SZ","000615.SZ","300015.SZ","601318.SH"]
start_date = "2019-01-01"
end_date = "2020-04-23"
num = 50000   #生成多少个组合

# 计算一下无风险收益率
r = risk_free_rate("2020-04-23")

data = stock_close_data(stock_list,start_date,end_date)
daily_return = np.log(data/data.shift(1))
# daily_return = daily_return.shift(1)
mean = daily_return.mean() * 252 #年化
cov_matrix = daily_return.cov() * 252
weight = generate_random_weight(num, stock_list)
ptf_return = portfolio_return(weight,mean,num,stock_list)
ptf_std = portfolio_standard_deviation(weight, cov_matrix, num, stock_list)
# 最大收益率和最小方差
max_return= max_portfolio_return(ptf_return)
min_std=min_portfolio_std(ptf_std)
# 找Sharp Ratio
# sharp_r = sharp_ratio_list, max_spr, max_spr_index
sharp_r = compute_sharp_ratio(ptf_return, ptf_std, r)

show_frontier(ptf_return,ptf_std,max_return,min_std,sharp_r)