title: “Bitcoin Quant Strategies - Momentum Trading”
date: 2019-07-20
tags: tech
mathjax: true

home: true

In this research I studied on the performance of simple and exponential moving average crossover strategies, with window sizes chosen by optimizing in-sample PNL, sharpe ratio and 30-day maximum drawdown. The calibrated strategy performs well, earning 500% cumulative return compared to baseline and a sharpe ratio of 1.30. The the 30-day maximum drawdown is similar to the baseline.

Motivation

It is no secret that price manipulations have always plagued the rising crypto-market. In this [paper], the auther studies large transactions behind the tether coin, and showed more evidence supporting that each large move in the crypto-market usually only come from the act of only a few. In this type of regime, I argue that technical indicator may be a better bet to profit compared to any attempt to apply fundamental analysis, because an increase in price no longer comes from the increase in a crypto’s intrinsic value, but rather speculation and manipulation. In this exercise I will mainly focus on moving average crossover techniques and its optimization.

Packages

import itertools
from IPython.display import display, HTML, Image
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np
import pandas as pd
from pandas.plotting import register_matplotlib_converters
import warnings

register_matplotlib_converters()
warnings.filterwarnings("ignore")

plt.rcParams['font.family'] = "serif"
plt.rcParams['font.serif'] = "DejaVu Serif"
plt.rcParams['figure.figsize'] = (12, 6)
plt.rcParams['figure.dpi'] = 150
plt.rcParams['lines.linewidth'] = 0.75
pd.set_option('max_row', 10)

Function

def disp(df):
    return display(HTML(df.to_html(max_rows=10, header=True).replace('<table border="1" class="dataframe">','<table>')))

Data Exploration

I got the preliminary bitcoin data from bitcoincharts. Data include price and volume information recorded by Bitstamp and split by seconds. This provide great granularity that can be grouped into any desirable levels later on.

data = pd.read_csv('bitstampUSD.csv', header=None, names=['time', 'price', 'volume'])
data['time'] = pd.to_datetime(data['time'], unit='s')
data.set_index('time', inplace=True)

Get 3-month treasury data.

url = 'https://fred.stlouisfed.org/graph/fredgraph.csv?id=DTB3'
tr  = pd.read_csv(url, index_col=0, parse_dates=True)

Data are grouped in to daily, with average applied to price and sum applied to trade volume. The backtest period is selected to be from 2018 to 2019, where the market was in continuous downturn. This ensure that our strategy performs well in adverse scenarios.

df1 = data.loc['2018-01-01':'2019-01-01'].resample('1D').agg({'price': np.mean, 'volume': np.sum})
df2 = tr.loc['2018-01-01':'2019-01-01']
df = df1.join(df2).replace('.', np.NaN).fillna(method='ffill').fillna(method='bfill').rename({'DTB3': 'tr'}, axis=1)
df.tr = df.tr.astype(float)/100
disp(df)

plt.plot(df.price, c='tab:grey')
plt.ylabel('Bitcoin Price in USD')
plt.show()

Simple Moving Average

A simple moving average strategy use the cross-over point of two moving averages as the trading signal. Here we use grid-search to find out the window size pair that optimizes our desired metrics, namely P&L, Sharpe ratio and 30-day maximum drawdown.

def moving_average(df0, ma1, ma2, transactionFee=0, runBaseline=False, returnStats=True, ewma=False):
    df = df0.copy()
    if ewma:
        df['ma'+str(ma1)] = df.price.ewm(span=ma1).mean()
        df['ma'+str(ma2)] = df.price.ewm(span=ma2).mean()
    else:
        df['ma'+str(ma1)] = df.price.rolling(ma1).mean()
        df['ma'+str(ma2)] = df.price.rolling(ma2).mean()

    df['ind'] = df['ma'+str(ma1)] > df['ma'+str(ma2)]
    df.dropna(inplace=True)
    df['buy'] = (df.ind != df.ind.shift(1)) & df.ind & (df.index != df.index[0])
    df['sell'] = (df.ind != df.ind.shift(1)) & df.ind.shift(1) & (df.buy.cumsum() > 0)

    if runBaseline:
        df.ind = 1
        df.buy = 1

    df['pnl'] = df.ind * (df.buy.cumsum() > 0) * df.price.shift(-1) / df.price
    df.pnl = df.pnl * np.where(df.ind != df.ind.shift(1), 1-transactionFee, 1)
    df.dropna(inplace=True)
    df.pnl.replace(0, 1, inplace=True)

    if returnStats:
        df['tr_daily'] = (1 + df.tr)**(1/365) - 1
        pnl            = round(df.pnl.cumprod()[-1], 2)
        sharpe_ratio   = round(np.mean(df.pnl-1-df.tr_daily) / np.std(df.pnl-1) * np.sqrt(365), 2)
        mdd_dur        = 30
        max_draw_down  = round(np.max(df.pnl.cumprod().rolling(mdd_dur).max() -
                                     df.pnl.cumprod().shift(mdd_dur)), 2)
        return pnl, sharpe_ratio, max_draw_down
    else:
        return df

First let’s compute the baseline results, from a simple buy and hold strategy.

pnl, spr, mdd = moving_average(df, 1, 1, runBaseline=True)
comp = pd.DataFrame({'Strategy': 'Baseline', 'P&L': pnl, 'Sharpe Ratio': spr, 'Maximum Drawdown': mdd}, index=[0])
disp(comp)

Performing grid-search for the optimal window size pair. Note that 25bps of transaction fee is added, this is to reflect the typical fee charged by crypto exchanges. I used coinbase pro’s fee here as an example.

fee = 0.0025
test_range = np.arange(1, 61)
result_ma = pd.DataFrame(columns=['Strategy','MA1', 'MA2', 'P&L', 'Sharpe Ratio', 'Maximum Drawdown'])

# grid-search
for ma1 in test_range:
    for ma2 in test_range:
        if ma2 > ma1 + 3:
            pnl, spr, mdd = moving_average(df, ma1, ma2, transactionFee=fee)
            result_ma = result_ma.append({'Strategy': 'MA', 'MA1': ma1, 'MA2': ma2,
                                          'P&L': pnl,
                                          'Sharpe Ratio': spr,
                                          'Maximum Drawdown': mdd}, ignore_index=True)

disp(result_ma.sort_values('P&L', ascending=False).head())

disp(result_ma.sort_values('Sharpe Ratio', ascending=False).head())

disp(result_ma.sort_values('Maximum Drawdown', ascending=True).head())

Choosing 1-7 as our selected window pair. Plotting the PNL over the 1-year backtest period.

bt = df.copy()
bt['Baseline: Buy and Hold'] = bt.price/bt.price[0]
bt['Strategy 1: MA 1-7']          = moving_average(df.copy(), 1, 7, returnStats=False).pnl.cumprod()
bt['Strategy 2: MA 1-7 with Fee'] = moving_average(df.copy(), 1, 7, transactionFee=fee, returnStats=False).pnl.cumprod()

plt.plot(bt.iloc[:, 3], c='tab:grey')
plt.plot(bt.iloc[:, 4], c='tab:red')
plt.plot(bt.iloc[:, 5], c='tab:red', alpha=0.5)
plt.legend(bt.columns[3:6], frameon=False)
plt.ylabel('Cumulative Asset Value Based on $1 Investment')
plt.show()

It seems that the trading fee does not have a material impact on the result. We plot the buy/sell signals as follow.

bt = df.copy()
ma = moving_average(bt, 1, 7, transactionFee=fee, returnStats=False)

plt.plot(bt.price, c='black', label='Bitcoin Price')
plt.plot(ma.price.loc[ma.buy], '^', markersize=3, color='g', label='Buy Signal')
plt.plot(ma.price.loc[ma.sell], 'v', markersize=3, color='r', label='Sell Signal')
plt.legend()
plt.show()

EWMA

Perform the same grid-search optimization using EWMA (Exponentially Weighted Moving Averages).

test_range = np.arange(1, 61)
result_ewma = pd.DataFrame(columns=['Strategy','MA1', 'MA2', 'P&L', 'Sharpe Ratio', 'Maximum Drawdown'])

# grid-search
for ma1 in test_range:
    for ma2 in test_range:
        if ma2 > ma1 + 3:
            pnl, spr, mdd = moving_average(df, ma1, ma2, transactionFee=fee, ewma=True)
            result_ewma = result_ewma.append({'Strategy': 'EWMA', 'MA1': ma1, 'MA2': ma2,
                                    'P&L': pnl,
                                    'Sharpe Ratio': spr,
                                    'Maximum Drawdown': mdd}, ignore_index=True)

disp(result_ewma.sort_values('P&L', ascending=False).head())

disp(result_ewma.sort_values('Sharpe Ratio', ascending=False).head())

disp(result_ewma.sort_values('Maximum Drawdown', ascending=True).head())

Selecting 1-7 as our window pair. Plotting the cumulative strategy return and buy/sell signals.

bt = df.copy()
bt['Baseline: Buy and Hold'] = bt.price/bt.price[0]
bt['Strategy 1: EMWA 1-5 (Best PNL)']          = moving_average(df.copy(), 1, 5, returnStats=False, ewma=True).pnl.cumprod()
bt['Strategy 2: EMWA 1-5 (Best PNL) with Fee'] = moving_average(df.copy(), 1, 5, transactionFee=fee, returnStats=False, ewma=True).pnl.cumprod()

plt.plot(bt.iloc[:, 3], c='tab:grey')
plt.plot(bt.iloc[:, 4], c='tab:blue')
plt.plot(bt.iloc[:, 5], c='tab:blue', alpha=0.5)
plt.legend(bt.columns[3:6], frameon=False)
plt.ylabel('Cumulative Asset Value Based on $1 Investment')
plt.show()

bt = df.copy()
ma = moving_average(bt, 1, 5, transactionFee=fee, returnStats=False, ewma=True).copy()

plt.plot(bt.price, c='black', label='Bitcoin Price')
plt.plot(ma.price.loc[ma.buy], '^', markersize=3, color='g', label='Buy Signal')
plt.plot(ma.price.loc[ma.sell], 'v', markersize=3, color='r', label='Sell Signal')
plt.legend()
plt.show()

Comparing the MA and EWMA strategies.

bt = df.copy()
bt['Baseline: Buy and Hold'] = bt.price/bt.price[0]
bt['Strategy 1: Moving Average 1-7'] = moving_average(df.copy(), 1, 7, transactionFee=fee, returnStats=False).pnl.cumprod()
bt['Strategy 2: EWMA 1-5']           = moving_average(df.copy(), 1, 5, transactionFee=fee, returnStats=False, ewma=True).pnl.cumprod()

plt.plot(bt.iloc[:, 3], c='tab:grey')
plt.plot(bt.iloc[:, 4], c='tab:red')
plt.plot(bt.iloc[:, 5], c='tab:blue')
plt.legend(bt.columns[3:6], frameon=False)
plt.ylabel('Cumulative Asset Value Based on $1 Investment')
plt.show()

As we can see, the MA strategy slightly outperforms the EWMA strategy in all three metrics.

comp = comp.append(result_ma.iloc[2, [0, 3, 4, 5]], ignore_index=True)
comp = comp.append(result_ewma.iloc[0, [0, 3, 4, 5]], ignore_index=True)
disp(comp)

Implementation

Starting 08-01-2019, I have implemented the optimal MA strategy on a VPS (virtual private server), running 24/7 through the coinbase pro api. Will post update on this periodically.