大宗商品 · 全球 · 差价合约、期货 · 每月 · 全球 Free

特有商品动量

登录后收藏

学术论文

Idiosyncratic Momentum in Commodity Futures

作者Idiosyncratic Momentum in Commodity Futures [点击查看论文]

机构

?Sarasin & Partners LLP
?Sarasin & Partners

论文链接https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3035397

策略概要

投资范围包括28种商品的期货合约。平均交易量低于1,000份合约的期货被排除在外。每个月，使用一个模型估计商品的特质回报，其中回报基于阿尔法、因子模拟投资组合和残差回报，参数使用OLS回归估计。因子溢价使用Fama & French方法构建，投资组合基于对冲压力（HP）、展期收益率、规模和价值因子。对冲压力通过未平仓合约衡量；展期收益率基于合约交割排名；价值基于现货价格的对数比率；规模由未平仓合约和合约价值定义。投资组合根据其3个月期间的残差回报，做多前7种商品，做空后7种商品。投资组合每月重新平衡，每种商品等权重。该策略旨在捕捉商品期货的因子溢价。

II. 策略合理性

动量效应有两种解释：行为的和基于风险的。在商品中，期货的回报不遵循随机游走，从而允许基于过去表现模式的盈利策略。特质回报动量源于时变动量暴露于系统性因子和传统策略面临的动量崩盘的证据。传统的动量策略在表现强劲时期对系统性因子产生正载荷，在表现疲软时期产生负载荷，从而在因子表现发生变化时造成损失。相比之下，将回报分解为系统性和特质性成分的特质回报动量提供了一种更稳健、风险调整后的策略，该策略始终优于传统策略。

回测表现

波动率29.42%

夏普比率1.05

索提诺比率0.151

胜率49%

完整 Python 代码

1from AlgorithmImports import *
2import data_tools
3import statsmodels.api as sm
4import numpy as np
5#endregion
6
7class IdiosyncraticCommodityMomentum(QCAlgorithm):
8
9def Initialize(self):
10self.SetStartDate(2004, 1, 1)
11self.SetCash(100000)
12   
13tickers:dict[str, str] = {
14    "CME_S1" : Futures.Grains.Soybeans,         # Soybean Futures, Continuous Contract
15    "CME_W1" : Futures.Grains.Wheat,            # Wheat Futures, Continuous Contract
16    "CME_SM1" : Futures.Grains.SoybeanMeal,     # Soybean Meal Futures, Continuous Contract
17    "CME_BO1" : Futures.Grains.SoybeanOil,      # Soybean Oil Futures, Continuous Contract
18    "CME_C1" : Futures.Grains.Corn,             # Corn Futures, Continuous Contract
19    "CME_O1" : Futures.Grains.Oats,             # Oats Futures, Continuous Contract
20    "CME_LC1" : Futures.Meats.LiveCattle,       # Live Cattle Futures, Continuous Contract
21    "CME_FC1" : Futures.Meats.FeederCattle,     # Feeder Cattle Futures, Continuous Contract
22    "CME_LN1" : Futures.Meats.LeanHogs,         # Lean Hog Futures, Continuous Contract
23    "CME_GC1" : Futures.Metals.Gold,            # Gold Futures, Continuous Contract
24    "CME_SI1" : Futures.Metals.Silver,          # Silver Futures, Continuous Contract
25    "CME_PL1" : Futures.Metals.Platinum,        # Platinum Futures, Continuous Contract
26    "CME_HG1" : Futures.Metals.Copper,          # Copper Futures, Continuous Contract
27    "CME_LB1" : Futures.Forestry.RandomLengthLumber,  # Random Length Lumber Futures, Continuous Contract
28    "CME_PA1" : Futures.Metals.Palladium,       # Palladium Futures, Continuous Contract
29    "CME_DA1" : Futures.Dairy.ClassIIIMilk,     # Class III Milk Futures
30    "CME_RB1" : Futures.Energies.Gasoline,      # Gasoline Futures, Continuous Contract
31    "ICE_CC1" : Futures.Softs.Cocoa,            # Cocoa Futures, Continuous Contract 
32    "ICE_CT1" : Futures.Softs.Cotton2,          # Cotton No. 2 Futures, Continuous Contract #1
33    "ICE_KC1": Futures.Softs.Coffee,            # Coffee C Futures, Continuous Contract #1
34    "ICE_O1" : Futures.Energies.HeatingOil,     # Heating Oil Futures, Continuous Contract
35    "ICE_OJ1": Futures.Softs.OrangeJuice,       # Orange Juice Futures, Continuous Contract #1
36    "ICE_SB1" : Futures.Softs.Sugar11CME,       # Sugar No. 11 Futures, Continuous Contract
37}
38
39self.ranking_period:int = 3
40self.month_period:int = 21
41self.one_year_period:int = 12 * self.month_period
42self.period:int = 5.5 * self.one_year_period
43
44self.leverage:int = 5
45self.trade_count:int = 4
46self.percentage_from_total_count:float = 0.15
47self.min_prices:int = 15
48self.wanted_monthly_returns:int = 1
49self.qp_max_missing_days:int = 5
50self.cot_max_missing_days:int = 10
51self.futures_max_missing_days:int = 5
52
53self.hedging_pressure_factor_symbols:list[Symbol, bool] = []
54self.hedging_pressure_factor_vector:list[float] = []
55
56self.term_structure_factor_symbols:list[Symbol, bool] = []
57self.term_structure_factor_vector:list[float] = []
58
59self.value_factor_symbols:list[Symbol, bool] = []
60self.value_factor_vector:list[float] = []
61
62self.data:dict[Symbol, data_tools.Symbol] = {}
63self.futures_data:dict[str, data_tools.FuturesData] = {}
64
65min_expiration_days:int = 0
66max_expiration_days:int = 360
67
68for qp_ticker, qc_ticker in tickers.items():
69    # Add quantpedia back-adjusted data.
70    security = self.AddData(data_tools.QuantpediaFutures, qp_ticker, Resolution.Daily)
71    security.SetFeeModel(data_tools.CustomFeeModel())
72    security.SetLeverage(self.leverage)
73
74    qp_symbol:Symbol = security.Symbol
75    
76    cot_ticker:str = 'Q' + qp_ticker.split('_')[1][:-1]
77    cot_symbol:Symbol = self.AddData(data_tools.CommitmentsOfTraders, cot_ticker, Resolution.Daily).Symbol
78
79    # QC futures
80    future:Future = self.AddFuture(qc_ticker, Resolution.Daily, dataNormalizationMode=DataNormalizationMode.Raw)
81    future.SetFilter(timedelta(days=min_expiration_days), timedelta(days=max_expiration_days))
82
83    future_ticker:str = future.Symbol.Value
84    self.futures_data[future_ticker] = data_tools.FuturesData(self.ranking_period)
85
86    self.data[qp_symbol] = data_tools.SymbolData(cot_symbol, future_ticker,
87        self.ranking_period * 4, self.period)
88
89self.recent_month:int = -1
90self.settings.daily_precise_end_time = False
91self.settings.minimum_order_margin_portfolio_percentage = 0.
92
93def FindAndUpdateContracts(self, futures_chain, ticker:str) -> None:
94near_contract:FuturesContract = None
95dist_contract:FuturesContract = None
96
97if ticker in futures_chain:
98    contracts:list[:FuturesContract] = [contract for contract in futures_chain[ticker] if contract.Expiry.date() > self.Time.date()]
99
100    if len(contracts) >= 2:
101        contracts:list[:FuturesContract] = sorted(contracts, key=lambda x: x.Expiry, reverse=False)
102        near_contract = contracts[0]
103        dist_contract = contracts[1]
104
105self.futures_data[ticker].update_contracts(near_contract, dist_contract)
106
107def OnData(self, data):
108curr_date:datetime.date = self.Time.date()
109
110for qp_symbol, symbol_obj in self.data.items():
111    # store daily price
112    if qp_symbol in data and data[qp_symbol]:
113        price:float = data[qp_symbol].Value
114        spliced:float = data[qp_symbol].GetProperty('spliced')
115
116        symbol_obj.update_prices(price)
117
118    cot_symbol:Symbol = symbol_obj.cot_symbol
119    if cot_symbol in data and data[cot_symbol]:
120        speculator_long_count:float = data[cot_symbol].GetProperty('LARGE_SPECULATOR_LONG')
121        speculator_short_count:float = data[cot_symbol].GetProperty('LARGE_SPECULATOR_SHORT')
122        
123        if speculator_long_count != 0 and speculator_short_count != 0:
124            hedging_pressure_value:float = speculator_long_count / (speculator_long_count + speculator_short_count)
125            symbol_obj.update_hedging_pressure_values(hedging_pressure_value)
126
127 # daily update qc future data
128if data.FutureChains.Count > 0:
129    for ticker, future_obj in self.futures_data.items():
130        # check if near contract is expired or is not initialized
131        if not future_obj.is_initialized() or \
132            (future_obj.is_initialized() and future_obj.near_contract.Expiry.date() == curr_date):
133            self.FindAndUpdateContracts(data.FutureChains, ticker)
134
135        # update QC futures rolling return
136        if future_obj.is_initialized():
137            near_c:FuturesContract = future_obj.near_contract
138            dist_c:FuturesContract = future_obj.distant_contract
139
140            if near_c.Symbol in data and data[near_c.Symbol] and dist_c.Symbol in data and data[dist_c.Symbol]:
141                near_price:float = data[near_c.Symbol].Value * self.Securities[ticker].SymbolProperties.PriceMagnifier
142                dist_price:float = data[dist_c.Symbol].Value * self.Securities[ticker].SymbolProperties.PriceMagnifier
143
144                if near_price != 0 and dist_price != 0:
145                    roll_yield:float = near_price / dist_price
146                    future_obj.update_roll_yields(roll_yield)
147
148# rebalance monthly
149if self.Time.month == self.recent_month:
150    return
151self.recent_month = self.Time.month
152
153# Factor calculation data.
154hedging_pressure:dict[Symbol, float] = {}
155roll_yield:dict[Symbol, float] = {}
156value:dict[Symbol, float] = {}
157custom_data_last_update_date: Dict[Symbol, datetime.date] = data_tools.LastDateHandler.get_last_update_date()
158
159for qp_symbol, symbol_obj in self.data.items():
160    future_ticker:str = symbol_obj.future_ticker
161
162    # check if data is still coming
163    if any([self.securities[symbol].get_last_data() and self.time.date() > custom_data_last_update_date[symbol] for symbol in [qp_symbol, symbol_obj.cot_symbol]]):
164        self.liquidate(qp_symbol)
165        continue
166
167    if symbol_obj.monthly_prices_ready(self.min_prices):
168        symbol_obj.update_monthly_returns()
169        symbol_obj.reset_monthly_prices()
170
171    # update metrics
172    if symbol_obj.prices_for_value_factor_ready():
173        value[qp_symbol] = symbol_obj.get_value(self.one_year_period) # The average spot price from 4.5 to 5.5 years ago divided by most recent spot price.
174     
175    if symbol_obj.hedging_pressure_values_ready():
176        hedging_pressure[qp_symbol] = symbol_obj.get_mean_hedging_pressure_values()
177
178    if self.futures_data[future_ticker].roll_yields_ready():
179        roll_yield[qp_symbol] = self.futures_data[future_ticker].get_mean_roll_yields()
180
181if int(len(hedging_pressure) * self.percentage_from_total_count) >= 1:
182    factor_return:float = self.CalcFactorReturn(self.hedging_pressure_factor_symbols, self.wanted_monthly_returns)
183
184    if factor_return != 0:
185        self.hedging_pressure_factor_vector.append(factor_return)
186    else:
187        self.hedging_pressure_factor_vector.clear()
188
189    self.hedging_pressure_factor_symbols = self.GetNewFactorSymbols(hedging_pressure)
190else:
191    # require consecutive data in regression
192    self.hedging_pressure_factor_symbols.clear()
193    self.hedging_pressure_factor_vector
194
195if int(len(roll_yield) * self.percentage_from_total_count) >= 1:
196    factor_return:float = self.CalcFactorReturn(self.term_structure_factor_symbols, self.wanted_monthly_returns)
197
198    if factor_return != 0:
199        self.term_structure_factor_vector.append(factor_return)
200    else:
201        self.term_structure_factor_vector.clear()
202
203    self.term_structure_factor_symbols = self.GetNewFactorSymbols(roll_yield)
204else:
205    # require consecutive data in regression
206    self.term_structure_factor_symbols.clear()
207    self.term_structure_factor_vector.clear()
208
209if int(len(value) * self.percentage_from_total_count) >= 1:
210    factor_return:float = self.CalcFactorReturn(self.value_factor_symbols, self.wanted_monthly_returns)
211
212    if factor_return != 0:
213        self.value_factor_vector.append(factor_return)
214    else:
215        self.value_factor_vector.clear()
216
217    self.value_factor_symbols = self.GetNewFactorSymbols(roll_yield)
218else:
219    # require consecutive data in regression
220    self.value_factor_symbols.clear()
221    self.value_factor_vector.clear()
222
223min_len:int = min(len(self.hedging_pressure_factor_vector), len(self.term_structure_factor_vector), len(self.value_factor_vector))
224
225# all vectors are filled
226if min_len < self.ranking_period:
227    self.Liquidate()
228    return
229
230residual_return:dict[Symbol, float] = {}
231
232for qp_symbol, symbol_obj in self.data.items():
233    if symbol_obj.monthly_returns_ready(min_len):
234        monthly_returns:list[float] = symbol_obj.get_last_n_monthly_returns(min_len)
235            
236        shorten_recent_hp_factor = self.hedging_pressure_factor_vector[-min_len:]
237        shorten_recent_ts_factor = self.term_structure_factor_vector[-min_len:]
238        shorten_recent_v_factor = self.value_factor_vector[-min_len:]
239        
240        # residual return calc.
241        x:list[list[float]] = [shorten_recent_hp_factor, shorten_recent_ts_factor, shorten_recent_v_factor]
242
243        regression_model = self.MultipleLinearRegresion(x, monthly_returns[-min_len:])
244        residual_return[qp_symbol] = sum(regression_model.resid[-self.ranking_period:])
245
246if len(residual_return) < (self.trade_count * 2):
247    self.Liquidate()
248    return
249
250sorted_by_residual_return:list[Symbol] = [x[0] for x in sorted(residual_return.items(), key=lambda item: item[1])]
251long_leg:list[Symbol] = sorted_by_residual_return[-self.trade_count:]
252short_leg:list[Symbol] = sorted_by_residual_return[:self.trade_count]
253
254# trade execution.
255stocks_invested:list[Symbol] = [x.Key.Value for x in self.Portfolio if x.Value.Invested]
256for symbol in stocks_invested:
257    if symbol not in long_leg + short_leg:
258        self.Liquidate(symbol)
259
260for symbol in long_leg:
261    if symbol in data and data[symbol]:
262        self.SetHoldings(symbol, 1 / self.trade_count)
263
264for symbol in short_leg:
265    if symbol in data and data[symbol]:
266        self.SetHoldings(symbol, -1 / self.trade_count)
267
268def MultipleLinearRegresion(self, x, y):
269x = np.array(x).T
270x = sm.add_constant(x)
271result = sm.OLS(endog=y, exog=x).fit()
272return result
273
274def CalcFactorReturn(self, factor_symbols:list, period:int) -> float:
275factor_return:float = 0
276for symbol, long_flag in factor_symbols:
277    if self.data[symbol].monthly_returns_ready(period):
278        commodity_returns = self.data[symbol].get_last_n_monthly_returns(period)
279        
280        for commodity_return in commodity_returns:
281            factor_return += commodity_return if long_flag else -commodity_return
282
283return factor_return
284
285def GetNewFactorSymbols(self, value_by_symbol:dict) -> list:
286sorted_by_value:dict[Symbol, float] = sorted(value_by_symbol.items(), key=lambda x: x[1])
287count:int = int(len(sorted_by_value) * self.percentage_from_total_count)
288long_leg:list[list[Symbol, bool]] = [(x[0], True) for x in sorted_by_value[-count:]]
289short_leg:list[list[Symbol, bool]] = [(x[0], False) for x in sorted_by_value[:count]]
290
291return long_leg + short_leg