Commodities Timing based on a Monetary Conditions

1from math import isnan
2from AlgorithmImports import *
3import pandas as pd
4import numpy as np
5from scipy.optimize import minimize
6class CommoditiesTimingbasedonaMonetaryConditions(QCAlgorithm):
7def Initialize(self):
8self.SetStartDate(2004, 1, 1)
9self.SetCash(100000)
10
11self.data = {}  # daily closes
12period = 12 * 21
13self.SetWarmUp(period)
14
15self.symbols = ["SPY", "EFA", "IEF", "LQD"]
16self.commodities = ["DBC"]
17for symbol in self.symbols + self.commodities:
18    self.AddEquity(symbol, Resolution.Daily)
19    self.data[symbol] = RollingWindow[float](period)
20# changes in FED policy from restrictive to expansive
21dates_str = ["24.08.1999", "03.01.2001", "30.06.2004", "18.09.2007", "14.12.2016", "31.7.2019"]
22self.dates = [datetime.strptime(x, "%d.%m.%Y").date() for x in dates_str] # datetime type
23
24# import quandl federal rate data
25self.target_rate = self.AddData(QuandlValue, 'FRED/DFEDTARU', Resolution.Daily).Symbol
26self.restrictive_flag = True    # from start of the algorithm
27self.last_target_rate = None
28self.external_restrictive_flag = None
29self.recent_month = -1
30def OnData(self, data):
31if self.target_rate in data and data[self.target_rate]:
32    curr_target_rate = data[self.target_rate].Value
33    
34    restrictive_flag = None
35    
36    # switch to external data source, when self.dates ends
37    if self.Time.date() > self.dates[-1]:
38        if self.last_target_rate:
39            if curr_target_rate > self.last_target_rate:
40                restrictive_flag = True
41            elif curr_target_rate < self.last_target_rate:
42                restrictive_flag = False
43    
44    if restrictive_flag is not None:
45        self.external_restrictive_flag = restrictive_flag
46            
47    self.last_target_rate = curr_target_rate
48
49# store daily price data
50for symbol in self.symbols + self.commodities:
51    if symbol in data and data[symbol]:
52        price = data[symbol].Value
53        self.data[symbol].Add(price)
54
55if self.recent_month == self.Time.month:
56    return
57self.recent_month = self.Time.month
58
59self.Liquidate()
60# if external data is present, trade out of it
61if self.external_restrictive_flag is not None:
62    restrictive_flag = self.external_restrictive_flag
63    
64    # stop backtest once quandl target rate data stops
65    if self.Securities[self.target_rate].GetLastData() and (self.Time.date() - self.Securities[self.target_rate].GetLastData().Time.date()).days > 5:
66        self.Liquidate()
67        return
68else:
69    restrictive_flag = self.restrictive_flag
70symbols = [x for x in self.symbols]
71
72if restrictive_flag:
73    symbols += self.commodities
74# construct dataframe
75data = {}
76for symbol in symbols:
77    if self.data[symbol].IsReady:
78        data[symbol] = [x for x in self.data[symbol]][::-1]
79        
80if len(data) != 0:
81    df_price = pd.DataFrame(data,columns=data.keys()) 
82    daily_return = (df_price / df_price.shift(1) - 1).dropna()
83    a = PortfolioOptimization(daily_return, 0, len(data))
84    opt_weight = a.opt_portfolio()
85    
86    if isnan(sum(opt_weight)): return
87    
88    for i in range(len(data)):
89        if opt_weight[i] >= 0.001:
90            self.SetHoldings(df_price.columns[i], opt_weight[i])
91else:
92    if self.Portfolio.Invested:
93        self.Liquidate()
94    
95class PortfolioOptimization(object):
96def __init__(self, df_return, risk_free_rate, num_assets):
97self.daily_return = df_return
98self.risk_free_rate = risk_free_rate
99self.n = num_assets # numbers of risk assets in portfolio
100self.target_vol = 0.05
101def annual_port_return(self, weights):
102# calculate the annual return of portfolio
103return np.sum(self.daily_return.mean() * weights) * 252
104def annual_port_vol(self, weights):
105# calculate the annual volatility of portfolio
106return np.sqrt(np.dot(weights.T, np.dot(self.daily_return.cov() * 252, weights)))
107def min_func(self, weights):
108# method 1: maximize sharp ratio
109return - self.annual_port_return(weights) / self.annual_port_vol(weights)
110
111# method 2: maximize the return with target volatility
112#return - self.annual_port_return(weights) / self.target_vol
113def opt_portfolio(self):
114# maximize the sharpe ratio to find the optimal weights
115cons = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
116bnds = tuple((0, 1) for x in range(2)) + tuple((0, 0.25) for x in range(self.n - 2))
117opt = minimize(self.min_func,                               # object function
118               np.array(self.n * [1. / self.n]),            # initial value
119               method='SLSQP',                              # optimization method
120               bounds=bnds,                                 # bounds for variables 
121               constraints=cons)                            # constraint conditions
122              
123opt_weights = opt['x']
124 
125return opt_weights
126# Quandl "value" data
127class QuandlValue(PythonQuandl):
128def __init__(self):
129self.ValueColumnName = 'Value'