Commodity Option Implied Volatility Strategy

1from AlgorithmImports import *
2#endregion
3# https://quantpedia.com/strategies/commodity-option-implied-volatility-strategy/
4#
5# The investment universe consists of 25 commodities.
6# Commodities are sorted into four groups based on the 30-days implied volatility de-trended by the previous 12 months mean of implied volatility (see page 8 for exact formula).
7# The “Low” (“High”) group contains the top 25% of all commodities with the lowest (highest) volatilities.
8# The portfolio is long-short and buys commodities from the group “Low” and sells commodities from the group “High”.
9# The portfolio is equally-weighted and is rebalanced on a monthly basis.
10#
11# QC Implementation:
12import numpy as np
13class CommodityOptionImpliedVolatilityStrategy(QCAlgorithm):
14def Initialize(self):
15self.SetStartDate(2010, 1, 1)
16self.SetCash(100000)
17
18self.min_expiry = 25
19self.max_expiry = 35
20
21self.period = 12 # need n of implied volatilities
22
23self.iv = {} # storing implied volatilies in RollingWindow
24self.contracts = {} # storing option contracts
25self.tickers_symbols = {} # storing commodities symbols under their tickers
26
27self.tickers = ['GLD', 'USO', 'UNG', 'SLV', 'DBA', 'DBB', 'PPLT', 'PALL']
28self.next_expiry = None
29for ticker in self.tickers:
30    # subscribe to commodity
31    security = self.AddEquity(ticker, Resolution.Minute)
32    
33    # change normalization to raw to allow adding contracts
34    security.SetDataNormalizationMode(DataNormalizationMode.Raw)
35    # set fee model and leverage
36    security.SetFeeModel(CustomFeeModel())
37    security.SetLeverage(5)
38    
39    # get commodity symbol
40    symbol = security.Symbol
41    # store symbol under ticker
42    self.tickers_symbols[ticker] = symbol
43    # create RollingWindow for implied volatilities
44    self.iv[symbol] = RollingWindow[float](self.period)
45
46self.day = -1
47
48def OnData(self, data):
49# rebalance daily
50if self.day == self.Time.day:
51    return
52self.day = self.Time.day
53
54if self.next_expiry and self.Time.date() >= self.next_expiry.date():
55    self.Liquidate()
56
57    for symbol in self.tickers_symbols:
58        if symbol in self.contracts:
59            # remove expired contracts
60            for contract in self.contracts[symbol]:
61                self.RemoveSecurity(contract)
62            # remove contracts from dictionary
63            del self.contracts[symbol]
64            
65if not self.Portfolio.Invested:
66    for symbol in self.tickers_symbols:
67        if symbol not in self.contracts:
68            # get all contracts for current commodity
69            contracts = self.OptionChainProvider.GetOptionContractList(symbol, self.Time)
70            # get current price for commodity
71            underlying_price = self.Securities[symbol].Price
72            
73            # get strikes from commodity contracts
74            strikes = [i.ID.StrikePrice for i in contracts]
75            if len(strikes) > 0:
76                # get at the money strike
77                atm_strike:float = min(strikes, key=lambda x: abs(x-underlying_price))
78
79                atm_calls:list = [i for i in contracts if i.ID.OptionRight == OptionRight.Call and 
80                                                         i.ID.StrikePrice == atm_strike and 
81                                                         self.min_expiry < (i.ID.Date - self.Time).days < self.max_expiry]
82                
83                atm_puts:list = [i for i in contracts if i.ID.OptionRight == OptionRight.Put and 
84                                                         i.ID.StrikePrice == atm_strike and 
85                                                         self.min_expiry < (i.ID.Date - self.Time).days < self.max_expiry]
86                
87                if len(atm_calls) and len(atm_puts):
88                    # sort by expiry
89                    atm_call = sorted(atm_calls, key = lambda x: x.ID.Date)[0]
90                    atm_put = sorted(atm_puts, key = lambda x: x.ID.Date)[0]
91                    
92                    self.next_expiry = min(atm_call.ID.Date, atm_put.ID.Date)
93                    
94                    # add contracts
95                    option = self.AddOptionContract(atm_call, Resolution.Minute)
96                    option.PriceModel = OptionPriceModels.CrankNicolsonFD()
97                    option.SetDataNormalizationMode(DataNormalizationMode.Raw)
98                    
99                    option = self.AddOptionContract(atm_put, Resolution.Minute)
100                    option.PriceModel = OptionPriceModels.CrankNicolsonFD()
101                    option.SetDataNormalizationMode(DataNormalizationMode.Raw)
102                    
103                    # store atm contracts by symbol
104                    self.contracts[symbol] = [atm_call, atm_put]
105    
106    iv_detrend = {} # storing detrend implied volatility for options
107    
108    if data.OptionChains.Count != 0:
109        for kvp in data.OptionChains:
110            chain = kvp.Value
111            contracts = [x for x in chain]
112            # check if there are enough contracts for option
113            if len(contracts) < 2:
114                continue
115            
116            atm_call_iv = None
117            atm_put_iv = None
118            # get ticker
119            ticker = chain.Underlying.Symbol.Value
120            
121            # go through option contracts
122            for c in contracts:
123                if c.Right == OptionRight.Call:
124                    # found atm call
125                    atm_call_iv = c.ImpliedVolatility
126                else:
127                    # found put option
128                    atm_put_iv = c.ImpliedVolatility
129            
130            if atm_call_iv and atm_put_iv:
131                # make mean from atm call implied volatility and atm put implied volatility
132                iv = (atm_call_iv + atm_put_iv) / 2 
133                # get symbol based on ticker from option contract
134                commodity_symbol = self.tickers_symbols[ticker]
135                
136                # check if there are enough data of mean implied volatilities
137                if self.iv[commodity_symbol].IsReady:
138                    # calculate mean of previous mean implied volatilities
139                    vol_mean = np.mean([x for x in self.iv[commodity_symbol]])
140                    # calculate detrend implied volatility and store it by symbol
141                    iv_detrend[commodity_symbol] = iv - vol_mean
142                    
143                # add current mean of implied volatility
144                self.iv[commodity_symbol].Add(iv)
145    
146    # can't perform quintile selection
147    if len(iv_detrend) < 4:
148        self.Liquidate()
149        return
150    
151    quintile = int(len(iv_detrend) / 4)
152    sorted_by_iv_detrend = [x[0] for x in sorted(iv_detrend.items(), key=lambda item: item[1])]
153    
154    # go long smallest quintile
155    long = sorted_by_iv_detrend[:quintile]
156    # go short largest quintile
157    short = sorted_by_iv_detrend[-quintile:]
158    
159    # trade execution
160    long_length = len(long)
161    short_length = len(short)
162    
163    for symbol in long:
164        self.SetHoldings(symbol, 1 / long_length)
165    for symbol in short:
166        self.SetHoldings(symbol, -1 / short_length)
167
168# custom fee model
169class CustomFeeModel(FeeModel):
170def GetOrderFee(self, parameters):
171fee = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
172return OrderFee(CashAmount(fee, "USD"))