Adaptive Asset Allocation

1from AlgorithmImports import *
2# The investment universe consists of 10 ETFs which are proxy for the main asset classes (US Stocks, European Stocks, Japanese Stocks, EM Stocks, US REITs, 
3# International REITs, US Intermediate Treasuries, US Long-term Treasuries, Commodities, and Gold). Each week, the asset classes are sorted based on their 
4# 6-month momentum. Only the top 5 assets are then used in the next step, when the investor uses the minimum variance calculation to compute the weights 
5# for each asset class for the next week. 60-day historical volatilities and correlations are used in the minimum variance computation. The overall portfolio
6# volatility prediction is then estimated (based on the weights from the min. variance algorithm and on historical volatilities and correlations) 
7# and the portfolio is rescaled to target 8% volatility. These steps are performed every week and the portfolio is rebalanced accordingly.
8import pandas as pd
9import numpy as np
10from scipy.optimize import minimize
11class AdaptiveAssetAllocation(QCAlgorithm):
12def Initialize(self):
13self.SetStartDate(2008, 1, 1)
14self.SetCash(100000)
15self.symbols = ['SPY', 'VGK', 'EWJ', 'EEM', 'VNQ', 'RWX', 'IEI', 'IEF', 'DBC', 'GLD']
16self.period = 6 * 21
17self.data = {}
18
19for symbol in self.symbols:
20    self.AddEquity(symbol, Resolution.Daily)
21    self.data[symbol] = SymbolData(self.period)
22self.Schedule.On(self.DateRules.WeekStart(self.symbols[0]), self.TimeRules.AfterMarketOpen(self.symbols[0]), self.Rebalance)
23def OnData(self, data):
24for symbol in self.data:
25    symbol_obj = self.Symbol(symbol)
26    if symbol_obj in data and data[symbol_obj]:
27        self.data[symbol].update(data[symbol_obj].Value)
28
29def Rebalance(self):
30self.Liquidate()
31
32ret_data = { x : self.data[x].performance() for x in self.symbols if self.data[x].is_ready()}
33# Performance sorting.
34if len(ret_data) == 0: return
35sorted_by_ret = sorted(ret_data.items(), key = lambda x: x[1], reverse = True)
36top_symbols = [x[0] for x in sorted_by_ret[:5]]
37
38# Optimalization
39data = {}
40for symbol in top_symbols:
41    closes = [x for x in self.data[symbol].price]
42    data[symbol] = closes[:60]
43    
44df_price = pd.DataFrame(data, columns=data.keys()) 
45daily_return = (df_price / df_price.shift(1)).dropna()
46a = PortfolioOptimization(daily_return, 0, len(data))
47opt_weight = a.opt_portfolio()
48
49for i in range(len(data)):
50    # Weight is higher than minumum QC supported weight.
51    if opt_weight[i] > 0.001:
52        self.SetHoldings(df_price.columns[i], opt_weight[i])
53
54class PortfolioOptimization(object):
55def __init__(self, df_return, risk_free_rate, num_assets):
56self.daily_return = df_return
57self.risk_free_rate = risk_free_rate
58self.n = num_assets # numbers of risk assets in portfolio
59self.target_vol = 0.08
60def annual_port_return(self, weights):
61# calculate the annual return of portfolio
62return np.sum(self.daily_return.mean() * weights) * 252
63def annual_port_vol(self, weights):
64# calculate the annual volatility of portfolio
65return np.sqrt(np.dot(weights.T, np.dot(self.daily_return.cov() * 252, weights)))
66def min_func(self, weights):
67# method 1: maximize sharp ratio
68#return - self.annual_port_return(weights) / self.annual_port_vol(weights)
69
70# method 2: maximize the return with target volatility
71# return - self.annual_port_return(weights) / self.target_vol
72# method 3: minimize variance with target volatility
73return (1 / self.annual_port_vol(weights)) / self.target_vol
74def opt_portfolio(self):
75# maximize the sharpe ratio to find the optimal weights
76cons = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
77bnds = tuple((0, 1) for x in range(2)) + tuple((0, 0.25) for x in range(self.n - 2))
78opt = minimize(self.min_func,                               # object function
79               np.array(self.n * [1. / self.n]),            # initial value
80               method='SLSQP',                              # optimization method
81               bounds=bnds,                                 # bounds for variables 
82               constraints=cons)                            # constraint conditions
83              
84opt_weights = opt['x']
85 
86return opt_weights
87class SymbolData():
88def __init__(self, period):
89self.price = RollingWindow[float](period)
90
91def update(self, value):
92self.price.Add(value)
93
94def is_ready(self) -> bool:
95return self.price.IsReady
96
97def performance(self, values_to_skip = 0) -> float:
98closes = [x for x in self.price][values_to_skip:]
99return (closes[0] / closes[-1] - 1)