使用python绘制有效性前沿
有效性前沿
在无数风险资产投资组合中，只要给出既定风险水平，我们总是可以找到收益最高的一个组合。当投资者可承受的风险水平变化时，与该风险水平相对应的最优投资组合A点也一直存在，并且随着风险水平变化不断的移动。这条由不同风险水平下最优投资组合A点构成的曲线，我们称之为有效曲线，又叫有效前沿。
有效性前沿python计算
输入项：
1、资产收益率irr
2、资产相关性矩阵（协方差）：cov
3、随机种子：seed。随机生成的配置比例数量，随机种子越大计算越精确
4、目标收益：r_return。投资者期望获得的收益率。
5、无风险利率：rf。指的是10年期国债收益率或者同业拆借利率。
计算步骤：
1、首先随机生成配置比例，个数为随机种子（seed）。
对应的代码为def random_weight
2、依据随机生成的配置比例，计算目标收益（r_return）下的最优配置比例
对应的代码为def cal_random_weight
3、依据随机生成的配置比例，求有效性前沿最左侧的点，即为有效性前沿的起点。
对应的代码为 self.cal_left_point
4、依据所有的最优点，绘制有效性前沿
对应的代码为 self.cal_ff
5、计算市场组合的预期收益率，预期波动率
对应的代码为 self.cal_market_weight
6、依据无风险利率，及市场组合两点连线，求出资本市场线
python代码:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import scipy.optimize as sco
plt.rcParams['font.sans-serif'] = ['SimHei'] # 中文显示问题
plt.rcParams['axes.unicode_minus'] = False # 负数显示问题
class EffectiveForefront(object):
"""
有效性前沿类
"""
def __init__(self, irr, cov, seed, r_return, rf):
"""
有效性前沿初始化
:param irr: 收益率
:param cov: 协方差
:param seed: 随机种子数
:param r_return: 目标收益率
:param rf: 无风险利率
"""
self.irr = irr
self.rf = rf
self.cov = cov
self.seed = seed
self.r_return = r_return
self.plt = None
self.cons = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
{'type': 'eq', 'fun': lambda x: self.opt_return_vol(x)[0] - r_return}) # 输入最优解条件
self.bnds = tuple((0, 1) for x in range(len(irr))) # 输入边界条件
self.frist_weight = len(irr) * [1 / len(irr)] # 生成初始权重
def eff_handler(self):
"""
有效性前沿计算流程
:return: self.plt 有效性前沿及资本市场线
:return: opt_w 目标收益率下资产配置比例
"""
self.plt = self.random_weight()
opt_w = self.cal_random_weight()
left_point_return, left_point_vol = self.cal_left_point()
self.plt.plot(left_point_vol, left_point_return, 'y*', markersize=14)
self.cal_ff(left_point_return)
rm, vm, slope = self.cal_market_weight()
rp_cml, vp_cml = self.cal_cml(slope)
self.plt.plot(vp_cml, rp_cml, 'b--')
self.plt.plot(vm, rm, 'g*', markersize=14)
self.plt.show()
return self.plt, opt_w
def cal_cml(self, slope):
"""
计算资本市场线
:param slope: 计算资本市场线斜率
:return:
"""
rp_cml = np.linspace(0.02, 0.25)
vp_cml = (rp_cml - self.rf) / slope
return rp_cml, vp_cml
def cal_market_weight(self):
"""
市场组合的预期收益率，预期波动率
:return:
"""
# 仅设定权重之和为1的约束条件
cons_sr = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
# 求解最优权重
result_sr = sco.minimize(self.srmin_f, self.frist_weight, method='SLSQP', bounds=self.bnds, constraints=cons_sr)
slope = -result_sr['fun'] # 即资本市场线斜率
# 市场组合的预期收益率
rm = np.sum(irr * result_sr['x']) # 市场组合的收益率
# 市场组合的波动率
vm = (rm - self.rf) / slope # 市场组合的波动率
return rm, vm, slope
def cal_ff(self, left_point_return):
"""
求解有效前沿
:param left_point_return: 最左侧点收益率
:param left_point_vol: 最左侧点波动率
:return:
"""
rp_target = np.linspace(left_point_return, 0.25, 100)
# 设定波动率列表
vp_target = []
for r in rp_target:
cons_new = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
{'type': 'eq', 'fun': lambda x: self.opt_return_vol(x)[0] - r})
result_new = sco.minimize(self.vmin_f, self.frist_weight, method='SLSQP',
bounds=self.bnds, constraints=cons_new)
vp_target.append(result_new['fun'])
self.plt.plot(vp_target, rp_target, 'r-')
def cal_random_weight(self):
"""
计算最有结果权重
:return:
"""
# 求最值
result = sco.minimize(self.vmin_f, self.frist_weight, method='SLSQP', bounds=self.bnds, constraints=self.cons)
# 获取最优化结果的权重
result['x'].round(4)
w_df = pd.DataFrame()
w_df['asset'] = list(self.cov)
w_df['weight'] = result['x']
return w_df
def random_weight(self):
"""
随机生成配置比例
:return:
"""
rp_list = []
vp_list = []
# 设定投资组合各产品的均值
for i in np.arange(self.seed):
x = np.random.random(5)
weights = x / sum(x)
rp_list.append(np.sum(weights * self.irr))
vp_list.append(np.sqrt(np.dot(weights, np.dot(self.cov, weights.T))))
plt.figure(figsize=(8, 6))
plt.scatter(vp_list, rp_list)
plt.xlim(0.12, 0.28)
plt.ylim(-0.1, 0.2)
plt.xlabel('波动率')
plt.ylabel('预期收益率')
plt.grid('True')
return plt
def opt_return_vol(self, w):
"""
计算最优组合的预期收益率、收益波动率
:param w: 资产配置权重
:return:
"""
w = np.array(w)
rp_opt = np.sum(w * self.irr) # 计算最优投资组合的预期收益率
vp_opt = np.sqrt(np.dot(w, np.dot(self.cov, w.T))) # 计算最优投资组合的收益波动率
return np.array([rp_opt, vp_opt])
def vmin_f(self, w):
return self.opt_return_vol(w)[1]
def cal_left_point(self):
"""
求解有效前沿最左侧的点
:return:
"""
cons_vmin = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
result_vmin = sco.minimize(self.vmin_f, self.frist_weight, method='SLSQP',
bounds=self.bnds, constraints=cons_vmin)
# 求解投资组合的最左侧点的收益率
rp_vmin = np.sum(irr * result_vmin['x'])
# 求解投资组合的最左侧点的波动率
vp_vmin = result_vmin['fun']
return rp_vmin, vp_vmin
def srmin_f(self, w):
"""
最优投资组合夏普比率
:param w:
:return:
"""
w = np.array(w)
rp_opt = np.sum(w * irr)
vp_opt = np.sqrt(np.dot(w, np.dot(cov, w.T)))
SR = (rp_opt - self.rf) / vp_opt
return -np.array([rp_opt, vp_opt, SR])[2] # 求解最大的夏普比率就是求解负的最小值
if __name__ == '__main__':
irr = np.array([0.20, 0.08, -0.17, 0.06, -0.04])
cov = pd.DataFrame(
{'A': [0.09, 0.02, 0.02, 0.01, 0.02], 'B': [0.02, 0.12, 0.04, 0.02, 0.03], 'C': [0.02, 0.04, 0.07, 0.02, 0.03],
'D': [0.01, 0.02, 0.02, 0.04, 0.02], 'E': [0.02, 0.03, 0.03, 0.02, 0.04]})
seed = 10000
r_return = 0.1
rf = 0.02
ef = EffectiveForefront(irr, cov, seed, r_return, rf)
plt, opt_w = ef.eff_handler()
print('目标收益率下的配置比例为')
print(opt_w)
plt.show()
该算法的优点：
1、无需用到复杂的tensorflow模型，比较好调试参数
2、资产数较少的时候，计算非常准确。
缺点：
1、资产数较大的时候，要满足相同的精度，需要的随机种子数会指数级增加。在本案例中，五个资产用了一万随机种子。如果资产数增加为六，随机种子数要达到十万个。如果50个资产，随机种子数要达到10^50。不适合资产配置较多的投资组合。
2、大量随机生成的配置点离最优点非常远，浪费掉了。
附上python结果：
目标收益率下的配置比例为：
asset weight
0 A 0.310922
1 B 0.085937
2 C 0.000000
3 D 0.550663
4 E 0.052478
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
THE END
二维码