Original paper
Abstract
Frazzini and Pedersen’s (2014) Betting Against Beta (BAB) factor is based on the same basic idea as Black’s (1972) beta-arbitrage, but its astonishing performance has generated academic interest and made it highly influential with practitioners. This performance is driven by non-standard procedures used in its construction that effectively, but non-transparently, equal weight stock returns. For each dollar invested in BAB, the strategy commits on average $1.05 to stocks in the bottom 1% of total market capitalization. BAB earns positive returns after accounting for transaction costs, but earns these by tilting toward profitability and investment, exposures for which it is fairly compensated. Predictable biases resulting from the paper’s non-standard beta estimation procedure drive results presented as evidence supporting its underlying theory.
Keywords:Â Factor models, beta-arbitrage, defensive equity, non-standard methods, asset pricing
Trading rules
- Use the CRSP database to choose stocks.
- Calculate each stock's rolling 1-year beta against the MSCI US Equity Index.
- Sort stocks from lowest to highest based on their determined beta.
- Categorize stocks into either low or high beta portfolios.
- Assign weights to stocks based on their beta rankings.
- Adjust portfolios on a monthly basis.
- Rescale both portfolios to have a beta of one at formation.
- Establish zero-cost, zero-beta Betting-Against-Beta portfolio: long low-beta, short high-beta.
- Consider simple modifications (e.g., long bottom beta decile, short top beta decile) to enhance performance.
Python code
Backtrader
Here’s a Backtrader Python code implementing the trading rules you described:
import backtrader as bt
import backtrader.feeds as btfeeds
import pandas as pd
class BetaRanking(bt.Strategy):
params = (
('lookback', 252),
('rebalance_freq', 21),
('num_long', 10),
('num_short', 10)
)
def __init__(self):
self.betas = {}
self.rankings = []
self.rebalance_day = 0
# Compute beta for each stock
for d in self.datas:
self.betas[d._name] = bt.indicators.Beta(d, self.data0, period=self.params.lookback)
def next(self):
self.rebalance_day += 1
if self.rebalance_day % self.params.rebalance_freq != 0:
return
self.rankings = sorted(
self.datas,
key=lambda d: self.betas[d._name][0]
)
longs = self.rankings[:self.params.num_long]
shorts = self.rankings[-self.params.num_short:]
for d in longs:
self.order_target_percent(d, target=1.0 / self.params.num_long)
for d in shorts:
self.order_target_percent(d, target=-1.0 / self.params.num_short)
for d in self.datas:
if d not in longs and d not in shorts:
self.order_target_percent(d, target=0.0)
if __name__ == '__main__':
cerebro = bt.Cerebro()
# Add strategy
cerebro.addstrategy(BetaRanking)
# Load CRSP database
# Replace this part with your actual CRSP data
for stock_data in CRSP_data:
data = btfeeds.PandasData(dataname=stock_data)
cerebro.adddata(data)
# Load MSCI US Equity Index data
msci_data = btfeeds.PandasData(dataname=pd.read_csv('msci_us_equity_index.csv', parse_dates=['date'], index_col='date'))
cerebro.adddata(msci_data, name='msci_us_equity_index')
# Set initial capital and run
cerebro.broker.setcash(100000.0)
cerebro.run()This code implements a Backtrader strategy that calculates rolling betas for each stock relative to the MSCI US Equity Index, ranks stocks based on their betas, and rebalances the portfolio monthly. Remember to replace the data loading part with your actual CRSP data and the MSCI US Equity Index data in a suitable format.