Original paper
Abstract
In this note we revisit the 2011 and 2013 papers of Blitz, Huij, and Martens (BHM2011), and Blitz, Huij, Lansdorp, and Verbeek (BHLV2013) in which momentum and reversal strategies on residual returns are proposed. Our results indicate that the main findings of these studies, that residual momentum and reversal strategies exhibit significantly lower time-varying exposures to the Fama-French factors than conventional momentum and reversal strategies and consequently have significantly higher return-to-risk ratios, are robust across different global stock universes and out-of-sample periods after the publication of the first results.
Keywords:Â residual momentum, residual reversal, factor investing
Trading rules
- Choose stocks primarily from NYSE, AMEX, and NASDAQ with a price higher than $1.
- Avoid including closed-end funds, REITs, unit trusts, ADRs, and non-domestic stocks.
- Filter for the top 10% of stocks based on market capitalization.
- Define strategy as top-minus-bottom decile portfolio based on monthly ranking of past 12-month residual returns (excluding most recent month), standardized by standard deviation of residual returns in the same period.
- Monthly, determine net returns for all stocks using a three-year regression analysis.
- Employ Fama and French's trio of factors as the main elements in the regression analysis for qualified stocks.
- Equally weight and rebalance portfolio monthly.
Python code
Backtrader
import backtrader as bt
import pandas as pd
from sklearn.linear_model import LinearRegression
class ResidualMomentum(bt.Strategy):
params = (
('lookback', 12),
('exclude_recent', 1),
('rebalance_period', 21),
('num_stocks', 0.1),
)
def __init__(self):
self.counter = 0
self.ff_factors = get_fama_french_factors() # Implement function to get Fama-French factors data
def next(self):
if self.counter % self.params.rebalance_period == 0:
eligible_stocks = self.get_eligible_stocks()
residual_returns = self.calculate_residual_returns(eligible_stocks)
selected_stocks = self.select_stocks(residual_returns)
self.adjust_portfolio(selected_stocks)
self.counter += 1
def get_eligible_stocks(self):
pass
# Implement function to get eligible stocks from NYSE, AMEX, and NASDAQ, filtering out excluded types and priced over $1
def calculate_residual_returns(self, eligible_stocks):
residual_returns = {}
for stock in eligible_stocks:
stock_data = self.get_stock_data(stock)
stock_returns = self.calculate_stock_returns(stock_data)
residual_return = self.calculate_stock_residual_return(stock_returns)
residual_returns[stock] = residual_return
return residual_returns
def select_stocks(self, residual_returns):
num_stocks = int(len(residual_returns) * self.params.num_stocks)
sorted_stocks = sorted(residual_returns, key=residual_returns.get, reverse=True)
return sorted_stocks[:num_stocks]
def adjust_portfolio(self, selected_stocks):
weight = 1.0 / len(selected_stocks)
for stock in selected_stocks:
self.order_target_percent(stock, target=weight)
def get_stock_data(self, stock):
pass
# Implement function to get stock data needed for regression analysis and stock returns calculation
def calculate_stock_returns(self, stock_data):
stock_data['return'] = stock_data['close'].pct_change()
return stock_data
def calculate_stock_residual_return(self, stock_returns):
lookback_range = self.params.lookback - self.params.exclude_recent
X = self.ff_factors.iloc[-lookback_range:]
y = stock_returns['return'].iloc[-lookback_range:]
model = LinearRegression()
model.fit(X, y)
residuals = y - model.predict(X)
return residuals.mean() / residuals.std()This code outlines the main structure of the Residual Momentum strategy using Backtrader. You will need to implement additional functions such as get_fama_french_factors(), get_eligible_stocks(), and get_stock_data(), which are specific to your data sources for the Fama-French factors and stock data. Make sure to handle the data and date alignments correctly when implementing these functions.