Overview

In the realm of quantitative finance, effectively allocating your investment portfolio is paramount to maximizing returns while minimizing risk. One of the most recognized methods for achieving this is through Mean-Variance Analysis, introduced by Harry Markowitz. In this blog post, we will explore the Mean-Variance Optimization (MVO) technique and provide practical examples using Python.

The Basics of Mean-Variance Optimization

Mean-Variance Optimization aims to create an efficient frontier, representing the optimal portfolios that offer the highest expected return for a defined level of risk. The key components involved in this analysis are:

Expected returns of the assets
Variance and covariance of asset returns

1. Expected Returns

Expected returns can be calculated based on historical data or analyst forecasts. For our example, we will use historical daily returns to determine the expected returns of a set of assets.

2. Variance and Covariance

The variance measures the dispersion of returns of an asset, while covariance measures how two assets move together. These statistical measures are crucial for understanding the risk associated with a portfolio.

Implementation in Python

Let's delve into the practical application of Mean-Variance Optimization using Python. We will utilize historical stock data from Yahoo Finance for our analysis. Below is the implementation:

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
 
# Define the list of tickers
assets = ['AAPL', 'GOOGL', 'MSFT', 'AMZN']
 
# Fetch historical data
prices = yf.download(assets, start='2020-01-01', end='2021-01-01')['Adj Close']
 
# Calculate daily returns
returns = prices.pct_change().dropna()
 
# Calculate expected returns and covariance matrix
expected_returns = returns.mean() * 252  # Annualize the returns
cov_matrix = returns.cov() * 252          # Annualize the covariance

3. Optimizing the Portfolio

Using the expected returns and covariance matrix, we can optimize our portfolio to find the weights that minimize risk for a given return.

from scipy.optimize import minimize
 
def portfolio_variance(weights, cov_matrix):
    return np.dot(weights.T, np.dot(cov_matrix, weights))
 
def minimize_variance(target_return):
    constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
                   {'type': 'eq', 'fun': lambda x: np.dot(expected_returns, x) - target_return})
    bounds = tuple((0, 1) for _ in range(len(assets)))
    result = minimize(portfolio_variance, 
                      len(assets)*[1./len(assets),], 
                      method='SLSQP', 
                      bounds=bounds, 
                      constraints=constraints)
    return result.x
 
# Example of finding weights for a target return of 15%
optimal_weights = minimize_variance(0.15)
print('Optimal Weights:', optimal_weights)

4. Visualizing the Efficient Frontier

Finally, we can visualize the efficient frontier to understand the risk-return trade-off better.

target_returns = np.linspace(0.05, 0.25, 50)
portfolio_risks = []
for target in target_returns:
    weights = minimize_variance(target)
    portfolio_risk = np.sqrt(portfolio_variance(weights, cov_matrix))
    portfolio_risks.append(portfolio_risk)
 
plt.figure(figsize=(10, 6))
plt.plot(portfolio_risks, target_returns, 'g--', markersize=5)
plt.title('Efficient Frontier')
plt.xlabel('Portfolio Risk (Standard Deviation)')
plt.ylabel('Expected Return')
plt.show()

Conclusion

Mean-Variance Optimization is a powerful tool for portfolio management, allowing investors to make informed decisions about asset allocation based on historical performance data. By implementing these techniques using Python, financial professionals can develop strategies that align with their risk tolerance and investment goals. This approach not only enhances understanding of portfolio dynamics but also fosters better financial decision-making.

Optimizing Portfolio Allocation with Mean-Variance Analysis