And when I enter different initial values, it gives totally different results. So strange that the algorithm is sensitive to initial values.
case 1.
w0=np.ones(9)*1.0/9
Optimization terminated successfully. (Exit mode 0)
Current function value: 0.000738113620943
Iterations: 21
Function evaluations: 232
Gradient evaluations: 21
The resulting weights:
[[ 3.96638553e-02 1.31838486e-02 1.15744406e-01 2.23200288e-01
1.00733213e-01 2.98562419e-02 3.71432543e-01 1.06185604e-01
5.36184804e-19]]

case 2.
w0=[0.05217992,0.04176691,0.08060158,0.03545008,0.00784548,0.00609901,0.01657915,0.07723674,0.68224114]
Optimization terminated successfully. (Exit mode 0)
Current function value: 1.00601342965e-15
Iterations: 33
Function evaluations: 363
Gradient evaluations: 33
The resulting weights:
[[ 0.00787686 0.00260464 0.020088 0.03888814 0.01903772 0.0061617
0.05590877 0.01845764 0.83097653]]

Risk Parity/Risk Budgeting Portfolio in Python

case 2.
w0=[0.05217992,0.04176691,0.08060158,0.03545008,0.00784548,0.00609901,0.01657915,0.07723674,0.68224114]
Optimization terminated successfully. (Exit mode 0)
Current function value: 1.00601342965e-15
Iterations: 33
Function evaluations: 363
Gradient evaluations: 33
The resulting weights:
[[ 0.00787686 0.00260464 0.020088 0.03888814 0.01903772 0.0061617
0.05590877 0.01845764 0.83097653]]

Hansueli

Hi Hansueli,
Thanks for verifying, I just checked with my code, it seems the minimize function only runs 1 iteration in this case which is not enough to find an optimal solution. It’s caused by the precision goal settings for the minimize function, which is defaulted at 1e-6, and your problem start at 1e-8.

There are two ways to modify this:

Change the risk_budget_objective function by penalising the cost and it should work. (e.g. I multiplied J*1000)
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] *1000 # sum of squared error
return J

or you can change the ftol : float (Precision goal for the value of f in the stopping criterion) in the minimise function to something smaller (in this case I use 1e-12)
res= minimize(risk_budget_objective, w0, args=[V,x_t], method=’SLSQP’,constraints=cons, options={‘disp’: True, ‘ftol’: 1e-12})

By doing so, you would potentially run more iteration to get more precision. (a trade off)

any hints?

Hi Jose,
Thanks for your comment, good point. sorry about the confusion, with SKlearn, we don’t actually need to compute the covariance matrix to calculate the PCs, I was playing around with the linalg.eig(cov) and forgot to delete the stock_cov variables.

sklearn_pca = sklearnPCA(n_components=5)
pc = sklearn_pca.fit_transform(stocks_ret)

is equivalant to eigen decomposition using the numpy library

x = stocks_ret.values
xm = x – x.mean(axis=0)
cov = np.cov(xm.T) # where you have to compute the covariance matrix
evals, evecs = np.linalg.eig(cov)
xm.dot(evecs) # equivalent to sklearn_pca.fit_transform(stocks_ret)

# to get your first component (sklearn_pca.components_[0,:])
# note: evecs may not be sorted from highest evals to lowest evals, in this case the highest evals just happen to be the first evals)
evecs[:,0] # your first component (negative of sklearn_pca.components_[0,:])