资产类别内的套息因子

1from AlgorithmImports import *
2#endregion
3class TermStructureCommodities(QCAlgorithm):
4def Initialize(self):
5 self.SetStartDate(2010, 1, 1)
6 self.SetCash(100000)
7 
8 commodities:dict = {
9     'CME_S1': Futures.Grains.Soybeans,
10     'CME_W1' : Futures.Grains.Wheat,
11     'CME_SM1' : Futures.Grains.SoybeanMeal,
12     'CME_C1' : Futures.Grains.Corn,
13     'CME_O1' : Futures.Grains.Oats,
14     'CME_LC1' : Futures.Meats.LiveCattle,
15     'CME_FC1' : Futures.Meats.FeederCattle,
16     'CME_LN1' : Futures.Meats.LeanHogs,
17     'CME_GC1' : Futures.Metals.Gold,
18     'CME_SI1' : Futures.Metals.Silver,
19     'CME_PL1' : Futures.Metals.Platinum,
20     'CME_HG1' : Futures.Metals.Copper,
21     'CME_LB1' : Futures.Forestry.RandomLengthLumber,
22     'CME_NG1' : Futures.Energies.NaturalGas,
23     'CME_PA1' : Futures.Metals.Palladium,
24     'CME_DA1' : Futures.Dairy.ClassIIIMilk,
25     
26     'CME_RB1' : Futures.Energies.Gasoline,
27     # 'ICE_WT1' : Futures.Energies.CrudeOilWTI,
28     'ICE_CC1' : Futures.Softs.Cocoa,
29     'ICE_O1' : Futures.Energies.HeatingOil,
30     # 'ICE_SB1' : Futures.Softs.Sugar11CME,
31 }
32                 
33 currencies:dict = {
34     'CME_AD1' : Futures.Currencies.AUD,
35     'CME_BP1' : Futures.Currencies.GBP,
36     'CME_CD1' : Futures.Currencies.CAD,
37     'CME_EC1' : Futures.Currencies.EUR,
38     'CME_JY1' : Futures.Currencies.JPY,
39     'CME_MP1' : Futures.Currencies.MXN,
40     'CME_NE1' : Futures.Currencies.NZD,
41     'CME_SF1' : Futures.Currencies.CHF,
42 }
43                 
44 equities:dict = {
45     'CME_NQ1' : Futures.Indices.NASDAQ100EMini,
46     'CME_ES1' : Futures.Indices.SP500EMini,
47     'LIFFE_Z1' : Futures.Indices.FTSEEmergingEmini,
48     'SGX_NK1' : Futures.Indices.Nikkei225Dollar,
49     # 'ICE_DX1' : Futures.Indices.,
50     # 'EUREX_FDAX1' : Futures.Indices.,
51     # 'EUREX_FSMI1' : Futures.Indices.,
52     # 'EUREX_FSTX1' : Futures.Indices.,
53     # 'LIFFE_FCE1' : Futures.Indices.,
54 }
55 bonds:dict = {
56     'CME_TY1' : Futures.Financials.Y10TreasuryNote,      # 10 Yr Note Futures, Continuous Contract #1
57     'CME_FV1' : Futures.Financials.Y5TreasuryNote,      # 5 Yr Note Futures, Continuous Contract #1
58     'CME_TU1' : Futures.Financials.Y2TreasuryNote,      # 2 Yr Note Futures, Continuous Contract #1
59     # 'ASX_XT' : Futures.Financials.,     # 10 Year Commonwealth Treasury Bond Futures, Continuous Contract #1
60     # 'ASX_YT' : Futures.Bonds.,     # 3 Year Commonwealth Treasury Bond Futures, Continuous Contract #1
61     # 'MX_CGB' : Futures.Bonds.,     # Ten-Year Government of Canada Bond Futures, Continuous Contract #1
62     # 'EUREX_FGBL' : Futures.Bonds.,  # Euro-Bund (10Y) Futures, Continuous Contract #1
63     # 'EUREX_FBTP' : Futures.Bonds., # Long-Term Euro-BTP Futures, Continuous Contract #1
64     # 'EUREX_FGBM' : Futures.Bonds.,  # Euro-Bobl Futures, Continuous Contract #1
65     # 'EUREX_FGBS' : Futures.Bonds.,  # Euro-Schatz Futures, Continuous Contract #1 
66     # 'SGX_JB' : Futures.Bonds.,      # SGX 10-Year Mini Japanese Government Bond Futures
67     # 'LIFFE_R' : Futures.Bonds.      # Long Gilt Futures, Continuous Contract #1
68     }
69 self.asset_classes:dict[str, dict] = {}
70 self.asset_classes['commodities'] = commodities
71 self.asset_classes['currencies'] = currencies
72 self.asset_classes['equities'] = equities
73 self.asset_classes['bonds'] = bonds
74 self.futures_info:dict = {}
75 self.min_expiration_days:int = 2
76 self.max_expiration_days:int = 360
77 for asset_class_name, asset_class in self.asset_classes.items():
78     for qp_symbol, qc_future in asset_class.items():
79         # QP futures
80         data:Security = self.AddData(QuantpediaFutures, qp_symbol, Resolution.Daily)
81         data.SetFeeModel(CustomFeeModel())
82         data.SetLeverage(5)
83         
84         # QC futures
85         future:Future = self.AddFuture(qc_future, Resolution.Daily, dataNormalizationMode=DataNormalizationMode.Raw)
86         future.SetFilter(timedelta(days=self.min_expiration_days), timedelta(days=self.max_expiration_days))
87         self.futures_info[future.Symbol.Value] = FuturesInfo(data.Symbol)
88 self.recent_month:int = -1
89def find_and_update_contracts(self, futures_chain, symbol):
90 near_contract:FuturesContract = None
91 dist_contract:FuturesContract = None
92 if symbol in futures_chain:
93     contracts:list = [contract for contract in futures_chain[symbol] if contract.Expiry.date() > self.Time.date()]
94     if len(contracts) >= 2:
95         contracts:list = sorted(contracts, key=lambda x: x.Expiry, reverse=False)
96         near_contract = contracts[0]
97         dist_contract = contracts[1]
98 self.futures_info[symbol].update_contracts(near_contract, dist_contract)
99def OnData(self, data):
100 if data.FutureChains.Count > 0:
101     for symbol, futures_info in self.futures_info.items():
102         if self.securities[futures_info.quantpedia_future].get_last_data() and self.time.date() > QuantpediaFutures.get_last_update_date()[futures_info.quantpedia_future]:
103             self.liquidate(futures_info.quantpedia_future)
104             futures_info.near_contract = None
105             futures_info.distant_contract = None
106         # check if near contract is expired or is not initialized
107         if not futures_info.is_initialized() or \
108             (futures_info.is_initialized() and futures_info.near_contract.Expiry.date() == self.Time.date()):
109             self.find_and_update_contracts(data.FutureChains, symbol)
110 roll_return:dict[Symbol, float] = {}
111 rebalance_flag:bool = False
112 # roll return calculation
113 for symbol, futures_info in self.futures_info.items():
114     # futures data is present in the algorithm
115     if futures_info.quantpedia_future in data and data[futures_info.quantpedia_future]:
116         # new month rebalance
117         if self.Time.month != self.recent_month:
118             self.recent_month = self.Time.month
119             rebalance_flag = True
120         if rebalance_flag:
121             if futures_info.is_initialized():
122                 near_c = futures_info.near_contract
123                 dist_c = futures_info.distant_contract
124                 if self.Securities.ContainsKey(near_c.Symbol) and self.Securities.ContainsKey(dist_c.Symbol):
125                     raw_price1:float = self.Securities[near_c.Symbol].Close * self.Securities[symbol].SymbolProperties.PriceMagnifier
126                     raw_price2:float = self.Securities[dist_c.Symbol].Close * self.Securities[symbol].SymbolProperties.PriceMagnifier
127                     if raw_price1 != 0 and raw_price2 != 0:
128                         roll_return[futures_info.quantpedia_future] = raw_price1 / raw_price2 - 1
129 if rebalance_flag:
130     weight:dict[Symbol, float] = {}
131     if len(roll_return) != 0:
132         long:list[Symbol] = []
133         short:list[Symbol] = []
134         class_count:int = len(self.asset_classes)
135         # sort by roll return
136         sorted_by_roll:list = sorted(roll_return.items(), key = lambda x: x[1], reverse = True)
137         positive_roll:list[Symbol] = [x for x in sorted_by_roll if x[1] > 0]
138         negative_roll:list[Symbol] = [x for x in sorted_by_roll if x[1] < 0]
139     
140         # ranking
141         rank_long:dict = {}
142         rank_short:dict = {}
143         score = len(positive_roll)
144         for symbol_data in positive_roll:
145             rank_long[symbol_data[0]] = score
146             score -= 1
147             
148         score = -1
149         for symbol_data in negative_roll:
150             rank_short[symbol_data[0]] = score
151             score -= 1
152         
153         total_items = len(positive_roll + negative_roll)
154         if total_items != 0:
155             # weighting within portfolio
156             if rank_long:
157                 partial_weight_long = 1 / sum([abs(score) for symbol, score in rank_long.items()])
158     
159                 for symbol, r in rank_long.items():
160                     weight[symbol] = (1 / class_count) * (r * partial_weight_long)
161             if rank_short:
162                 partial_weight_short = 1 / sum([abs(score) for symbol, score in rank_short.items()])
163             
164                 for symbol, r in rank_short.items():
165                     weight[symbol] = (1 / class_count) * (r * partial_weight_short)
166 
167     # trade execution
168     invested:list[Symbol] = [x.Key for x in self.Portfolio if x.Value.Invested]
169     for symbol in invested:
170         if symbol not in weight:
171             self.Liquidate(symbol)
172     for symbol, w in weight.items():
173         self.SetHoldings(symbol, w)
174class FuturesInfo():
175def __init__(self, quantpedia_future:Symbol) -> None:
176 self.quantpedia_future:Symbol = quantpedia_future
177 self.near_contract:FuturesContract = None
178 self.distant_contract:FuturesContract = None
179
180def update_contracts(self, near_contract:FuturesContract, distant_contract:FuturesContract) -> None:
181 self.near_contract = near_contract
182 self.distant_contract = distant_contract
183
184def is_initialized(self) -> bool:
185 return self.near_contract is not None and self.distant_contract is not None
186
187# Custom fee model.
188class CustomFeeModel():
189def GetOrderFee(self, parameters):
190 fee = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
191 return OrderFee(CashAmount(fee, "USD"))
192# Quantpedia data.
193# NOTE: IMPORTANT: Data order must be ascending (datewise)
194class QuantpediaFutures(PythonData):
195_last_update_date:Dict[Symbol, datetime.date] = {}
196@staticmethod
197def get_last_update_date() -> Dict[Symbol, datetime.date]:
198return QuantpediaFutures._last_update_date
199def GetSource(self, config, date, isLiveMode):
200 return SubscriptionDataSource("data.quantpedia.com/backtesting_data/futures/{0}.csv".format(config.Symbol.Value), SubscriptionTransportMedium.RemoteFile, FileFormat.Csv)
201def Reader(self, config, line, date, isLiveMode):
202 data = QuantpediaFutures()
203 data.Symbol = config.Symbol
204 
205 if not line[0].isdigit(): return None
206 split = line.split(';')
207 
208 data.Time = datetime.strptime(split[0], "%d.%m.%Y") + timedelta(days=1)
209 data['back_adjusted'] = float(split[1])
210 data['spliced'] = float(split[2])
211 data.Value = float(split[1])
212 if config.Symbol not in QuantpediaFutures._last_update_date:
213     QuantpediaFutures._last_update_date[config.Symbol] = datetime(1,1,1).date()
214 if data.Time.date() > QuantpediaFutures._last_update_date[config.Symbol]:
215     QuantpediaFutures._last_update_date[config.Symbol] = data.Time.date()
216 return data