Original paper
Abstract
Momentum trading strategies are thoroughly described in the academic literature and used in many trading strategies by hedge funds, asset managers, and proprietary traders. Baz et al. (2015) describe a momentum strategy for different asset classes in great detail from a practitioner’s point of view. Using a geometric Brownian Motion for the dynamics of the returns of financial instruments, we extensively explain the motivation and background behind each step of a momentum trading strategy. Constants and parameters that are used for the practical implementation are derived in a theoretical setting and deviations from those used in Baz et al. (2015) are shown. The trading signal is computed as a mixture of exponential moving averages with different time horizons. We give a statistical justification for the optimal selection of time horizons. Furthermore, we test our approach on global currency markets, including G10 currencies, emerging market currencies, and cryptocurrencies. Both a time series portfolio and a cross-sectional portfolio are considered. We find that the strategy works best for traditional fiat currencies when considering a time series based momentum strategy. For cryptocurrencies, a cross-sectional approach is more suitable. The momentum strategy exhibits higher Sharpe ratios for more volatile currencies. Thus, emerging market currencies and cryptocurrencies have better performances than the G10 currencies. This is the first comprehensive study showing both the underlying statistical reasons of how such trading strategies are constructed in the industry as well as empirical results using a large universe of currencies, including cryptocurrencies.
Keywords:Â Momentum, Currency Markets, G10, Emerging Markets, Cryptocurrencies, Bitcoin, Moving Average Crossover, Cross-Sectional Momentum, Time Series Momentum, Trend-Following
Trading rules
- Focus on G10 currency pairs.
- Always employ the foreign currency as the primary and USD as the secondary.
- Use exponential moving averages (EMAs) to analyze currency values.
- Derive short-term EMAs over periods of 8, 16, and 32 days, and long-term EMAs over durations of 24, 48, and 96 days.
- Identify a bullish trend when the short-term EMA surpasses the long-term EMA and a bearish trend when it's the opposite.
- The primary indicator is formed as a difference between short and long EMA.
- The primary indicator's sign decides the currency position, long or short.
- Standardize the primary indicator by comparing with the exchange rate's 3-month rolling standard deviation.
- Again, standardize the resultant sequence by its one-year moving standard deviation.
- Employ a response function to determine the indicator using the standardized series.
- For every duration, the ultimate indicator is the weighted aggregate of prior indicators.
- Go long on currencies exhibiting a positive indicator and short those with a negative one.
- Distribute investments across currencies, factoring in the indicator value over the total number of currencies (10).
- Daily adjustments are required for the portfolio.
- A 5:1 leverage ratio is in place.
Python code
Backtrader
Here is the Backtrader Python code for the given trading rules:
import backtrader as bt
import numpy as np
class ForexEMAStrategy(bt.Strategy):
params = (
('lookback_short', 8),
('lookback_medium', 16),
('lookback_long', 32),
('lookback_short_ma', 24),
('lookback_medium_ma', 48),
('lookback_long_ma', 96),
('weight_short', 0.2),
('weight_medium', 0.5),
('weight_long', 0.3),
('leverage_ratio', 5),
)
def __init__(self):
self.ema_short = {}
self.ema_medium = {}
self.ema_long = {}
self.ma_short = {}
self.ma_medium = {}
self.ma_long = {}
self.signal_short = {}
self.signal_medium = {}
self.signal_long = {}
self.forex_symbols = ['EURUSD', 'USDJPY', 'GBPUSD', 'USDCHF', 'USDCAD', 'AUDUSD', 'NZDUSD', 'USDNOK', 'USDSEK', 'USDZAR']
self.weights = [self.params.weight_short, self.params.weight_medium, self.params.weight_long]
self.num_currencies = len(self.forex_symbols)
self.daily_rebalance = True
for sym in self.forex_symbols:
self.ema_short[sym] = bt.talib.EMA(self.data[sym], timeperiod=self.params.lookback_short)
self.ema_medium[sym] = bt.talib.EMA(self.data[sym], timeperiod=self.params.lookback_medium)
self.ema_long[sym] = bt.talib.EMA(self.data[sym], timeperiod=self.params.lookback_long)
self.ma_short[sym] = bt.talib.SMA(self.data[sym], timeperiod=self.params.lookback_short_ma)
self.ma_medium[sym] = bt.talib.SMA(self.data[sym], timeperiod=self.params.lookback_medium_ma)
self.ma_long[sym] = bt.talib.SMA(self.data[sym], timeperiod=self.params.lookback_long_ma)
self.signal_short[sym] = self.ema_short[sym] - self.ma_short[sym]
self.signal_medium[sym] = self.ema_medium[sym] - self.ma_medium[sym]
self.signal_long[sym] = self.ema_long[sym] - self.ma_long[sym]
def next(self):
signal = np.zeros(self.num_currencies)
for i, sym in enumerate(self.forex_symbols):
signal_short = (self.signal_short[sym][0] / self.ma_short[sym][0]) / np.std(self.signal_short[sym][0:90])
signal_medium = (self.signal_medium[sym][0] / self.ma_medium[sym][0]) / np.std(self.signal_medium[sym][0:90])
signal_long = (self.signal_long[sym][0] / self.ma_long[sym][0]) / np.std(self.signal_long[sym][0:90])
signal[i] = self.weights[0] * signal_short + self.weights[1] * signal_medium + self.weights[2] * signal_long
signal = self.params.leverage_ratio * signal / self.num_currencies
dollar_value = self.params.leverage_ratio * self.broker.get_value()
for i, sym in enumerate(self.forex_symbols):
weight = signal[i] / 10
position_value = dollar_value * weight
num_lots = position_value / self.data[sym].close[0]
self.order_target_size(sym, num_lots)
import datetime
if self.daily_rebalance and self.data.datetime.time() == datetime.time(23, 59, 59):
self.rebalance_portfolio()
def rebalance_portfolio(self):
for sym in self.forex_symbols:
self.order_target_percent(sym, 0)