期权/股票成交量比率变化预测股票回报

1from AlgorithmImports import *
2from typing import List, Dict
3from dataclasses import dataclass
4#endregion
5class ChangeInOptionStockVolumeRatioPredictsStockReturns(QCAlgorithm):
6def Initialize(self) -> None:
7self.SetStartDate(2014, 1, 1)
8self.SetCash(100000)
9
10self.tickers_to_ignore: List[str] = ['AMD', 'TSLA', 'MSFT']
11self.min_expiry: int = 20
12self.max_expiry: int = 30
13self.period: int = 6           # need n monthly volumes
14self.min_period_len: int = 14  # need at least n daily volumes and at least n minute volumes  
15self.quantile: int = 5
16self.leverage: int = 15
17self.min_share_price: int = 5
18
19self.current_fundamental: List[Symbol] = []
20self.previous_fundamental: List[Symbol] = []
21self.data: Dict[Symbol, SymbolData] = {}                      
22self.subscribed_contracts: Dict[Symbol, Contracts] = {}  # subscribed option universe
23# initial data feed
24self.AddEquity('SPY', Resolution.Minute)
25
26self.months_counter: int = 1
27self.fundamental_count: int = 100
28self.fundamental_sorting_key = lambda x: x.DollarVolume
29self.selection_flag: bool = True
30self.subscribing_flag: bool = False
31self.Settings.MinimumOrderMarginPortfolioPercentage = 0.
32self.UniverseSettings.Resolution = Resolution.Minute
33self.settings.daily_precise_end_time = False
34self.AddUniverse(self.FundamentalSelectionFunction)
35self.SetSecurityInitializer(lambda x: x.SetDataNormalizationMode(DataNormalizationMode.Raw))
36self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw
37def OnSecuritiesChanged(self, changes: SecurityChanges) -> None:
38for security in changes.AddedSecurities:
39    security.SetFeeModel(CustomFeeModel())
40    security.SetLeverage(self.leverage)
41def FundamentalSelectionFunction(self, fundamental: List[Fundamental]) -> List[Symbol]:
42# rebalance yearly
43if not self.selection_flag:
44    return Universe.Unchanged
45
46# change flags values
47self.selection_flag = False
48self.subscribing_flag = True
49# filter top n U.S. stocks by dollar volume
50selected: List[Fundamental] = [
51    x for x in fundamental 
52    if x.HasFundamentalData 
53    and x.Market == 'usa' 
54    and x.Price > self.min_share_price
55    and x.Symbol.Value not in self.tickers_to_ignore
56    ]
57if len(selected) > self.fundamental_count:
58    selected = [
59        x for x in sorted(
60            selected, 
61            key=self.fundamental_sorting_key, 
62            reverse=True)[:self.fundamental_count]]
63
64for stock in selected:
65    symbol: Symbol = stock.Symbol
66    self.current_fundamental.append(symbol)
67    
68    # make sure data are consecutive
69    if symbol not in self.data or symbol not in self.previous_fundamental:
70        self.data[symbol] = SymbolData(self.period)
71    
72# return newly selected symbols
73return self.current_fundamental
74
75def OnData(self, data: Slice) -> None:
76for stock_symbol in self.current_fundamental:
77    # stock has to have subscribed option contracts
78    if stock_symbol not in self.subscribed_contracts:
79        continue
80    
81    if self.Securities[stock_symbol].IsDelisted:
82        continue
83    # check if any of the subscribed contracts expired
84    if self.subscribed_contracts[stock_symbol].expiry_date - timedelta(days=1) <= self.Time.date():
85        for c in self.subscribed_contracts[stock_symbol].contracts:
86            self.RemoveOptionContract(c)
87        
88        self.subscribed_contracts[stock_symbol].contracts.clear()
89        
90        # remove Contracts object for current symbol
91        del self.subscribed_contracts[stock_symbol]
92        
93    else:
94        # collect volumes
95        stock_volume: Union[None, float] = data[stock_symbol].Value if stock_symbol in data and data[stock_symbol] else None
96        
97        option_volumes: List[float] = []
98        option_contracts: List[Symbol] = self.subscribed_contracts[stock_symbol].contracts
99        
100        for option_contract in option_contracts:
101            if option_contract in data and data[option_contract]:
102                # option volume isn't in data object
103                option_volumes.append(self.Securities[option_contract].Volume)
104        
105        # make sure all volumes were collected       
106        if stock_volume is not None and len(option_volumes) == len(option_contracts):
107            # store volumes
108            if stock_symbol not in self.data:
109                self.data[stock_symbol] = SymbolData(self.period)
110                
111            # store minute stock volume
112            self.data[stock_symbol].stock_minute_volumes.append(stock_volume)
113            
114            # store total minute option volume
115            self.data[stock_symbol].options_minute_volumes.append(sum(option_volumes))
116        
117        if stock_symbol in self.data:
118            if self.Time.hour == 16 and self.Time.minute == 0 and self.data[stock_symbol].minute_volumes_ready(self.min_period_len):
119                self.data[stock_symbol].update_daily_volumes()
120# perform trade, when there are no active contracts for current selection
121if len(self.subscribed_contracts) == 0 and not self.subscribing_flag and self.Time.hour != 0:
122    OS_ratio_change: Dict[Symbol, float] = {}
123    
124    for stock_symbol in self.current_fundamental:
125        if stock_symbol not in self.data:
126            continue
127        
128        if self.Securities[stock_symbol].IsDelisted:
129            continue
130        symbol_obj: SymbolData = self.data[stock_symbol]
131        
132        # each stock has to have at least minimum daily volumes
133        if symbol_obj.daily_volumes_ready(self.min_period_len):
134            symbol_obj.update_os_ratios()
135        else:
136            self.data[stock_symbol].clear_data()
137            del self.data[stock_symbol]
138        
139        # OS ratios data has to be ready
140        if not symbol_obj.is_ready():
141            continue
142        
143        OS_ratios_values: List[float] = [x for x in symbol_obj.os_ratios]
144        mean_os_ratios_value: float = np.mean(OS_ratios_values)
145        
146        OS_ratio_change_value: float = (OS_ratios_values[0] - mean_os_ratios_value) / mean_os_ratios_value
147        
148        # store OS ratio change keyed by stock symbol
149        OS_ratio_change[stock_symbol] = OS_ratio_change_value
150    
151    # make sure there are enough stocks with data    
152    if len(OS_ratio_change) >= self.quantile:
153        # perform selection
154        quantile: int = int(len(OS_ratio_change) / self.quantile)
155        sorted_by_ratio: List[Symbol] = [x[0] for x in sorted(OS_ratio_change.items(), key=lambda item: item[1])]
156        
157        # long low and short high 
158        long: List[Symbol] = sorted_by_ratio[:quantile]
159        short: List[Symbol] = sorted_by_ratio[-quantile:]
160        
161        # trade execution
162        targets: List[PortfolioTarget] = []
163        for i, portfolio in enumerate([long, short]):
164            for symbol in portfolio:
165                if symbol in data and data[symbol]:
166                    targets.append(PortfolioTarget(symbol, ((-1) ** i) / len(portfolio)))
167        self.SetHoldings(targets, True)
168    
169    elif not self.selection_flag:
170        # liquidate all positions from previous selection
171        self.Liquidate()
172    
173    if len(self.current_fundamental) != 0 and self.months_counter % 12 == 0:
174        # reinitialize previous fundamental
175        self.previous_fundamental = list(map(lambda symbol: symbol, self.current_fundamental))
176        # make space for new stocks from fundamental
177        self.current_fundamental.clear()
178        # increase month counter
179        self.months_counter += 1 
180        # perform next selection
181        self.selection_flag = True
182        
183    elif not self.subscribing_flag and len(self.current_fundamental) != 0:
184        # perform new subscribtion without selection
185        self.subscribing_flag = True
186        # increase months counter
187        self.months_counter += 1
188    
189    return # skip to firstly perform fundamental selection and then contracts subscribing
190
191# subscribe to new contracts after selection
192if len(self.subscribed_contracts) == 0 and self.subscribing_flag:
193    for symbol in self.current_fundamental:
194        if self.Securities[symbol].IsDelisted:
195            continue
196        # get all contracts for current stock symbol
197        contracts: List[Symbol] = self.OptionChainProvider.GetOptionContractList(symbol, self.Time)
198        # get current price for etf
199        underlying_price: float = self.Securities[symbol].Price
200        
201        # get strikes from commodity future contracts
202        strikes: List[float] = [i.ID.StrikePrice for i in contracts]
203        
204        # can't filter contracts, if there isn't any strike price
205        if len(strikes) <= 0 or underlying_price == 0:
206            continue
207        
208        atm_strike: float = min(strikes, key=lambda x: abs(x-underlying_price))
209        itm_strike: float = min(strikes, key=lambda x: abs(x-(underlying_price*0.95)))
210        otm_strike: float = min(strikes, key=lambda x: abs(x-(underlying_price*1.05)))
211        
212        # filter calls and puts contracts with one month expiry
213        atm_calls, atm_puts = self.FilterContracts(atm_strike, contracts, underlying_price)
214        itm_calls, itm_puts = self.FilterContracts(itm_strike, contracts, underlying_price)
215        otm_calls, otm_puts = self.FilterContracts(otm_strike, contracts, underlying_price)
216        
217        # make sure, there is at least one call and put contract
218        if len(atm_calls) > 0 and len(atm_puts) > 0 and len(itm_calls) > 0 and len(itm_puts) > 0 and len(otm_calls) > 0 and len(otm_puts) > 0:
219            # sort by expiry
220            atm_call, atm_put = self.SortByExpiry(atm_calls, atm_puts)
221            itm_call, itm_put = self.SortByExpiry(itm_calls, itm_puts)
222            otm_call, otm_put = self.SortByExpiry(otm_calls, otm_puts)
223            
224            atm_call_subscriptions: List[SubscriptionDataConfig] = self.SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(atm_call.Underlying)
225            
226            # check if stock's call and put contract was successfully subscribed
227            if atm_call_subscriptions:
228                selected_contracts: List[Symbol] = [atm_call, atm_put, itm_call, itm_put, otm_call, otm_put]
229                
230                for contract in selected_contracts:
231                    # add contract
232                    self.AddOptionContract(contract, Resolution.Minute)
233                    
234                # retrieve expiry date for contracts
235                expiry_date: datetime.date = atm_call.ID.Date.date() if atm_call.ID.Date.date() < atm_put.ID.Date.date() else atm_put.ID.Date.date()
236                # store contracts with expiry date under stock's symbol
237                self.subscribed_contracts[symbol] = Contracts(expiry_date, underlying_price, selected_contracts)
238    
239    # at least one stock has to have successfully subscribed all option contracts, to stop subscribing
240    if len(self.subscribed_contracts) > 0:
241        self.subscribing_flag = False
242
243def FilterContracts(self, 
244                strike: float, 
245                contracts: List[Symbol], 
246                underlying_price: float) -> List[Symbol]:
247''' filter call and put contracts from contracts parameter '''
248''' return call and put contracts '''
249
250calls: List[Symbol] = [] # storing call contracts
251puts: List[Symbol] = [] # storing put contracts
252
253for contract in contracts:
254    # check if contract has one month expiry
255    if self.min_expiry < (contract.ID.Date - self.Time).days < self.max_expiry:
256        # check if contract is call
257        if contract.ID.OptionRight == OptionRight.Call and contract.ID.StrikePrice == strike:
258            calls.append(contract)
259        # check if contract is put
260        elif contract.ID.OptionRight == OptionRight.Put and contract.ID.StrikePrice == strike:
261            puts.append(contract)
262
263# return filtered calls and puts with one month expiry
264return calls, puts
265
266def SortByExpiry(self, 
267            calls: List[Symbol], 
268            puts: List[Symbol]) -> List[Symbol]:
269''' return option call and option put with farest expiry '''
270
271call: List[Symbol] = sorted(calls, key = lambda x: x.ID.Date, reverse=True)[0]
272put: List[Symbol] = sorted(puts, key = lambda x: x.ID.Date, reverse=True)[0]
273
274return call, put
275
276class SymbolData:
277def __init__(self, period: int) -> None:
278self.os_ratios: RollingWindow = RollingWindow[float](period)
279
280self.stock_minute_volumes: List[float] = []
281self.options_minute_volumes: List[float] = []
282
283self.stock_daily_volumes: List[float] = []
284self.options_daily_volumes: List[float] = []
285
286def update_daily_volumes(self) -> None:
287self.stock_daily_volumes.append(sum(self.stock_minute_volumes))
288self.options_daily_volumes.append(sum(self.options_minute_volumes))
289
290self.stock_minute_volumes.clear()
291self.options_minute_volumes.clear()
292
293def update_os_ratios(self) -> None:
294os_ratio_value = sum(self.options_daily_volumes) / sum(self.stock_daily_volumes)
295self.os_ratios.Add(os_ratio_value)
296
297self.stock_daily_volumes.clear()
298self.options_daily_volumes.clear()
299
300def clear_data(self) -> None:
301self.stock_minute_volumes.clear()
302self.options_minute_volumes.clear()
303self.stock_daily_volumes.clear()
304self.options_daily_volumes.clear()
305
306def daily_volumes_ready(self, period: int) -> bool:
307return len(self.stock_daily_volumes) >= period and len(self.options_daily_volumes) >= period
308
309def minute_volumes_ready(self, period: int) -> bool:
310return len(self.stock_minute_volumes) >= period and len(self.options_minute_volumes) >= period
311
312def is_ready(self) -> bool:
313return self.os_ratios.IsReady
314@dataclass
315class Contracts():
316expiry_date: datetime.date
317underlying_price: float
318contracts: List[Symbol]
319
320# Custom fee model
321class CustomFeeModel(FeeModel):
322def GetOrderFee(self, parameters: OrderFeeParameters) -> OrderFee:
323fee: float = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
324return OrderFee(CashAmount(fee, "USD"))