Naive Risk Parity for Weight Allocations

Having calculated the cluster weights in the previous step, this step calculates the final asset weights. Within the same cluster, an initial set of weights –  – is calculated using the naive risk parity allocation. In this approach, assets are allocated weights in proportion to the inverse of their respective risk; higher risk assets will receive lower portfolio weights, and lower risk assets will receive higher weights. Here the risk can be quantified in different ways – variance, CVaR, CDaR, max daily loss etc… The final weights are given by the following equation:

where,  refers to naive risk parity weights of assets in the  cluster and  is the weight of the  cluster calculated in Step-3.

Calculating the Optimal Weight Allocations

Now that we have our data loaded in, we can make use of the HierarchicalEqualRiskContribution class from PortfolioLab to construct our optimized portfolio. First we must instantiate our class and then run the allocate() method to optimize our portfolio.

Keep in mind that PortfolioLab currently supports the following metrics for calculating weight allocations:

1. ‘variance’: The variance of the clusters is used as a risk metric
2. ‘standard_deviation’: The standard deviation of the clusters is used as a risk metric
3. ‘equal_weighting’: All clusters are weighted equally with respect to the risk
4. ‘expected_shortfall’: The expected shortfall of the clusters is used as a risk metric
5. ‘conditional_drawdown_risk’: The conditional drawdown at risk of the clusters is used as a risk metric

PortfolioLab also supports all four linkage algorithms discussed in this post, though the default method is set as the Ward Linkage algorithm.

The allocate() method for the HierarchicalEqualRiskContribution object requires three parameters to run:

1. asset_names (a list of strings containing the asset names)
2. asset_prices (a dataframe of historical asset prices – daily close)
3. risk_measure (the type of risk representation to use – PortfolioLab currently supports 5 different solutions)

Note: The list of asset names is not a necessary parameter. If your input data is in the form of a dataframe, it will use the column names as the default asset names.

Users can also specify:

1. The type of linkage algorithm (shown below)
2. The confidence level used for calculating expected shortfall and conditional drawdown at risk
3. The optimal number of clusters for clustering

For simplicity, we will only be working with the three required parameters and also specifying our linkage algorithm of choice. In the example shown below, we are using an equal_weighting solution and the Ward Linkage algorithm.

herc = HierarchicalEqualRiskContribution()
herc.allocate(asset_names=stock_prices.columns, 
              asset_prices=stock_prices, 
              risk_measure="equal_weighting", 
              linkage="ward")

# plotting our optimal portfolio
herc_weights = herc.weights
y_pos = np.arange(len(herc_weights.columns))

plt.figure(figsize=(25,7))
plt.bar(list(herc_weights.columns), herc_weights.values[0])
plt.xticks(y_pos, rotation=45, size=10)
plt.xlabel('Assets', size=20)
plt.ylabel('Asset Weights', size=20)
plt.title('HERC Portfolio Weights', size=20)
plt.show()

We can observe from the above plot that many assets have been assigned equal weights. However, there is still a visible difference in the allocations. Let us see the reason behind this by visualising the tree structure.

Plotting the Clusters

The clusters can be visualised by calling the plot_clusters() method. This will plot the dendrogram tree which is the standard way of visualising hierarchical clusters.

plt.figure(figsize=(17,7))
herc.plot_clusters(assets=stock_prices.columns)
plt.title('HERC Dendrogram', size=18)
plt.xticks(rotation=45)
plt.show()

In this graph, the different colors in the x-labels represent the clusters that the stocks belong to. Through visual analysis, we can count that the optimal number of clusters determined by the Gap statistic is 6 for our dataset. We can also confirm this by printing out our optimal number of clusters through the ‘optimal_num_clusters’ attribute.

print("Optimal Number of Clusters: " + str(herc.optimal_num_clusters))

This shows why some assets received similar weights. At each point of bisection, the left and right clusters are assigned equal weights. This results in both the US and French clusters getting the same weight allocation which is then distributed equally among all assets. Hence, all the US and French assets have the same weight allocations.

Changing the optimal number of clusters can lead to very different weight allocations. You can play around with this number by passing different values through the optimal_num_clusters parameter and understanding how the weights change. For example, in the following code snippet, we look at the clusters identified by the algorithm when the optimal number of clusters is 4.

herc = HierarchicalEqualRiskContribution()
herc.allocate(asset_prices=stock_prices, 
              optimal_num_clusters=4, 
              risk_measure="equal_weighting")

# Plot clusters
plt.figure(figsize=(17,7))
herc.plot_clusters(assets=stock_prices.columns)
plt.title('HERC Dendrogram', size=18)
plt.xticks(rotation=45)
plt.show()

# Plotting optimal portfolio
herc_weights = herc.weights
y_pos = np.arange(len(herc_weights.columns))

plt.figure(figsize=(25,7))
plt.bar(list(herc_weights.columns), herc_weights.values[0])
plt.xticks(y_pos, rotation=45, size=10)
plt.xlabel('Assets', size=20)
plt.ylabel('Asset Weights', size=20)
plt.title('HERC Portfolio Weights', size=20)
plt.show()

You can observe that Gold and CRB have now been grouped into one cluster. Similarly, SP500 and Russel2000 are now in the same cluster as the other assets like FTSE and MSCI. Due to this, the weight allocations have also changed slightly, as can be observed in the following figure.