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

home: true

In this research I looked at intraday Bitcoin trading based on price and volume information using classification models.

Packages

import warnings
import itertools
import numpy as np
import pandas as pd
from sklearn import tree
from sklearn.svm import SVC
import matplotlib.pyplot as plt
from xgboost import XGBClassifier
import matplotlib.ticker as ticker
from sklearn.decomposition import PCA
from imblearn.over_sampling import SMOTE
from sklearn.metrics import confusion_matrix
from multiprocessing import set_start_method
from sklearn.tree import DecisionTreeClassifier
from IPython.display import display, HTML, Image
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold, GridSearchCV
from pandas.plotting import register_matplotlib_converters
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier

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'] = 100
plt.rcParams['lines.linewidth'] = 0.75
pd.set_option('max_row', 10)

Function

This is a customized function used to plot confusion matrix in python.

def disp(df, max_rows=10):
    return display(HTML(df.to_html(max_rows=max_rows, 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 bill price.

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

We first resample our data by hour. Since most Bitcoin exchanges nowadays have transaction fees, which renders retail trading at a high frequency level unattainable. Therefore I leave out the second and minute level data and combine them into hours. Note that I average the price while summing the volume within an hour.

A 2 year data window from 2017 to 2019 is used, as this is when Bitcoin and other crypto has come into the attention of the larger public, and mostly importantly, started to be heavily traded. Therefore the training set will be more representative of any future trading environment. The plot below illustrates the total dollar amount traded per hours over time.

df0 = data.resample('H').agg({'price': np.mean, 'volume': np.sum}).fillna(method='ffill')
plt.plot(df0.volume * df0.price, c='black')
plt.title('Bitcoin Dollar Volume in Dollar Term')
plt.show()

df1  = data.loc['2017-07-01':'2019-06-30'].resample('H').agg({'price': np.mean,
                                                            'volume': np.sum}).fillna(method='ffill')
df2 = tr.loc['2017-07-01':'2019-06-30']
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='black')
plt.title('Bitcoin Price 2017-07-01 to 2019-06-30')
plt.show()

We then created several more data fields intending to extract more information from the previous n-hour window

interval = [6, 12, 24, 48, 120] # 0.25, 0.5, 1, 2, 5 days
for i in interval:
    for c in ['price', 'volume']:
        df[c+'_change_'+str(i)+'H']   = df[c]/df[c].shift(i)-1
        df[c+'_high_'+str(i)+'H']     = df[c].rolling(i).max().shift(1) / df[c]
        df[c+'_low_'+str(i)+'H']      = df[c].rolling(i).min().shift(1) / df[c]
        df[c+'_avg_'+str(i)+'H']      = df[c].rolling(i).mean().shift(1) / df[c]  
        df[c+'_std_'+str(i)+'H']      = df[c].rolling(i).std().shift(1) / df[c] * np.sqrt(24/i)

df.dropna(inplace=True)
disp(df.head())

PCA

Due to the large number of features created in the last step, we use PCA to reduce the dimensionality of the data. Aside from price, 15 other principal components are retained. Since we mostly care about predicting accuracy, therefore we are okay with losing some interpretability in the PCA process.

X = StandardScaler().fit_transform(df.iloc[:, 3:])
comp = 15
pca = PCA(n_components=comp)
X_pca = pca.fit_transform(X)
np.round(pca.explained_variance_ratio_, 2)

array([0.29, 0.23, 0.13, 0.06, 0.05, 0.03, 0.03, 0.02, 0.02, 0.02, 0.01,
       0.01, 0.01, 0.01, 0.01])

np.round(np.sum(pca.explained_variance_ratio_), 2)

0.93

df_pca = pd.DataFrame(X_pca, index=df.index, columns = ['PC' + str(i) for i in range(1, comp+1)])
df = pd.DataFrame(df.iloc[:, 0:3]).join(df_pca)
disp(df.head())

Modeling

Train and test sets are created for modeling purpose. Since it is time series data, randomization will not be performed. Rather, both train and test sets are chosen such that they both include a market upturn and market downturn.

train  = df.loc['2017-07-01':'2018-06-30']
test   = df.loc['2018-07-01':'2019-06-30']

Here we specify some modeling parameters. The trading frequency is set to one day.

trade_interval      = '1H'
trade_interval_min  = 60
ann_factor          = 24 * 365
training_threshold  = 0.0075
transaction_fee     = 0.0025

Create a model engine that fit the train data and use grid search CV to tune the parameter grid. A long trade will be executed only if the model predict a next-5-day up move in the last 24 consecutive hours. This limits the frequency of trade which reduce the impact of the relatively large transaction fee per trade. The training threshold is set to 75 bps, which means the model is train to identify a potential up move of more than 75 bps in the next 5 days.

def run_model(Model, model_name, param, param_init, param_grid, search=False):
    # prepare data
    train_copy = train.resample(trade_interval).first()
    test_copy = test.resample(trade_interval).first()
    train_copy.dropna(inplace=True)
    test_copy.dropna(inplace=True)

    indicator = 24  # hr
    offset    = 120 # hr

    X_train = train_copy.iloc[:-offset, 3:]
    Y_train = (train_copy.price.shift(-offset)/train_copy.price)[:-offset] > (1 + training_threshold)
    X_test  = test_copy.iloc[:-offset, 3:]
    Y_test  = (test_copy.price.shift(-offset)/test_copy.price)[:-offset] > (1 + training_threshold)


    # run model
    if search:
        model = GridSearchCV(estimator=Model(**param_init),
                             cv=KFold(n_splits=5, random_state=0),
                             scoring='precision',
                             param_grid=param_grid).fit(X_train, Y_train)
        print(f'cv precision: {round(model.best_score_, 2)}, best param: {model.best_params_}')
    else:
        model = Model(**param).fit(X_train, Y_train)

    Y_pred    = model.predict(X_test)
    cm        = confusion_matrix(Y_test, Y_pred)
    precision = round(cm[1][1]/(cm[1][1] + cm[0][1]), 2)

    # calculate pnl
    # test_copy['ind']     = np.append(Y_pred, False)
    # test_copy['pnl']     = test_copy.ind * (test_copy.price.shift(-1) / test_copy.price)
    test_copy['pred'] = np.append(Y_pred, [False] * offset)
    test_copy['ind']  = test_copy.pred.rolling(indicator).sum() == indicator
    test_copy['buy']  = test_copy.ind.rolling(offset).sum() > 0

    test_copy['pnl']  = test_copy.buy * (test_copy.price.shift(-1) / test_copy.price)
    test_copy.pnl.replace(0, 1, inplace=True)
    test_copy.dropna(inplace=True)

    test_copy['fee']  = np.where(test_copy.ind != test_copy.ind.shift(1), 1-transaction_fee, 1)
    test_copy.pnl     *= test_copy.fee

    test_pnl  = round(test_copy.pnl.cumprod()[-1], 2)
    test_spr  = round(np.mean(test_copy.pnl - 1 - test_copy.tr/(ann_factor))
                      / (test_copy.pnl - 1).std() * np.sqrt(ann_factor), 2)

    print(f'test precision: {precision}; pnl: {test_pnl}, spr: {test_spr}')
    return test_copy.pnl, precision, test_pnl, test_spr

Baseline

baseline        = test.resample(trade_interval).first()
baseline['pnl'] = baseline.price / baseline.price.shift(1) - 1
baseline_pnl    = round(baseline.price.iloc[-1] / baseline.price.iloc[0], 2)
baseline_spr    = round(np.mean(baseline.pnl - baseline.tr/(ann_factor))
                        / baseline.pnl.std() * np.sqrt(ann_factor), 2)

result = test[['price']].copy().rename({'price': 'Baseline'}, axis=1)/test.price.iloc[0]*1000
comp = pd.DataFrame({'Strategy': 'Baseline', 'Precision': 'NA',
                     'P&L': baseline_pnl, 'Sharpe Ratio': baseline_spr}, index=[0])
print(f'test precision: {np.NaN}; pnl: {baseline_pnl}, spr: {baseline_spr}')

test precision: nan; pnl: 1.69, spr: 1.14

Logistic Regression

Model      = LogisticRegression
model_name = 'Logistic Regression'
param      = {'class_weight':'balanced',
              'solver':'liblinear',
              'random_state': 0,
              'C': 0.001,
              'penalty': 'l2'}
param_init = {'random_state': 0, 'class_weight': 'balanced'}
param_grid = {'C': [1e-2, 1e-1, 1, 10], 'penalty': ['l1', 'l2']}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.52, best param: {‘C’: 0.01, ‘penalty’: ‘l1’}
test precision: 0.47; pnl: 1.14, spr: 0.47

Linear Discriminant Analysis

Model      = LinearDiscriminantAnalysis
model_name = 'Linear Discriminant Analysis'
param      = {'solver': 'svd', 'n_components': None}
param_init = {}
param_grid = {'solver': ['svd', 'lsqr'], 'n_components': [None, 5, 10, 25]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.5, best param: {‘n_components’: None, ‘solver’: ‘svd’}
test precision: 0.47; pnl: 0.85, spr: -0.17

KNN

Model      = KNeighborsClassifier
model_name = 'KNN'
param      = {'p': 2, 'leaf_size': 2, 'n_neighbors': 100}
param_init = {'p': 2}
param_grid = {'n_neighbors': [5, 25, 100], 'leaf_size': [2, 25, 100]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.53, best param: {‘leaf_size’: 2, ‘n_neighbors’: 100}
test precision: 0.5; pnl: 1.95, spr: 1.85

Decision Tree

Model      = DecisionTreeClassifier
model_name = 'Decision Tree'
param      = {'random_state':0, 'criterion': 'gini', 'max_depth': None, 'max_features': 10}
param_init = {'random_state':0}
param_grid = {'criterion': ['gini', 'entropy'],
              'max_depth': [None, 5, 10, 25],
              'max_features': [None, 'auto', 5, 10]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.53, best param: {‘criterion’: ‘gini’, ‘max_depth’: 10, ‘max_features’: 5}
test precision: 0.49; pnl: 1.61, spr: 1.84

Random Forest

Model      = RandomForestClassifier
model_name = 'Random Forest'
param      = {'class_weight':'balanced',
              'random_state': 0,
              'criterion': 'entropy',
              'max_depth': 10,
              'max_features': 5,
              'n_estimators': 200}
param_init = {'class_weight':'balanced', 'random_state': 0, 'n_estimators': 200}
param_grid = {'criterion': ['gini', 'entropy'],
              'max_depth': [5, 25],
              'max_features': [5, 10]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.53, best param: {‘criterion’: ‘gini’, ‘max_depth’: 5, ‘max_features’: 10}
test precision: 0.53; pnl: 1.55, spr: 1.16

AdaBoost

Model      = AdaBoostClassifier
model_name = 'AdaBoost'
param      = {'random_state': 0, 'algorithm': 'SAMME.R', 'n_estimators': 200, 'learning_rate': 0.1}
param_init = {'random_state': 0, 'algorithm': 'SAMME.R', 'n_estimators': 200}
param_grid = {'learning_rate': [1e-2, 1e-1, 1, 10]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.52, best param: {‘learning_rate’: 0.01}
test precision: 0.5; pnl: 0.86, spr: -0.09

Gradient Boost

Model      = GradientBoostingClassifier
model_name = 'Gradient Boost'
param      = {'random_state': 0, 'warm_start': True, 'n_estimators': 200,
              'max_depth': 10,
              'max_features': 10,
              'learning_rate': 0.1}
param_init = {'random_state': 0, 'warm_start': True, 'n_estimators': 200,}
param_grid = {'max_depth': [5, 25],
              'max_features': [5, 10],
              'learning_rate': [1e-2, 1e-1, 1, 10]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.54, best param: {‘learning_rate’: 10, ‘max_depth’: 5, ‘max_features’: 5}
test precision: 0.48; pnl: 1.06, spr: 0.33

XGBoost

set_start_method('forkserver', force=True) # enabling multi-threading

Model      = XGBClassifier
model_name = 'XGBoost'
param      = {'n_jobs':4, 'seed':0, 'n_estimators': 200,
              'max_depth': 5,
              'min_child_weight': 1,
              'gamma': 10,
              'learning_rate': 0.01}
param_init = {'n_jobs':4, 'seed':0, 'n_estimators': 200}
param_grid = {'max_depth': [5, 25],
              'min_child_weight': [1, 5],
              'gamma': [1e-2, 1e-1, 1, 10],
              'learning_rate': [1e-2, 1e-1, 1, 10]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.52, best param: {‘gamma’: 10, ‘learning_rate’: 0.01, ‘max_depth’: 25, ‘min_child_weight’: 1}
test precision: 0.52; pnl: 1.33, spr: 0.86

SVC

Model      = SVC
model_name = 'SVC'
param      = {'probability':True, 'class_weight':'balanced', 'C': 10, 'gamma': 0.01}
param_init = {'probability':True, 'class_weight':'balanced'}
param_grid = {'C': [1e-2, 1e-1, 1, 10],
              'gamma': [1e-2, 1e-1, 1, 10]}

a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.64, best param: {‘C’: 0.1, ‘gamma’: 1}
test precision: 0.47; pnl: 1.31, spr: 0.73

MLP Classificer

Model      = MLPClassifier
model_name = 'MLP Classifier'
param      = {'random_state': 0, 'hidden_layer_sizes': (25, 25), 'alpha': 0.01}
param_init = {'random_state': 0}
param_grid = {# 'hidden_layer_sizes': [x for x in itertools.product((5, 25, 100),repeat=2)],
              'alpha'             : [1e-2, 1e-1, 1, 10],
              # 'activation'        : ['identity', 'logistic', 'tanh', 'relu'],
              # 'solver'            : ['lbfgs', 'sgd', 'adam'],
              # 'learning_rate'     : ['constant', 'invscaling', 'adaptive'],
              # 'max_itr'           : [100, 200, 1000]
             }


a, b, c, d = run_model(Model, model_name, param, param_init, param_grid, search=True)
result     = result.join(a.cumprod() * 1000).rename({'pnl': model_name}, axis=1).dropna()
comp       = comp.append({'Strategy': model_name, 'Precision': b, 'P&L': c, 'Sharpe Ratio': d}, ignore_index=True)

cv precision: 0.53, best param: {‘alpha’: 1}
test precision: 0.55; pnl: 2.06, spr: 1.79

Result

The results are summarized as follow.

disp(comp.replace('NA', 0).sort_values('P&L', ascending=False), 20)

Plotting the cumulative return for each strategy with transaction fee reflected.

plt.plot(result)
plt.legend(result.columns, frameon=False)
plt.xticks(rotation=30)
plt.gca().xaxis.set_major_locator(ticker.MultipleLocator(30))
plt.ylabel('Cumulative Value Based on $1000 Investment')
plt.show()