Implied Skewness Strategy in Commodities

1from AlgorithmImports import *
2class ImpliedSkewnessStrategyInCommodities(QCAlgorithm):
3def Initialize(self):
4self.SetStartDate(2015, 1, 1)
5self.SetCash(100000)
6
7self.symbols = []           # storing commodities symbols
8self.managed_queue = []     # storing parts of portfolio with their current holding period
9self.contracts_expiry = {}  # storing contracts expiry date under symbols
10self.tickers_symbols = {}   # storing commodities symbols under their tickers
11
12self.futures = ['GLD', 'USO', 'UNG', 'SLV', 'CORN', 'WEAT', 'SOYB', 'CPER']
13self.quantile = 4
14for ticker in self.futures:
15    # subscribe to commodity future
16    security = self.AddEquity(ticker, Resolution.Minute)
17    
18    # change normalization to raw to allow adding futures contracts
19    security.SetDataNormalizationMode(DataNormalizationMode.Raw)
20    # set fee model and leverage
21    security.SetFeeModel(CustomFeeModel())
22    security.SetLeverage(5)
23    
24    # get commodity symbol
25    symbol = security.Symbol
26    # store future symbol under future ticker
27    self.tickers_symbols[ticker] = symbol
28    # add commodity symbol to symbols, which can be traded in this strategy
29    self.symbols.append(symbol)
30    
31self.min_expiry = 25
32self.max_expiry = 35
33
34self.holding_period = 21 # holding each part of portfolio n days
35self.current_day = -1
36def OnData(self, data):
37# rebalance daily
38if self.current_day == self.Time.day:
39    return
40self.current_day = self.Time.day
41
42for symbol in self.symbols:
43    # subscribe to new contracts, because current ones has expiried
44    if symbol not in self.contracts_expiry or self.contracts_expiry[symbol] <= self.Time.date():
45        # subsribe to new itm and otm contracts
46        self.SubscribeOptionContracts(symbol)
47
48# storing implied skewness for each commodity
49implied_skewness = {}
50
51for kvp in data.OptionChains:
52    chain = kvp.Value
53    contracts = [x for x in chain]
54    # check if there are enough contracts for option
55    if len(contracts) < 4:
56        continue
57    
58    # get future symbol
59    future_symbol = self.tickers_symbols[chain.Underlying.Symbol.Value]
60    
61    # get implied volatility for each contract
62    itm_put_iv, itm_call_iv, otm_put_iv, otm_call_iv = self.GetImpliedVolatilities(contracts)
63    
64    # make sure, there is implied volatility for each contract
65    if itm_put_iv and itm_call_iv and otm_put_iv and otm_call_iv:
66        # calculate otm mean
67        otm_mean = (otm_put_iv + otm_call_iv) / 2
68        # calculate itm mean
69        itm_mean = (itm_put_iv + itm_call_iv) / 2
70        # calculate and store skewness
71        implied_skewness[future_symbol] = otm_mean - itm_mean
72
73# make sure, there are enough symbols for quartile selection
74if len(implied_skewness) < self.quantile:
75    # try to liquidate old part of portfolio
76    self.TradeAndLiquidate()
77    return
78
79# quartile selection
80quantile = int(len(implied_skewness) / self.quantile)
81sorted_by_skewness = [x[0] for x in sorted(implied_skewness.items(), key=lambda item: item[1])]
82
83# long top quartile
84long = [x for x in sorted_by_skewness[-quantile:] if self.GetLastPrice(x, data)]
85# short bottom quartile
86short = [x for x in sorted_by_skewness[:quantile] if self.GetLastPrice(x, data)]
87
88if len(long) != 0 and len(short) != 0:
89    # calculate long and short weight for new portfolio part
90    long_w = self.Portfolio.TotalPortfolioValue / self.holding_period / len(long)
91    short_w = self.Portfolio.TotalPortfolioValue / self.holding_period / len(short)
92    
93    # create long and shory symbols_q
94    long_symbols_q = [(x, np.floor(long_w / self.GetLastPrice(x, data))) for x in long]
95    short_symbols_q = [(x, -np.floor(short_w / self.GetLastPrice(x, data))) for x in short]
96    
97    # add new part of portfolio to managed_queue list
98    self.managed_queue.append(RebalanceQueueItem(long_symbols_q + short_symbols_q))
99    
100# trade new part of portfolio and try to liquidate old one
101self.TradeAndLiquidate()
102
103def SubscribeOptionContracts(self, symbol):
104''' get itm and otm strike for specific symbol ''' 
105''' then it filters itm and otm puts and calls ''' 
106''' if there are enough itm and otm puts and calls this function subscribes one of their contracts based on expiry and store expiry date ''' 
107
108# get all contracts for current commodity future
109contracts = self.OptionChainProvider.GetOptionContractList(symbol, self.Time)
110# get current price for commodity future
111underlying_price = self.Securities[symbol].Price
112
113# get strikes from commodity future contracts
114strikes = [i.ID.StrikePrice for i in contracts]
115
116# check if there is at least one strike    
117if len(strikes) <= 0:
118    return
119
120# in the money with 95%
121itm_strike:float = min(strikes, key=lambda x: abs(x-(underlying_price*0.95)))
122# out the money with 105%
123otm_strike:float = min(strikes, key=lambda x: abs(x-(underlying_price*1.05)))
124
125# filtred contracts based on option rights and strikes
126itm_puts:list = self.FilterContracts(contracts, OptionRight.Put, itm_strike)
127itm_calls:list = self.FilterContracts(contracts, OptionRight.Call, itm_strike)
128otm_puts:list = self.FilterContracts(contracts, OptionRight.Put, otm_strike)
129otm_calls:list = self.FilterContracts(contracts, OptionRight.Call, otm_strike)
130
131# make sure there are enough contracts
132if len(itm_puts) > 0 and len(itm_calls) > 0 and len(otm_puts) > 0 and len(otm_calls) > 0:
133    # sort by expiry
134    itm_put, itm_call, otm_put, otm_call = self.SortByExpiry(itm_puts, itm_calls, otm_puts, otm_calls)
135    
136    # add contracts
137    for contract in [itm_put, itm_call, otm_put, otm_call]:
138        self.AddContract(contract)
139    
140    # store expiry date
141    self.contracts_expiry[symbol] = itm_put.ID.Date.date()
142
143def FilterContracts(self, contracts, option_right, strike):
144''' filter contracts based on option_right and strike parameter from contracts parameter'''   
145
146# filter contracts based on option right and strike parameters
147filtered_contracts:list = [i for i in contracts if i.ID.OptionRight == option_right and 
148                                         i.ID.StrikePrice == strike and 
149                                         self.min_expiry < (i.ID.Date - self.Time).days < self.max_expiry]
150# return filtered contracts
151return filtered_contracts
152
153def SortByExpiry(self, itm_puts, itm_calls, otm_puts, otm_calls):
154''' sort contracts based on expiry and returns contracts with nearest expiry date '''
155
156# sort by expiry
157itm_put = sorted(itm_puts, key = lambda x: x.ID.Date)[0]
158itm_call = sorted(itm_calls, key = lambda x: x.ID.Date)[0]
159
160otm_put = sorted(otm_puts, key = lambda x: x.ID.Date)[0]
161otm_call = sorted(otm_calls, key = lambda x: x.ID.Date)[0]
162
163return [itm_put, itm_call, otm_put, otm_call]
164
165def AddContract(self, contract):
166''' subcribe to contract, set price model and normalization mode '''
167
168# add contract
169option = self.AddOptionContract(contract, Resolution.Minute)
170option.PriceModel = OptionPriceModels.CrankNicolsonFD()
171option.SetDataNormalizationMode(DataNormalizationMode.Raw)
172
173def GetImpliedVolatilities(self, contracts):
174''' return implied volatility for itm_put, itm_call, otm_put and otm_call contract '''
175
176itm_put_iv = None
177itm_call_iv = None
178otm_put_iv = None
179otm_call_iv = None
180
181# go through option contracts
182for c in contracts:
183    # get underlying price of contract
184    underlying_price = self.Securities[c.UnderlyingSymbol].Price
185    
186    if c.Right == OptionRight.Call and c.Strike < underlying_price:
187        # found itm call
188        itm_call_iv = c.ImpliedVolatility
189    elif c.Right == OptionRight.Call and c.Strike >= underlying_price:
190        # found otm call
191        otm_call_iv = c.ImpliedVolatility
192    elif c.Right == OptionRight.Put and c.Strike < underlying_price:
193        # found itm put
194        itm_put_iv = c.ImpliedVolatility
195    else:
196        # found otm put
197        otm_put_iv = c.ImpliedVolatility
198
199# return implied volatility for each contract
200return itm_put_iv, itm_call_iv, otm_put_iv, otm_call_iv
201
202def GetLastPrice(self, symbol, data):
203''' return symbol price from data object, or returns None if there isn't the price '''
204
205# check if symbol has price in data object
206if symbol in data and data[symbol]:
207    # return price
208    return data[symbol].Value
209else:
210    # return None, if symbol doesn't have price in data object
211    return None
212    
213def TradeAndLiquidate(self):
214''' handles daily rebalancing of portfolio parts '''
215''' it trades new parts and liquidate parts, which has holding_period equal to self.holding_period '''
216''' after liquidation these parts are removed from self.managed_queue '''
217
218remove_portfolio_part = None
219
220for portfolio_part in self.managed_queue:
221    # liquidate this part of portfolio
222    if portfolio_part.holding_period == self.holding_period:
223        for symbol, quantity in portfolio_part.symbol_q:
224            # liquidate symbol from this portfolio part
225            self.MarketOrder(symbol, -quantity)
226            # reinitialize remove_portfolio_part
227            remove_portfolio_part = portfolio_part
228            
229    # trade new portfolio part
230    elif portfolio_part.holding_period == 0:
231        # store symbols, which were opened
232        opened_symbol_q = []
233        
234        for symbol, quantity in portfolio_part.symbol_q:
235            if self.Securities[symbol].Price != 0 and self.Securities[symbol].IsTradable:
236                # trade symbol
237                self.MarketOrder(symbol, quantity)
238                # store symbol in opened symbol_q
239                opened_symbol_q.append((symbol, quantity))
240        
241        # change symbol_q of current portfolio part
242        portfolio_part.symbol_q = opened_symbol_q
243    
244    # increase holding period of current portfolio part
245    portfolio_part.holding_period += 1
246    
247# in the end try to remove portfolio part from self.managed_queue
248if remove_portfolio_part:
249    self.managed_queue.remove(remove_portfolio_part)
250    
251class RebalanceQueueItem():
252def __init__(self, symbol_q):
253# symbol/quantity collections
254self.symbol_q = symbol_q  
255self.holding_period = 0
256
257# custom fee model
258class CustomFeeModel(FeeModel):
259def GetOrderFee(self, parameters):
260fee = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
261return OrderFee(CashAmount(fee, "USD"))