Original paper

SSRN-id2610288.pdf3356.0KB

Abstract

We compare the performance of time-series (TS) and cross-sectional (CS) strategies based on past returns. While CS strategies are zero-net investment long/short strategies, TS strategies take on a time-varying net-long investment in risky assets. For individual stocks, the difference between the performances of TS and CS strategies is largely due to this time-varying net-long investment. With multiple international asset classes with heterogeneous return distributions, scaled CS strategies significantly outperform similarly scaled TS strategies.

Keywords: Momentum, market timing, return predictability

Trading rules

Create a collection of commodity futures suitable for trading.
Assess the 12-month historical returns of each future.
Categorize futures into quintiles based on performance.
Take a long position on the quintile showcasing the strongest momentum.
Opt for a short position on the quintile with the weakest momentum.
Adjust the portfolio positions on a monthly basis.

Python code

Backtrader

import backtrader as bt
import numpy as np

class CommodityMomentum(bt.Strategy):
    params = (
        ('lookback', 12),
        ('rebalance_period', 30),
    )

    def __init__(self):
        self.future_data = {}
        self.inds = {}

    def prenext(self):
        self.next()

    def nextstart(self):
        self.next()

    def next(self):
        if len(self.data) % self.params.rebalance_period == 0:
            self.rebalance_portfolio()

    def add_future_data(self, future_name, future_data):
        self.future_data[future_name] = future_data
        self.inds[future_name] = {}
        self.inds[future_name]['momentum'] = bt.indicators.Momentum(future_data.close, period=self.params.lookback)

    def rebalance_portfolio(self):
        momentums = []
        for future_name, future_data in self.future_data.items():
            if len(future_data) < self.params.lookback:
                continue
            momentum_value = self.inds[future_name]['momentum'][0]
            momentums.append((future_name, momentum_value))

        sorted_momentums = sorted(momentums, key=lambda x: x[1])
        quintile_size = len(sorted_momentums) // 5
        long_futures = [future_name for future_name, _ in sorted_momentums[-quintile_size:]]
        short_futures = [future_name for future_name, _ in sorted_momentums[:quintile_size]]

        for future_name, future_data in self.future_data.items():
            if future_name in long_futures:
                self.order_target_percent(future_data, target=1.0/len(long_futures))
            elif future_name in short_futures:
                self.order_target_percent(future_data, target=-1.0/len(short_futures))
            else:
                self.order_target_percent(future_data, target=0)

cerebro = bt.Cerebro()

# Add your data feeds and set the respective names
# Example: data_feed = bt.feeds.YourDataFeed(dataname="your_data_feed")
# cerebro.adddata(data_feed, name="future_name")

strategy = cerebro.addstrategy(CommodityMomentum)
for future_name, future_data in strategy.future_data.items():
    strategy.add_future_data(future_name, future_data)

cerebro.run()

Please note that you need to add your data feeds and set the respective names before running the code.

Cross-Sectional and Time-Series Tests of Return Predictability: What Is the Difference?

Original paper

Abstract

Trading rules

Python code

Backtrader