Supported Portfolio Allocation Solutions

The MPT or Mean-Variance Optimisation encompasses a large variety of portfolio solutions with different objectives and constraints. The MeanVarianceOptimisation class provides some of these commonly encountered portfolio problems out-of-the-box:

Inverse Variance

For this solution, the diagonal of the covariance matrix is used for weights allocation.\begin{aligned}w_{i} = \frac{\sum^{-1}}{\sum_{j=1}^{N}(\sum_{j,j})^{-1}}\end{aligned}

where is the weight allocated to the asset in a portfolio, is the element on the main diagonal of the covariance matrix of elements in a portfolio and  is the number of elements in a portfolio.

Minimum Volatility

For this solution, the objective is to generate a portfolio with the least variance. The following optimization problem is being solved.\begin{aligned}& \underset{\mathbf{w}}{\text{minimise}} & & w^T\sum w \\ & \text{s.t.} & & \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \end{aligned}

Maximum Sharpe Ratio

For this solution, the objective is (as the name suggests) to maximise the Sharpe Ratio of your portfolio.\begin{aligned} & \underset{\mathbf{w}}{\text{maximise}} & & \frac{\mu^{T}w – R_{f}}{(w^{T}\sum w)^{1/2}} \\ & \text{s.t.} & & \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \end{aligned}

A major problem with the above formulation is that the objective function is not convex and this presents a problem for cvxpy which only accepts convex optimization problems. As a result, the problem can be transformed into an equivalent one, but with a convex quadratic objective function.\begin{aligned} & \underset{\mathbf{w}}{\text{minimise}} & & y^T\sum y \\ & \text{s.t.} & & (\mu^{T}w – R_{f})^{T}y = 1 \\ &&& \sum_{j=1}^{N}y_{j} = \kappa, \\ &&& \kappa \geq 0, \\ &&& w_{j} = \frac{y_j}{\kappa}, j=1,..,N \end{aligned}

where refer to the set of unscaled weights, is the scaling factor and the other symbols refer to their usual meanings.

Efficient Risk

For this solution, the objective is to minimise risk given a target return value by the investor. Note that the risk value for such a portfolio will not be the minimum, which is achieved by the minimum-variance solution. However, the optimiser will find the set of weights which efficiently allocate risk constrained by the provided target return, hence the name “efficient risk”.\begin{aligned} & \underset{\mathbf{w}}{\text{min}} & & w^T\sum w \\ & \text{s.t.} & & \mu^Tw = \mu_t\\ &&& \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \\ \end{aligned}

where is the target portfolio return set by the investor and the other symbols refer to their usual meanings.

Efficient Return

For this solution, the objective is to maximise the portfolio return given a target risk value by the investor. This is very similar to the efficient_risk solution. The optimiser will find the set of weights which efficiently try to maximise return constrained by the provided target risk, hence the name “efficient return”.\begin{aligned} & \underset{\mathbf{w}}{\text{max}} & & \mu^Tw \\ & \text{s.t.} & & w^T\sum w = \sigma^{2}_t\\ &&& \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \\ \end{aligned}

where  is the target portfolio risk set by the investor and the other symbols refer to their usual meanings.

Maximum Return – Minimum Volatility

This is often referred to as quadratic risk utility. The objective function consists of both the portfolio return and the risk. Thus, minimising the objective relates to minimising the risk and correspondingly maximising the return. Here, \lambda is the risk-aversion parameter which models the amount of risk the user is willing to take. A higher value means the investor will have high defense against risk at the expense of lower returns and keeping a lower value will place higher emphasis on maximising returns, neglecting the risk associated with it.\begin{aligned} & \underset{\mathbf{w}}{\text{min}} & & \lambda * w^T\sum w – \mu^Tw\\ & \text{s.t.} & & \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \\ \end{aligned}

Maximum Diversification

Maximum diversification portfolio tries to diversify the holdings across as many assets as possible. In the 2008 paper, Toward Maximum Diversification, the diversification ratio, D, of a portfolio, is defined as:\begin{aligned}D = \frac{w^{T}\sigma}{\sqrt{w^{T}\sum w}}\end{aligned}

where is the vector of volatilities and is the covariance matrix. The term in the denominator is the volatility of the portfolio and the term in the numerator is the weighted average volatility of the assets. More diversification within a portfolio decreases the denominator and leads to a higher diversification ratio. The corresponding objective function and the constraints are:\begin{aligned} & \underset{\mathbf{w}}{\text{max}} & & D\\ & \text{s.t.} & & \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \\ \end{aligned}

Maximum Decorrelation

For this solution, the objective is to minimise the correlation between the assets of a portfolio\begin{aligned} & \underset{\mathbf{w}}{\text{min}} & & w^TA w\\ & \text{s.t.} & & \sum_{j=1}^{n}w_{j} = 1 \\ &&& w_{j} \geq 0, j=1,..,N \\ \end{aligned}

where is the correlation matrix of assets. The Maximum Decorrelation portfolio is closely related to Minimum Variance and Maximum Diversification, but applies to the case where an investor believes all assets have similar returns and volatility, but heterogeneous correlations. It is a Minimum Variance optimization that is performed on the correlation matrix rather than the covariance matrix, .

Mean-Variance Optimisation with PortfolioLab

In this section, we will show users how to optimize their portfolio using several mean-variance optimisation (MVO) solutions provided through the PortfolioLab Python library. Official documentation can be found at this link. The mean-variance optimisation class from PortfolioLab utilizes techniques based on Harry Markowtiz’s methods for calculating efficient frontier solutions. Through the PortfolioLab library, users can generate optimal portfolio solutions for different objective functions, including:

# importing our required libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from portfoliolab.modern_portfolio_theory import MeanVarianceOptimisation

The Data

In this tutorial, we will be working with the historical closing prices for 17 assets. The portfolio consists of diverse set of assets ranging from commodities to bonds and each asset exhibits different risk-return characteristics. You can download the dataset CSV file from our research repository here

# preparing our data
raw_prices = pd.read_csv('../Sample-Data/assetalloc.csv', sep=';', parse_dates=True, index_col='Dates')
stock_prices = raw_prices.sort_values(by='Dates')

# Taking a quick look at our most recent 5000 data points
stock_prices.resample('M').last().plot(figsize=(17,7))
plt.ylabel('Price', size=15)
plt.xlabel('Dates', size=15)
plt.title('Stock Data Overview', size=15)
plt.show()

Calculating some Example Portfolios

We will first work through building an optimal portfolio under the inverse-variance solution string. It is one of the simplest yet powerful allocation strategy which outperforms a lot of complex optimisation objectives.

In order to calculate the asset weights of the inverse-variance portfolio, we will need to create a new MeanVarianceOptimisation object and use the allocate method. More information on inverse-variance solutions can be found here.

Note that the allocate method 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. solution (the type of solution/algorithm to use to calculate the weights)

Instead of providing historical asset prices, users can also provide the expected asset returns along with a covariance matrix of asset returns. There is also much more customizability within the allocation method in which we will explore later in this post. For simplicity, we will show users how to create an optimal portfolio under the Inverse Variance portfolio solution. If you wish to create a different optimized portfolio, all that must be changed is the ‘solution’ parameter string. The corresponding solution strings and portfolio solutions can be found at the official documentation.

# creating our portfolio weights under the correct objective function
mvoIV = MeanVarianceOptimisation()
mvoIV.allocate(asset_names=stock_prices.columns,
               asset_prices=stock_prices,
               solution='inverse_variance')

# plotting our optimal portfolio
IV_weights = mvoIV.weights
y_pos = np.arange(len(IV_weights.columns))

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

Let us create another portfolio – the maximum Sharpe Ratio portfolio. This is sometimes also referred to as the tangency portfolio.

# creating our portfolio weights under the correct objective function
mvoMS = MeanVarianceOptimisation()
mvoMS.allocate(asset_names=stock_prices.columns,
                asset_prices=stock_prices,
                solution='max_sharpe')

# plotting our optimal portfolio
MS_weights = mvoMS.weights
y_pos = np.arange(len(MS_weights.columns))

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

Custom Input from Users

While PortfolioLab provides many of the required calculations when constucting optimal portfolios, users also have the choice to provide custom input for their calculations. Instead of providing the raw historical closing prices for their assets, users can input a covariance matrix of asset returns and the expected asset returns to calculate their optimal portfolio. If you would like to learn more about the customizbility within PortfolioLab’s MVO implementation, please refer to the official documentation.

The following parameters in the allocate() method are utilized in order to do so:

1. ‘covariance_matrix’: (pd.DataFrame/NumPy matrix) A covariance matrix of asset returns
2. ‘expected_asset_returns: (list) A list of mean asset returns

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 in order to calculate our covariance matrix
returns = ReturnsEstimators.calculate_returns(stock_prices)

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

We also calculate the expected returns i.e. mean asset returns

# Calculating our mean asset returns
mean_returns = ReturnsEstimators.calculate_mean_historical_returns(stock_prices)
mean_returns

Having calculated all the required input matrices, we create an efficient risk portfolio using these custom inputs. An efficient risk portfolio tries to efficiently manage risk for a given target return by the investor. Here we are specifying a target return of 0.2

# From here, we can now create our portfolio
mvo_custom = MeanVarianceOptimisation()
mvo_custom.allocate(asset_names=stock_prices.columns,
                    expected_asset_returns=mean_returns,
                    covariance_matrix=cov,
                    target_returns=0.2,
                    solution='efficient_risk')

# plotting our optimal portfolio
custom_weights = mvo_custom.weights
y_pos = np.arange(len(custom_weights.columns))

plt.figure(figsize=(25,7))
plt.bar(list(custom_weights.columns), custom_weights.values[0])
plt.xticks(y_pos, rotation=45, size=20)
plt.xlabel('Assets', size=20)
plt.ylabel('Asset Weights', size=20)
plt.title('Custom MVO Portfolio - Efficient Risk Solution', size=20)
plt.show()

Additionally, a lot of investors and portfolio managers like to place specific weight bounds on some assets in their portfolio. For instance, in the above portfolio, one may want to limit the weights assigned to French-2Y and US-30Y. Let us try to decrease their allocations and diversify the portfolio a little. We place a maximum bound on their weights and a minimum bound on French-5Y and French-10Y. Note that the indexing starts from 0.

mvo_custom_bounds = MeanVarianceOptimisation()
mvo_custom_bounds.allocate(asset_prices=stock_prices,
                           weight_bounds=["weights[4] <= 0.2", "weights[11] <= 0.1", "weights[5] >= 0.05", "weights[6] >= 0.05"],
                           solution='efficient_risk')

# plotting our optimal portfolio
custom_bounds_weights = mvo_custom_bounds.weights
y_pos = np.arange(len(custom_bounds_weights.columns))

plt.figure(figsize=(25,7))
plt.bar(list(custom_bounds_weights.columns), custom_bounds_weights.values[0])
plt.xticks(y_pos, rotation=45, size=20)
plt.xlabel('Assets', size=20)
plt.ylabel('Asset Weights', size=20)
plt.title('Custom MVO Portfolio - Efficient Risk Solution with Weight Bounds', size=20)
plt.tight_layout()
plt.savefig("mvo_custom_weight_bounds.png", dpi=150)
plt.show()

You can see how the weight bounds help us achieve a more diversified portfolio and prevent the weights from becoming too concentrated on only some assets.