In this tutorial, we will show you how to build optimized portfolios in Python using the PyPortfolioOpt library. In another tutorial, we have shown you how to build diversified portfolios from scratch using Python. For this task, we will build the optimized portfolios based on the Efficient Frontier. We will build one portfolio that maximized the Sharpe Ratio and another that minimizes the volatility. The chart below shows the location of the portfolios that we mentioned above on the efficient frontier.

The flowchart below represents the different functionalities of the PyPorfolioOpt library.

## Load the Required Libraries

For this tutorial, we will need to use some libraries. If you want to follow along with the reproducible examples, you should have installed these libraries. Let’s load them.

import pandas as pd import requests import time from pypfopt import risk_models from pypfopt.risk_models import CovarianceShrinkage from pypfopt import expected_returns from pypfopt.efficient_frontier import EfficientFrontier

## Get the Data

We will consider the daily prices of the cryptocurrencies in USD ($) since “**2020-01-01**” which means 2 years and 4 months of data (today is: 2022-04-01). We will use the Kraken API and all the available cryptocurrencies. Note that we will remove any cryptocurrency that has missing data during this time period. We will keep the closing daily prices. Note that the date is in Unix timestamp.

# get the starting date in unix timestamp date_time = '2020-01-01 00:00:00' pattern = '%Y-%m-%d %H:%M:%S' epoch = int(time.mktime(time.strptime(date_time, pattern))) # get all the cryptocurrencies in USD resp = requests.get('https://api.kraken.com/0/public/AssetPairs') resp = resp.json() # Keep all the cryptos over USD dollar_pairs = [] for pair in resp['result']: if pair.endswith('USD'): dollar_pairs.append(pair) # get all the unixtimestamps tmp_url = f'https://api.kraken.com/0/public/OHLC?pair=XXBTZUSD&since={epoch}&interval=1440'.format(epoch) resp = requests.get(tmp_url) dummy_df = pd.DataFrame(resp.json()['result']['XXBTZUSD'])[[0]] # create a pandas data frame and add the closing prices of each asset df = pd.DataFrame(index=dummy_df[0]) for pair in dollar_pairs: tmp_url = f'https://api.kraken.com/0/public/OHLC?pair={pair}&since={epoch}&interval=1440'.format(pair,epoch) resp = requests.get(tmp_url) tmp_df = pd.DataFrame(resp.json()['result'][pair])[[0,4]] tmp_df.columns = ['unixtimestap', pair] tmp_df[pair] = tmp_df[pair].astype(float) df = pd.concat([df,tmp_df.set_index('unixtimestap')], axis=1) # remove the last row since it is not a full day df = df[:-1].copy() # drop the columns with a least one NA df.dropna(axis='columns', inplace=True) # remove the other fiat currencies liker EURO and the stable coins like Tether and DAI df.drop(columns=['USDCUSD', 'USDTZUSD', 'DAIUSD', 'ZGBPZUSD','ZEURZUSD', 'PAXGUSD'], axis=1, inplace=True)

We ended up with 29 cryptocurrencies of 720 daily closing prices.

## Get the Efficient Frontier

For the efficient frontier, we will need to pass the expected returns `mu`

and the variance-covariance matrix `Sigma`

. There are many variations of the mu and Sigma respectively. For example, for mu we have the following options:

- mean_historical_return
- ema_historical_return
- returns_from_prices

and for Sigma we have the following options:

`sample_cov`

`semicovariance`

`exp_cov`

`ledoit_wolf`

`ledoit_wolf_constant_variance`

`ledoit_wolf_single_factor`

`ledoit_wolf_constant_correlation`

`oracle_approximating`

In this case, we will work with the exponential mean and variance in order to give more weight to the most recent observations. Feel free to play with the other options too.

# calculate the mean and variance mu = expected_returns.ema_historical_return(df, frequency=365) Sigma = risk_models.exp_cov(df, frequency=365)

From the EMA returns, we can see that the Wave, the DogeCoin the Cosmos and the ETC have performed extremely well compared to the rest cryptocurrencies.

# get the efficient frontier ef = EfficientFrontier(mu, Sigma)

## Maximum Sharpe Ratio Portfolio

We can get the weights of the optimum portfolio in terms of Sharpe Ratio as follows. Note that we have set the risk-free interest rate to be 0. If you would like to set another value, you can pass it to the `max_sharpe()`

function.

sharpe_weights = ef.max_sharpe() (ef.clean_weights())

The optimum portfolio that maximizes the Sharpe Ratio is to **invest in Wave (70%) and in DogeCoin (30%)**. We can also get the performance of the portfolio.

ef.portfolio_performance(verbose=True)

## Minimum Variance Portfolio

We can also get the weights of the portfolio that minimizes the risk and it is on the Efficient Frontier.

ef = EfficientFrontier(mu, Sigma) min_vol_weights = ef.min_volatility() (ef.clean_weights())

According to our data, the weights of the lowest variance portfolio are **50% BTC, 35% TRX, 10% REP and 5% MLN**.

The performance of this portfolio is:

ef.portfolio_performance(verbose=True)

## The Takeaways

Our goal was to show you how to apply the Markowitz portfolio theory to cryptocurrencies using Python. Personally, I believe that we didn’t get reliable results because:

- Many good cryptocurrencies were not included because we did not have 2.5 years data. Some examples are the DOT, AAVE, LUNA, AVAX and so on.
- There are some alt-coins that can have extremely high returns and this affects our data

However, I believe that you can apply these techniques by taking into consideration a shorter time period and by focusing on specific cryptocurrencies.

## Want some Free Cryptos?

You can get **$25** in Bitcoin by investing $100 in Nexo