Original paper
Abstract
We propose a novel measure of the amount of arbitrage capital allocated to the momentum strategy to test whether arbitrageurs can have a destabilizing effect in the stock market. Our measure, which we dub comomentum, aims to capture the extent to which momentum trades by arbitrageurs become crowded. Specifically, we define comomentum as the high-frequency abnormal return correlation among stocks that a typical momentum strategy would speculate on. We show that during periods of low comomentum, momentum strategies are profitable and stabilizing, reflecting an underreaction phenomenon that arbitrageurs correct. In contrast, during periods of high comomentum, these strategies become unprofitable and tend to crash, reflecting prior overreaction due to the momentum crowd pushing prices away from fundamentals. Moreover, both firm-level and international versions of comomentum forecast returns in a manner consistent with our interpretation.
Trading rules
- Focus on stocks from NYSE, Amex, and Nasdaq.
- Exclude stocks with a value under $5 and those that fall in the smallest NYSE size decile.
- Monthly procedure:
- Categorize stocks into ten groups based on their returns over the past 12 months, excluding the last month.
- For each of these groups, find pairwise partial correlations using using 52 weekly returns.
- Adjust for FamaFrench's three factors to eliminate comovement arising from known risk factors.
- Determine ComomL (loser comomentum) as the average pairwise partial correlation for the loser decile.
- If the current month's ComomL is among the 20% lowest in its historical records, implement the standard momentum strategy by taking long positions in the top-performing (10%) group and short positions in the lowest-performing (10%) group.
Python code
Backtrader
To implement the trading strategy described, you can use the Backtrader library in Python. Here is an example of the Python code to set up the investment universe, exclude the undesired stocks, calculate the required values, and trade the strategy:
```python import backtrader as bt import pandas as pd import numpy as np from scipy import stats import statsmodels.api as sm
class MomentumStrategy(bt.Strategy): params = dict( momentum_lookback=11, weekly_returns_lookback=52, comoml_history=20, deciles=10, quintiles=5 )
def __init__(self):
self.returns = {}
self.comoml_values = []
def next(self):
# Exclude stocks priced below $5 and in the bottom NYSE size decile
universe = [d for d in self.datas if d.close[0] >= 5 and d._name not in self.get_bottom_decile()]
if not universe:
return
# Sort stocks into deciles based on 12-month returns (excluding the most recent month)
universe_deciles = self.get_deciles(universe)
# Calculate pairwise partial correlations for each decile using 52 weekly returns
correlations = [self.calculate_partial_corr(decile) for decile in universe_deciles]
# Determine ComomL (loser comomentum) as the average pairwise partial correlation for the loser decile
comoml = np.mean(correlations[-1])
self.comoml_values.append(comoml)
# Trade classical momentum strategy if the current month's ComomL falls in the lowest quintile of historical ComomL values
if len(self.comoml_values) >= self.params.comoml_history:
comoml_threshold = np.percentile(self.comoml_values[-self.params.comoml_history:], 100 / self.params.quintiles)
if comoml <= comoml_threshold:
for d in universe_deciles[0]:
self.order_target_percent(d, target=1 / len(universe_deciles[0]))
for d in universe_deciles[-1]:
self.order_target_percent(d, target=-1 / len(universe_deciles[-1]))
def get_deciles(self, universe):
returns = [(d, d.close.get(size=self.params.momentum_lookback)[-1] / d.close.get(size=self.params.momentum_lookback)[0]) for d in universe]
sorted_returns = sorted(returns, key=lambda x: x[1], reverse=True)
return np.array_split([r[0] for r in sorted_returns], self.params.deciles)
def get_bottom_decile(self):
# Replace 'NYSE_data' with the actual data source for NYSE stocks' size
nyse_sizes = pd.read_csv("NYSE_data.csv")['size']
return set(nyse_sizes.sort_values().iloc[:len(nyse_sizes) // self.params.deciles].index)
def calculate_partial_corr(self, decile):
weekly_returns = [self.calculate_weekly_returns(d) for d in decile]
ff_factors = sm.add_constant(self.get_fama_french_factors()) # Add constant term to the linear model
correlations = []
for i in range(len(decile)):
for j in range(i + 1, len(decile)):
x1 = weekly_returns[i]
x2 = weekly_returns[j]
x1_resid = sm.OLS(x1, ff_factors).fit().resid
x2_resid = sm.OLS(x2, ff_factors).fit().resid
corr, _ =