Commodity · Global · CFDs, futures · Monthly · Global Free
Idiosyncratic Commodity Momentum

Academic paper

Idiosyncratic Momentum in Commodity Futures
AuthorsIuliia Shpak; Ben Human; Andrea Nardon
Institute
?Sarasin & Partners LLP
?Sarasin & Partners
Paper linkhttps://papers.ssrn.com/sol3/papers.cfm?abstract_id=3035397
Strategy in a nutshell

This strategy trades 28 commodity futures, excluding low-liquidity contracts (<1,000 average volume). Idiosyncratic returns are estimated monthly via OLS regression using factor mimicking portfolios based on hedging pressure, roll yield, size, and value. The portfolio goes long on the top 7 and short on the bottom 7 commodities by residual returns over a 3-month period. Positions are equally weighted and rebalanced monthly to capture factor premiums systematically.
Economic rationale

Commodity momentum arises from non-random return patterns. Idiosyncratic return momentum isolates residual returns from systematic factors, reducing exposure to factor crashes. This approach provides a robust, risk-adjusted strategy, consistently outperforming conventional momentum methods during varying market conditions.
Backtest performance

Annualised return17.5%
Volatility29.42%
Beta0.062
Sharpe ratio1.05
Sortino ratio0.151
Win rate49%
Full Python code

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