Using Custom Input with PortfolioLab

PortfolioLab also provides users with a lot of customizability when it comes to creating their optimal portfolios. Instead of providing the raw historical closing prices for assets, users can instead input asset returns, a covariance matrix of asset returns, a distance matrix, and side weights.

In this section, we will make use of the following parameters in the allocate() method to construct a custom use case:

1. asset_returns – (pd.DataFrame/numpy matrix) User supplied matrix of asset returns
2. covariance_matrix – (pd.DataFrame/numpy matrix) User supplied covariance matrix of asset returns
3. distance_matrix – (pd.DataFrame/numpy matrix) User supplied distance matrix

We will be constructing our first custom portfolio using the asset_returns and covariance_matrix parameters. To make some of the necessary calculations, we will make use of the ReturnsEstimators class provided by PortfolioLab.

# importing ReturnsEstimation class from PortfolioLab
from portfoliolab.estimators import ReturnsEstimators

# calculating our asset returns
returns = ReturnsEstimators.calculate_returns(stock_prices)

# calculating our covariance matrix
cov = returns.cov()

# constructing our first custom portfolio
hrp_custom = HierarchicalRiskParity()
hrp_custom.allocate(asset_names=stock_prices.columns,
                    asset_returns=returns,
                    covariance_matrix=cov)

# plotting our optimal portfolio
hrp_custom_weights = hrp_custom.weights
y_pos = np.arange(len(hrp_custom_weights.columns))

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

You can notice we get the same weight allocations as the ones when we instead passed raw asset prices. You can use your own pre-calculated covariance matrices and asset returns or rely on our inbuilt calculation methods for calculating weights.

Passing a Custom Distance Matrix

Note that the Hierarchical Risk Parity algorithm proposed in the original paper uses the following distance matrix:

\begin{aligned}
D = \sqrt{0.5 * (1 – ⍴)}
\end{aligned}

where refers to the correlation matrix of asset returns. Users can choose to use the HRP method as it is or can tweak its performance by passing their our own distance matrix to calculate our optimal portfolio. All other steps of the algorithm will stay the same.

from portfoliolab.estimators import RiskEstimators

# create our own distance matrix
corr = RiskEstimators.cov_to_corr(cov)
distance = np.sqrt((1 - corr).round(5) / 2)

# allocate weights
hrp_distance = HierarchicalRiskParity()
hrp_distance.allocate(asset_names=stock_prices.columns,
                      distance_matrix=distance, 
                      covariance_matrix=cov)

# plotting our optimal portfolio
hrp_distance_weights = hrp_distance.weights
y_pos = np.arange(len(hrp_distance_weights.columns))

plt.figure(figsize=(25,7))
plt.bar(list(hrp_distance_weights.columns), hrp_distance_weights.values[0])
plt.xticks(y_pos, rotation=45, size=10)
plt.xlabel('Assets', size=20)
plt.ylabel('Asset Weights', size=20)
plt.title('HRP - Custom Distance Matrix', size=20)
plt.show()

Building a Long-Short Portfolio

This is an extra feature we have added to our HRP implementation. By default, shorting of assets is not allowed in the original algorithm. But with PortfolioLab’s implementation, you can pass a side_weights parameter to short some assets in your portfolio.

In the following example, we will short the first four stocks in our dataset. All other steps remain the same – the only difference being the addition of the side_weights parameter to indicate which stocks we would like to short and long (-1 indicates shorting a stock and 1 indicates going long on a stock).

side_weights = pd.Series([1]*stock_prices.shape[1], index=stock_prices.columns)

# short the first 4 stocks
side_weights.loc[stock_prices.columns[:4]] = -1

print(side_weights)

FTSE             -1
EuroStoxx50      -1
SP500            -1
Gold             -1
French-2Y         1
French-5Y         1
French-10Y        1
French-30Y        1
US-2Y             1
US-5Y             1
US-10Y            1
US-30Y            1
Russel2000        1
EuroStox_Small    1
FTSE_Small        1
MSCI_EM           1
CRB               1
dtype: int64

# calculating optimal weights
hrp_ls = HierarchicalRiskParity()
hrp_ls.allocate(asset_names=stock_prices.columns,
                asset_prices=stock_prices,
                side_weights=side_weights)

# plotting our optimal portfolio
hrp_ls_weights = hrp_ls.weights
y_pos = np.arange(len(hrp_ls_weights.columns))

plt.figure(figsize=(25,7))
plt.bar(list(hrp_ls_weights.columns), hrp_ls_weights.values[0])
plt.xticks(y_pos, rotation=45, size=10)
plt.xlabel('Assets', size=20)
plt.ylabel('Asset Weights', size=20)
plt.title('HRP - Long/Short Portfolio', size=20)
plt.tight_layout()
plt.savefig('HRP Long-Short Portfolio')
plt.show()