跨截面一个月股票ATM跨式交易策略

1from AlgorithmImports import *
2from typing import List, Dict
3from pandas.core.frame import DataFrame
4from pandas.core.series import Series
5#endregion
6class CrossSectionalOneMonthEquityATMStraddleTradingStrategy(QCAlgorithm):
7def Initialize(self):
8self.SetStartDate(2012, 1, 1)
9self.SetCash(1000000)
10
11self.tickers_to_ignore: List[str] = ['DFG']
12self.min_expiry: int = 20
13self.max_expiry: int = 45
14self.period: int = 21 # need n of stock daily prices
15self.percentage_traded: float = 0.2
16self.min_share_price: int = 10
17self.leverage: int = 5
18self.quantile: int = 10
19self.min_contracts: int = 2
20self.day: int = -1
21
22self.fundamental_count: int = 500
23self.fundamental_sorting_key = lambda x: x.DollarVolume
24self.selection_flag: bool = True
25self.data: Dict[Symbol, RollingWindow] = {}
26self.symbols_by_ticker: Dict[str, Symbol] = {}
27self.subscribed_contracts: Dict[Symbol, Contracts] = {}
28self.settings.daily_precise_end_time = False
29self.Settings.MinimumOrderMarginPortfolioPercentage = 0.
30self.UniverseSettings.Resolution = Resolution.Daily
31self.AddUniverse(self.FundamentalSelectionFunction)
32self.SetSecurityInitializer(lambda x: x.SetDataNormalizationMode(DataNormalizationMode.Raw))
33self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw
34def OnSecuritiesChanged(self, changes: SecurityChanges) -> None:
35for security in changes.AddedSecurities:
36    security.SetFeeModel(CustomFeeModel())
37    security.SetLeverage(self.leverage)
38def FundamentalSelectionFunction(self, fundamental: List[Fundamental]) -> List[Symbol]:
39# update daily prices of stocks in self.data dictionary
40for stock in fundamental:
41    symbol: Symbol = stock.Symbol
42    
43    if symbol in self.data:
44        self.data[symbol].Add(stock.AdjustedPrice)
45
46# rebalance, when contracts expiried
47if not self.selection_flag:
48    return Universe.Unchanged
49
50# select top n stocks by dollar volume
51selected: List[Fundamental] = [
52    x for x in fundamental
53    if x.HasFundamentalData
54    and x.Market == 'usa'
55    and x.Price > self.min_share_price
56    and x.Symbol.Value not in self.tickers_to_ignore
57]
58if len(selected) > self.fundamental_count:
59    selected = [x for x in sorted(selected, key=self.fundamental_sorting_key, reverse=True)[:self.fundamental_count]]
60for stock in selected:
61    symbol: Symbol = stock.Symbol
62    ticker: str = symbol.Value 
63    self.symbols_by_ticker[ticker] = symbol
64    
65    if symbol in self.data:
66        continue
67    
68    self.data[symbol] = RollingWindow[float](self.period)
69    history: DataFrame = self.History(symbol, self.period, Resolution.Daily)
70    if history.empty:
71        continue
72    closes: Series = history.loc[symbol].close
73    for time, close in closes.items():
74        self.data[symbol].Add(close)
75# return newly selected symbols
76return list(map(lambda x: x.Symbol, selected))
77def OnData(self, data: Slice) -> None:
78# execute once a day
79if self.day == self.Time.day:
80    return
81self.day = self.Time.day
82
83# check if any of the subscribed contracts expired
84for _, symbol in self.symbols_by_ticker.items():
85    if symbol in self.subscribed_contracts and self.subscribed_contracts[symbol].expiry_date <= self.Time.date():
86        # remove expired contracts
87        for contract in self.subscribed_contracts[symbol].contracts:
88            if self.Securities[contract].IsTradable:
89                # self.RemoveSecurity(contract)
90                self.Liquidate(contract)
91            
92        # remove Contracts object for current symbol
93        del self.subscribed_contracts[symbol]
94
95# perform next selection, when there are no active contracts
96if len(self.subscribed_contracts) == 0 and not self.selection_flag:
97    # liquidate leftovers
98    if self.Portfolio.Invested:
99        self.Liquidate()
100        
101    self.symbols_by_ticker.clear()
102    self.selection_flag = True
103    return
104
105# subscribe to new contracts after selection
106elif len(self.subscribed_contracts) == 0 and self.selection_flag:
107    for _, symbol in self.symbols_by_ticker.items():
108        if symbol in self.data and self.data[symbol].IsReady:
109            if self.Securities[symbol].IsDelisted:
110                continue
111            # get all contracts for current stock symbol
112            contracts: List[Symbol] = self.OptionChainProvider.GetOptionContractList(symbol, self.Time)
113            # get current price for etf
114            underlying_price: float = self.data[symbol][0]
115            
116            # get strikes from commodity future contracts
117            strikes: List[float] = [i.ID.StrikePrice for i in contracts]
118            
119            # can't filter contracts, if there isn't any strike price
120            if len(strikes) <= 0 or underlying_price == 0:
121                continue
122            
123            # filter calls and puts contracts with one month expiry
124            calls, puts = self.FilterContracts(strikes, contracts, underlying_price)
125            
126            # make sure, there is at least one call and put contract
127            if len(calls) > 0 and len(puts) > 0:
128                # sort by expiry
129                call: Symbol = sorted(calls, key = lambda x: x.ID.Date, reverse=True)[0]
130                put: Symbol = sorted(puts, key = lambda x: x.ID.Date, reverse=True)[0]
131                
132                subscriptions = self.SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(call.Underlying)
133                if subscriptions:
134                    # add call contract
135                    self.AddContract(call)
136                    # add put contract
137                    self.AddContract(put)
138                    
139                    # retrieve expiry date for contracts
140                    expiry_date: datetime.date = call.ID.Date.date() if call.ID.Date.date() < put.ID.Date.date() else put.ID.Date.date()
141                    # store contracts with expiry date under stock's symbol
142                    self.subscribed_contracts[symbol] = Contracts(expiry_date, underlying_price, [call, put])
143    
144# calculate term structure and trade options
145elif len(self.subscribed_contracts) != 0 and data.OptionChains.Count != 0 and self.selection_flag:
146    self.selection_flag = False # this makes sure, there will be no other trades until next selection
147    
148    term_structure = {} # storing term structures keyed by stock's symbol
149    
150    for kvp in data.OptionChains:
151        chain: OptionChain = kvp.Value
152        ticker: str = chain.Underlying.Symbol.Value
153        if ticker in self.symbols_by_ticker:
154            # get stock's symbol
155            symbol: Symbol = self.symbols_by_ticker[ticker]
156            # get contracts
157            contracts: List[Symbol] = [x for x in chain]
158            
159            # check if there are enough contracts for option and daily prices are ready
160            if len(contracts) < self.min_contracts or not self.data[symbol].IsReady:
161                continue
162            
163            # get call and put implied volatility
164            call_iv, put_iv = self.GetImpliedVolatilities(contracts)
165            
166            if call_iv and put_iv:
167                # make mean from call implied volatility and put implied volatility
168                iv: float = (call_iv + put_iv) / 2 
169                # get historical volatility
170                hv: float = self.GetHistoricalVolatility(self.data[symbol])
171                
172                # store stock's term structure
173                term_structure[symbol] = (iv - hv) / hv
174    
175    # can't perform selection
176    if len(term_structure) < self.quantile:
177        return
178    
179    # perform quantile selection
180    quantile: int = int(len(term_structure) / self.quantile)
181    sorted_by_term_structure: List[Symbol] = [x[0] for x in sorted(term_structure.items(), key=lambda item: item[1])]
182    
183    # long top
184    long: List[Symbol] = sorted_by_term_structure[-quantile:]
185    # short bottom
186    short: List[Symbol] = sorted_by_term_structure[:quantile]
187    
188    # trade execution
189    self.Liquidate()
190    
191    # trade long
192    self.TradeOptions(data, long, True)
193    # trade short
194    self.TradeOptions(data, short, False)
195
196def FilterContracts(self, 
197                strikes: List[float], 
198                contracts: List[Symbol], 
199                underlying_price: float) -> List[Symbol]:
200''' filter call and put contracts from contracts parameter '''
201''' return call and put contracts '''
202
203# Straddle
204call_strike: float = min(strikes, key=lambda x: abs(x-underlying_price))
205put_strike: float = call_strike
206
207calls: List[Symbol] = [] # storing call contracts
208puts: List[Symbol] = [] # storing put contracts
209
210for contract in contracts:
211    # check if contract has one month expiry
212    if self.min_expiry < (contract.ID.Date - self.Time).days < self.max_expiry:
213        # check if contract is call
214        if contract.ID.OptionRight == OptionRight.Call and contract.ID.StrikePrice == call_strike:
215            calls.append(contract)
216        # check if contract is put
217        elif contract.ID.OptionRight == OptionRight.Put and contract.ID.StrikePrice == put_strike:
218            puts.append(contract)
219
220# return filtered calls and puts with one month expiry
221return calls, puts
222
223def AddContract(self, contract: Symbol) -> None:
224''' subscribe option contract, set price mondel and normalization mode '''
225option = self.AddOptionContract(contract, Resolution.Daily)
226option.PriceModel = OptionPriceModels.CrankNicolsonFD()
227
228def GetImpliedVolatilities(self, contracts: List[Symbol]) -> float:
229''' retrieve implied volatility of contracts from contracts parameteres '''
230''' returns call and put implied volatility '''
231call_iv: Union[None, float] = None
232put_iv: Union[None, float] = None
233        
234# go through option contracts
235for c in contracts:
236    if c.Right == OptionRight.Call:
237        # found call option
238        call_iv = c.ImpliedVolatility
239    else:
240        # found put option
241        put_iv = c.ImpliedVolatility
242    
243return call_iv, put_iv
244
245def GetHistoricalVolatility(self, rolling_window_prices: RollingWindow) -> np.ndarray:
246''' calculate historical volatility based on daily prices in rolling_window_prices parameter '''
247prices: np.ndarray = np.array([x for x in rolling_window_prices])
248returns: np.ndarray = (prices[:-1] - prices[1:]) / prices[1:]
249return np.std(returns)
250
251def TradeOptions(self, 
252            data: Slice, 
253            symbols: List[Symbol], 
254            long_flag: bool) -> None:
255''' on long signal buy call and put option contract '''
256''' on short signal sell call and put option contract '''
257length: int = len(symbols)
258
259# trade etf's call and put contracts
260for symbol in symbols:
261    # get call and put contract
262    call, put = self.subscribed_contracts[symbol].contracts
263    
264    # get underlying price
265    underlying_price: float = self.subscribed_contracts[symbol].underlying_price
266    
267    options_q: int = int(((self.Portfolio.TotalPortfolioValue * self.percentage_traded) / length) / (underlying_price * 100))
268    
269    if call in data and data[call] and put in data and data[put]:
270        if long_flag:
271            self.Buy(call, options_q)
272            self.Buy(put, options_q)
273        else:
274            self.Sell(call, options_q)
275            self.Sell(put, options_q)
276
277class Contracts():
278def __init__(self, expiry_date: datetime.date, underlying_price: float, contracts: List[Symbol]) -> None:
279self.expiry_date: datetime.date = expiry_date
280self.underlying_price: float = underlying_price
281self.contracts: List[Symbol] = contracts
282# Custom fee model
283class CustomFeeModel(FeeModel):
284def GetOrderFee(self, parameters: OrderFeeParameters) -> OrderFee:
285fee: float = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
286return OrderFee(CashAmount(fee, "USD"))