Carry On – Enhanced Carry Strategy

1import data_tools
2from AlgorithmImports import *
3from itertools import combinations
4from numpy.linalg import inv
5from scipy import stats
6class CarryOnEnhancedCarryStrategy(QCAlgorithm):
7def Initialize(self):
8self.SetStartDate(2002, 1, 1)
9self.SetCash(100000)
10
11# Source: https://www.quandl.com/data/OECD-Organisation-for-Economic-Co-operation-and-Development
12# NOTE: interest rate quandl data is available only once a month
13self.symbols = {
14    "CME_AD1" : "IR3TIB01AUM156N",   # Australian Dollar Futures, Continuous Contract #1
15    "CME_CD1" : "IR3TIB01CAM156N",   # Canadian Dollar Futures, Continuous Contract #1
16    "CME_EC1" : "IR3TIB01EZM156N",   # Euro FX Futures, Continuous Contract #1
17    "CME_JY1" : "IR3TIB01JPM156N",   # Japanese Yen Futures, Continuous Contract #1  # IR data since 2002
18    "CME_MP1" : "IR3TIB01MXM156N",   # Mexican Peso Futures, Continuous Contract #1
19    "CME_NE1" : "IR3TIB01NZM156N",   # New Zealand Dollar Futures, Continuous Contract #1  # price data since 2006
20    "CME_SF1" : "IR3TIB01CHM156N"    # Swiss Franc Futures, Continuous Contract #1
21}
22
23self.leverage:int = 10
24self.volatility_period:int = 2 * 12 * 21
25self.performance_period:int = 3 * 12 * 21
26self.data = {}
27self.SetWarmUp(self.performance_period, Resolution.Daily)
28self.top_diff_pairs_cnt:int = 19  # number of pairs with top interest rate difference to pick
29self.top_vol_pairs_cnt:int = 6    # number of pairs with top volatility to pick
30
31turbulance_sma_period:int = 30
32turbulance_sma_hist_period:int = 3*12*21
33self.turbulance_sma: SimpleMovingAverage = SimpleMovingAverage(turbulance_sma_period)
34self.turbulance_sma_history: RollingWindow = RollingWindow[float](turbulance_sma_hist_period)
35
36for symbol, rate_symbol in self.symbols.items():
37    self.AddData(data_tools.InterestRate3M, rate_symbol, Resolution.Daily)
38    data = self.AddData(data_tools.QuantpediaFutures, symbol, Resolution.Daily)
39    data.SetFeeModel(data_tools.CustomFeeModel())
40    data.SetLeverage(self.leverage)
41    
42    self.data[symbol] = data_tools.SymbolData(self.volatility_period, self.performance_period)
43
44# construct currency pairs
45symbols = list(self.symbols.keys())
46self.pairs = list(combinations(symbols, 2))
47
48self.rebalance_flag = False
49self.Schedule.On(self.DateRules.MonthEnd(symbols[0]), self.TimeRules.At(0, 0), self.Rebalance)
50
51def Rebalance(self) -> None:
52self.rebalance_flag = True
53
54def OnData(self, data: Slice) -> None:
55ir_last_update_date:Dict[str, datetime.date] = data_tools.InterestRate3M.get_last_update_date()
56qp_futures_last_update_date:Dict[str, datetime.date] = data_tools.QuantpediaFutures.get_last_update_date()
57symbols_to_delete:List[str] = []
58# data is still coming in
59if all([self.Securities[x].GetLastData() for x in self.symbols.keys()]) and any([self.Time.date() >= qp_futures_last_update_date[x] for x in self.symbols.keys()]) \
60    and all([self.Securities[x].GetLastData() for x in self.symbols.values()]) and any([self.Time.date() >= ir_last_update_date[x] for x in self.symbols.values()]):
61    self.Liquidate()
62    return
63# store daily data
64for symbol, ir in self.symbols.items():
65    if symbol in data and data[symbol]:
66        price = data[symbol].Value
67        self.data[symbol].update_price(price)
68
69if self.IsWarmingUp: return
70
71carry_weight = None
72
73S_dict = { x : self.data[x].daily_performance() for x in self.symbols if self.data[x].is_ready() }
74# data for every symbol is ready
75if len(S_dict) == len(self.symbols):
76    # turbulance calculation
77    y = np.array([[ self.data[x].abs_performance() for x in self.symbols ]]) # row vector
78    u = np.array([[ self.data[x].avg_performance() for x in self.symbols ]]) # row vector
79    A = y - u
80    A_t = np.transpose(A)
81    S = inv(pd.DataFrame(S_dict).cov())
82    N = len(S_dict)
83    t_ = np.dot(np.dot(A, S), A_t)
84    turbulance = (t_ / N)[0][0]
85    
86    # update turbulance SMA indicator daily
87    self.turbulance_sma.Update(self.Time, turbulance)
88    
89    # turbulance SMA is ready
90    if self.turbulance_sma.IsReady:
91        turb_sma = self.turbulance_sma.Current.Value
92        # update turbulance SMA history
93        self.turbulance_sma_history.Add(turb_sma)
94        
95        # turbulance SMA history is ready
96        if self.turbulance_sma_history.IsReady:
97            # percent rank of moving average versus its five-year history
98            percentile_score = stats.percentileofscore([x for x in self.turbulance_sma_history][1:], turb_sma)
99            
100            # floor to nearest 20 score
101            percent_rank_floored = math.floor(percentile_score / 20) * 20
102            
103            # assign carry strategy weight
104            if percent_rank_floored == 0:
105                carry_weight = 1
106            elif percent_rank_floored == 20:
107                carry_weight = .75
108            elif percent_rank_floored == 40:
109                carry_weight = .5
110            elif percent_rank_floored == 60:
111                carry_weight = .25
112            elif percent_rank_floored == 80:
113                carry_weight = 0
114                
115if not self.rebalance_flag:
116    return
117self.rebalance_flag = False
118
119# carry weight is not set
120if not carry_weight:
121    return
122
123# calculate interest rate differentials and align each currency pair such 
124# that a long position corresponds to a positive interest rate differential
125ir_diff_pos = {
126    x : data[self.symbols[x[0]]].Value - data[self.symbols[x[1]]].Value
127    for x in self.pairs if 
128    self.symbols[x[0]] in data and data[self.symbols[x[0]]] and
129    self.symbols[x[1]] in data and data[self.symbols[x[1]]] and
130    data[self.symbols[x[0]]].Value >= data[self.symbols[x[1]]].Value
131}
132ir_diff_neg = {
133    (x[1], x[0]) : data[self.symbols[x[1]]].Value - data[self.symbols[x[0]]].Value
134    for x in self.pairs if 
135    self.symbols[x[0]] in data and data[self.symbols[x[0]]] and
136    self.symbols[x[1]] in data and data[self.symbols[x[1]]] and
137    data[self.symbols[x[0]]].Value < data[self.symbols[x[1]]].Value
138}
139
140# merge both dictionaries
141interest_rate_diff = {**ir_diff_pos, **ir_diff_neg}
142
143if len(interest_rate_diff) >= self.top_diff_pairs_cnt:
144    pair_volatility = { x : (self.data[x[0]].volatility() + self.data[x[1]].volatility()) / 2 for x in interest_rate_diff   \
145                        if x[0] in self.data and x[1] in self.data and self.data[x[0]].is_ready() and self.data[x[1]].is_ready() }
146    
147    # sort pairs by currency interest rate difference
148    sorted_by_diff = sorted(interest_rate_diff.items(), key = lambda x:x[1], reverse=True)
149    top_by_diff = [x[0] for x in sorted_by_diff[:self.top_diff_pairs_cnt]]
150    
151    # sort pairs by volatility
152    sorted_by_vol = sorted([x for x in top_by_diff if x in pair_volatility], key = lambda x:pair_volatility[x], reverse=True)
153    if len(sorted_by_vol) >= self.top_vol_pairs_cnt:
154        top_by_vol = [x for x in sorted_by_vol[:self.top_vol_pairs_cnt]]
155        
156        # trade carry strategy
157        self.Liquidate()
158        
159        equity_used = self.Portfolio.TotalPortfolioValue * carry_weight
160        pair_count = len(top_by_vol)
161        for pair in top_by_vol:
162            # calculate traded quantity
163            q1 = equity_used / pair_count / self.data[pair[0]].recent_price()
164            q2 = equity_used / pair_count / self.data[pair[1]].recent_price()
165            self.MarketOrder(pair[0], q1)
166            self.MarketOrder(pair[1], -q2)