In addition to minimum variance, and risk parity/budgeting, maximum diversivication is also another well known risk based asset allocation technique.

Let

  be a vector of all asset weights
and

 be a vector of all asset volatility (square root of the diagnal of V, the covariance matrix)

Then define diversification ratio as

It is basically the weighted average of volatility devided by the portfolio volatility

An interesting hypothesis/observation: if the assest volatility is positively correlated with asset expected excess return, then maximizing diversification ratio is related to maximizing ex ante Sharpe ratio of the portfolio.

For example, Using CAPM

and beta is

Obviously  is not a constant because correlation of stock return to market return varies across assets/stocks. But Beta is indeed positively correlated with asset volatility, thus the expected excess return is positively correlated with asset volatility under the CAPM.

Python implementation using scipy optimize

def calc_diversification_ratio(w, V):
    # average weighted vol
    w_vol = np.dot(np.sqrt(np.diag(V)), w.T)
    # portfolio vol
    port_vol = np.sqrt(calculate_portfolio_var(w, V))
    diversification_ratio = w_vol/port_vol
    # return negative for minimization problem (maximize = minimize -)
    return -diversification_ratio


#####################################################################
#               PORTFOLIO Optimization functions                    #
#####################################################################

def max_div_port(w0, V, bnd=None, long_only=True):
    # w0: initial weight
    # V: covariance matrix
    # bnd: individual position limit
    # long only: long only constraint
    cons = ({'type': 'eq', 'fun': total_weight_constraint},)
    if long_only: # add in long only constraint
        cons = cons + ({'type': 'ineq', 'fun':  long_only_constraint},)
    res = minimize(calc_diversification_ratio, w0, bounds=bnd, args=V, method='SLSQP', constraints=cons)
    return res

Risk Parity Portfolio is an investment allocation strategy which focuses on the allocation of risk, rather than the allocation of capital. For example, a typical 40% bond 60% equity portfolio has a significant risk in equity. A risk parity (equal risk) portfolio is a portfolio, which individual assets, in this case equity and bond, have equal risk contribution to the portfolio risk. The allocation strategy has gained popularity in the last decades, the idea of asset allocation base on risk has been used in many strategies such as managed futures strategy, and the famous Bridgewater all weather fund. Some people argue that this allocation strategy provides better risk adjusted return than capital based allocation strategies. (I will do some simple backtest in the future)

I will go over a very basic example of what risk parity is and how to construct a simple risk parity (equal risk) portfolio  and extend it to a risk budgeting portfolio (target risk allocation)

First define the marginal risk contribution as:

Then, the risk contribution of asset j to the total portfolio is:

Risk Parity portfolio is a portfolio which RC are equal across all individual assets

For example, going back to the previous example and assume we have an equal weight portfolio of four assets with weight = 25% each, it’s RC (in total portfolio risk %) is:

To compute the weight of a risk parity portfolio, we could use the optimise function from python

Let the sum of squared error of a portfolio assets RC  be:ThenIn python

from __future__ import division
import numpy as np
from matplotlib import pyplot as plt
from numpy.linalg import inv,pinv
from scipy.optimize import minimize

 # risk budgeting optimization
def calculate_portfolio_var(w,V):
    # function that calculates portfolio risk
    w = np.matrix(w)
    return (w*V*w.T)[0,0]

def calculate_risk_contribution(w,V):
    # function that calculates asset contribution to total risk
    w = np.matrix(w)
    sigma = np.sqrt(calculate_portfolio_var(w,V))
    # Marginal Risk Contribution
    MRC = V*w.T
    # Risk Contribution
    RC = np.multiply(MRC,w.T)/sigma
    return RC

def risk_budget_objective(x,pars):
    # calculate portfolio risk
    V = pars[0]# covariance table
    x_t = pars[1] # risk target in percent of portfolio risk
    sig_p =  np.sqrt(calculate_portfolio_var(x,V)) # portfolio sigma
    risk_target = np.asmatrix(np.multiply(sig_p,x_t))
    asset_RC = calculate_risk_contribution(x,V)
    J = sum(np.square(asset_RC-risk_target.T))[0,0] # sum of squared error
    return J

def total_weight_constraint(x):
    return np.sum(x)-1.0

def long_only_constraint(x):
    return x

x_t = [0.25, 0.25, 0.25, 0.25] # your risk budget percent of total portfolio risk (equal risk)
cons = ({'type': 'eq', 'fun': total_weight_constraint},
{'type': 'ineq', 'fun': long_only_constraint})
res= minimize(risk_budget_objective, w0, args=[V,x_t], method='SLSQP',constraints=cons, options={'disp': True})
w_rb = np.asmatrix(res.x)

Then the weights in the risk parity portfolio are

[ 0.19543974,  0.21521557,  0.16260951,  0.42673519]

and the risk contributions to the total portfolio are

The problem is actually set up to  calculate any risk budget allocation since it actually uses you can set up your target risk allocation for each asset then minimise the objective function of squared error

e.g.

x_t = [0.3, 0.3, 0.1, 0.3] # your risk budget percent of total portfolio risk

The weights are
[ 0.22837243, 0.25116466, 0.08875776, 0.43170515]

individual asset RC percentages are:

The following example uses the same data from the previous posts.
In the real world, sometimes you cannot short an asset easily, so I added another constraint to the optimisation to ensure all weights are positive.

Run the same code but add bounds for the optimiser

# positive weight portfolio
bnd=[(0, 1),(0, 1),(0, 1),(0, 1)] # only positive weights
res2= minimize(calculate_portfolio_var, w0, args=V, bounds = bnd, method='SLSQP',constraints=cons)
w_g_long_only = res2.x

The weights of unconstrained MVP

The weights of long only MVP, Asset 1 has a slightly positive weight

And it’s easy to limit weights on individual holdings
E.g. an asset cannot be more than  50% of the portfolio

bnd=[(0, .5),(0, .5),(0, .5),(0, .5)]

The following code uses the scipy optimize to solve for the minimum variance portfolio. It uses the same sample in the other post “Modern portfolio theory in python”

from __future__ import division
import numpy as np
from matplotlib import pyplot as plt
from numpy.linalg import inv,pinv
from scipy.optimize import minimize

# USER INPUT
V = np.matrix('123 37.5 70 30; 37.5 122 72 13.5; 70 72 321 -32; 30 13.5 -32 52')/100  # covariance
R = np.matrix('14; 12; 15; 7')/100
rf = 3/100

w0= [0.25,0.25,0.25,0.25]
# min var optimization
def calculate_portfolio_var(w,V):
    w = np.matrix(w)
    return (w*V*w.T)[0,0]

# unconstrained portfolio (only sum(w) = 1 )
cons = ({'type': 'eq', 'fun': lambda x:  np.sum(x)-1.0})
res= minimize(calculate_portfolio_var, w0, args=V, method='SLSQP',constraints=cons)
w_g = res.x
mu_g = w_g*R
var_g = np.dot(w_g*V,w_g)

I implemented some numerical calculations used in efficient frontier, minimum variance portfolio, and tangent portfolio with a very simple example.

The variables and calculation are from APPENDIX OF “A CRITIQUE OF THE ASSET PRICING THEORY’S TESTS” ROLL (1977)

Let return and covariance matrix be
 
and let I be a 4 by 1 vector of all ones

From definition A.9 in ROLL(1977)

The Efficient Frontier:

The Global Minimum Variance Portfolio properties are defined as follows:

The Tangent Portfolio
  then we can use Corollary 1 and
 with , and the weight of the tangent portfolio  is

from __future__ import division
from matplotlib import pyplot as plt
from numpy.linalg import inv,pinv

""" USING THE MATRIX NOTATION DEFINED IN
APPENDIX OF "A CRITIQUE OF THE ASSET PRICING THEORY'S TESTS" ROLL (1977) 
"""

# USER INPUT
V = np.matrix('123 37.5 70 30; 37.5 122 72 13.5; 70 72 321 -32; 30 13.5 -32 52')/100  # covariance
R = np.matrix('14; 12; 15; 7')/100 # return
rf = 3/100 # risk free

# define the 
I = np.ones((len(R),1))
SD = np.sqrt(np.diag(V))

# Variable for Efficient frontier (SEE (A.9) ROLL 1977 page 160)
C = I.T*pinv(V)*I 
B = R.T*pinv(V)*I
A = R.T*pinv(V)*R
D = A*C-B**2

########################################################
#EFFICIENT FRONTIER
########################################################
# Efficient Frontier Range for Return
mu = np.arange(-max(R),max(R)*5,max(R)/100);
 
# Plot Efficient Frontier
minvar = (A-2*B*mu+(C*mu**2))/D;
minstd = np.sqrt(minvar)[0];
minstd = np.squeeze(np.asarray(minstd))
plt.plot(minstd,mu,SD,R,'*')
plt.title('Efficient Frontier with Individual Securities',fontsize=20)
plt.ylabel('Expected Return (%)', fontsize=14)
plt.xlabel('Standard Deviation (%)', fontsize=14)
plt.show()


########################################################
#MVP
########################################################
# Mean and Variance of Global Minimum Variance Portfolio
mu_g = B/C
var_g = 1/C
std_g = np.sqrt(var_g)

# Minimum Variance Portfolio Weights
w_g = (pinv(V)*I)/C

# Plot Efficient Frontier
minvar = (A-2*B*mu+(C*mu**2))/D;
minstd = np.sqrt(minvar)[0];
minstd = np.squeeze(np.asarray(minstd))
plt.plot(minstd,mu,SD,R,'*',std_g,mu_g,'ro')
plt.title('Efficient Frontier with Individual Securities',fontsize=20)
plt.ylabel('Expected Return (%)', fontsize=14)
plt.xlabel('Standard Deviation (%)', fontsize=14)
plt.show()


########################################################
#TANGENT PORTFOLIO
########################################################
# Expected Return of Tangency Portfolio
mu_tan = (B*rf-A)/(C*rf-B);
 
# Variance and Standard Deviation of Tangency Portfolio
vartan = (A-2*rf*B + (rf**2*C))/((B-C*rf)**2);
stdtan = np.sqrt(vartan);
 
# Weights for Tangency Portfolio
w_tan = (pinv(V)*(R - rf*I))/(B-C*rf)

# Tangency Line
m_tan = mu[mu >= rf];
minvar_rf = (m_tan-rf)**2/(A-2*rf*B+C*rf**2);
minstd_rf = np.sqrt(minvar_rf);
minstd_rf = np.squeeze(np.asarray(minstd_rf))

# Plot with tangency portfolio
plt.plot(minstd,mu,SD,R,'*',minstd_rf,m_tan,'r',std_g,mu_g,'bo',stdtan,mu_tan,'go')
plt.title('Efficient Frontier with Individual Securities',fontsize=18)
plt.ylabel('Expected Return (%)', fontsize=12)
plt.xlabel('Standard Deviation (%)', fontsize=12)
plt.text(0.5,rf,'rf',fontsize=12);
plt.text(0.5+std_g,mu_g,'Global Minimum Variance Portfolio',fontsize=12);
plt.text(0.5+stdtan,mu_tan,'Tangency Portfolio',fontsize=12);
plt.show()