Posted September 5, 2015

Contents

BitCoin Trading Strategies BackTest With PyAlgoTrade

(4 votes, average: 4.50 out of 5)

Written by Khang Nguyen Vo, khangvo88@gmail.com, for the RobustTechHouse blog. Khang is a graduate from the Masters of Quantitative and Computational Finance Program, John Von Neumann Institute 2014. He is passionate about research in machine learning, predictive modeling and backtesting of trading strategies.

Introduction

Bitcoin (or BTC) was invented by Japanese Satoshi Nakamoto and considered the first decentralized digital currency or crypto-currency. In this article, we experiment with a simple momentum based trading strategy for Bitcoin using PyAlgoTrade which is a Python Backtesting library. The Moving Average Crossover trading strategy we start with is defined as:

Enter position:
- Long when MA10 > MA20
- Short when MA10 < MA20
Exit position:
- reverse trend
- Take profit when we gain $20
- Cut loss when we lose $10

MA10 refers to 10 day moving average price and MA20 refers 20 day moving average price.

Data

The bitcoin data can be obtained from Bitcoin charts. The raw data of this source is at minute based sampling frequency and we group the data to 15-minutes prices as follows:

BitCoin Trading Strategy BackTest With PyAlgoTrade

PyAlgoTrade, as mentioned in previous blog, is an event-driven library. So we must override the basic events onEnterOk and onExitOk, which are raised when orders submitted before are successfully filled.

import Momentum.MyBaseStrategy as bstr  #extend from pyalgotrade.BacktestStrategy
from pyalgotrade.technical import ma
from pyalgotrade.barfeed import csvfeed
from pyalgotrade.bar import Frequency
from pyalgotrade import plotter
import numpy as np
import datetime

class MyStrategy(bstr.MyBTStrategy):    
    def __init__(self, feed, cash,sma):
        self.__instrument = 'Bitcoin'  
        bstr.MyBTStrategy.__init__(self,feed,cash, instrument=self.__instrument)                
        self.MAXPROFIT = 20; self.STOPLOSS = 10        
        self.getBroker().setAllowNegativeCash(True)                        
                    
        # using for trading signal        
        self.__position = None        
        self.__price = feed[self.__instrument].getCloseDataSeries()        
        self.__sma10 = ma.SMA(self.__price,sma[0],maxLen=100000)
        self.__sma20 = ma.SMA(self.__price,sma[1],maxLen=100000)
        self.__lastPrice = 0 #last price. Use for take profit and cutloss                
        self.__signal = 0 #1: buying, -1: selling, 0: no change
        self.__last_exit_time = None
     
    def onEnterOk(self, position):        
        execInfo = position.getEntryOrder().getExecutionInfo()        
        self.info("%s %d at VND %s" %(self.alert_message,execInfo.getQuantity(), 
                                      ut.accountingFormat(execInfo.getPrice())))
        self.__lastPrice = execInfo.getPrice()                   
        self.record_detail_transaction(position)
    
    def onEnterCanceled(self, position):
        self.__position = None        
   
    def onExitOk(self, position):        
        execInfo = position.getExitOrder().getExecutionInfo()
        self.info("%s %d at %s\n=================================" 
                  %(self.alert_message, 
                    execInfo.getQuantity(),'{:11,.2f}'.format(execInfo.getPrice())))        
        self.__position = None        
        self.record_detail_transaction(position, False) # log detail for later analysis
        
    # run before onEnterOk and onExitOk        
    def onOrderUpdated(self,order):    
        pass

The main process of trading algorithm is in onBars, which is raised every time there is new record of time series. PyAlgoTrade feed the data series and put it in bars, on each time given. This mandatory method is implemented as follows:

. . .
    # main event to update trading strategy
    def onBars(self, bars):                
        self.portfolio_values.append(self.getBroker().getEquity())        
        if self.__sma20[-1] is None:
            return
        bar = bars[self.__instrument]                
                
        if self.__sma10[-1] > self.__sma20[-1]:   self.__signal = 1 # buying signal            
        elif self.__sma10[-1] < self.__sma20[-1]: self.__signal =-1 # selling signal             
        shares = 1
        
        if(self.__position) is None and self.__sma20[-2] is not None:
            # go into long position            
            if self.__sma10[-1] > self.__sma20[-1] and self.__sma10[-2] <= self.__sma20[-2]:
                self.info("short SMA > long SMA. RAISE BUY SIGNAL")                        
                #shares = int(self.getBroker().getCash() * 0.9 / bar.getClose())
                self.__position = self.enterLong(self.__instrument,shares,False)                                                    
                self.alert_message='Long position'         
                self.buy_signals.append(self.getCurrentDateTime())                                                       
            #short position
            elif self.__sma10[-1] < self.__sma20[-1] and self.__sma10[-2] >= self.__sma20[-2]: 
                self.info("short SMA < long SMA. RAISE SELL SIGNAL")   
                self.__position = self.enterShort(self.__instrument,shares,False)                   
                self.alert_message='Short position'       
                self.sell_signals.append(self.getCurrentDateTime())         
        elif self.__lastPrice is not None and self.getBroker().getPositions() != {}:                     
            pos = self.getBroker().getPositions()[self.__instrument]                        
            # take profit when we obtain >= $20
            if( np.sign(pos)*(bar.getClose() - self.__lastPrice) >= self.MAXPROFIT):
                self.alert_message = 'TAKE PROFIT'
                self.__position.exitMarket()
                self.__lastPrice = None
            # cut loss when we lose more than $10
            elif (np.sign(pos)*(self.__lastPrice - bar.getClose())) >= self.STOPLOSS:
                self.alert_message = 'STOP LOSS'
                self.__position.exitMarket()
                self.__lastPrice = None
            elif pos*self.__signal < 0:
                self.alert_message = "Reverse signal. TAKE PROFIT"
                self.__position.exitMarket()
                self.__lastPrice = None
                if self.__signal < 0:
                    self.sell_signals.append(self.getCurrentDateTime())
                else:
                    self.buy_signals.append(self.getCurrentDateTime())
                self.__last_exit_time = self.getCurrentDateTime()

Then the main script as follows:

    filename = '../btcUSD15m_2.csv'    
    # TODO: change the date range 
    firstDate = datetime.datetime(2014,1,1,0,0,0,0,pytz.utc)
    endDate = datetime.datetime(2014,3,31,0,0,0,0,pytz.utc)
                                                
    feed = csvfeed.GenericBarFeed(15*Frequency.MINUTE,pytz.utc,maxLen=100000)
    feed.setBarFilter(csvfeed.DateRangeFilter(firstDate,endDate))
    feed.addBarsFromCSV('Bitcoin', filename)    

    cash = 10 ** 3 # 1,000 USD
    myStrategy = MyStrategy(feed,cash,[12,30]) #short and long moving average
    plt = plotter.StrategyPlotter(myStrategy, True, False, True)            
    myStrategy.run()

    myStrategy.printTradingPerformance()

The trading transaction detail of this strategy from Jan 2014 to Mar 2014 are as follows:

In this short time window, the Sharpe Ratio is indeed poor and only -1.9. Moreover, there are a total of 200 trades executed in 3 months, and most are unprofitable trades (132/200 trades = 66%). Therefore, we need to reduce the number of unprofitable trades.

Tweaking BitCoin Trading Strategy BackTest

The problem might be that we are using a very short-length moving average window to calculate the change of trends, so the strategy is very sensitive to changes. Now we try a longer moving average window with MA(80,200) crossover

    myStrategy = MyStrategy(feed,cash,[80,200]) #short and long moving average
    plt = plotter.StrategyPlotter(myStrategy, True, False, True)            
    myStrategy.run()

The result of this trading strategy as follows for the same period.

The summary result when running this strategy between 2013-2015

Charts In 2013

Charts In 2014

Charts In 2015

We see that the trading performance is better now. The Sharpe ratio is larger than 0.5, and in 2014, the cumulative returns is as big as 33%. The length of Moving Average could be further optimized (data-mined!).

Note on Transaction Costs

In real trading, it is mandatory to add commission rates or transaction costs. Usually, the transaction cost can be computed as the difference between ASK price and BID price (BID-ASK SPREAD) if market orders are used to buy or sell. In our data set, the average “bid ask spread” is about 0.11, so we set the cost of each transaction to BTC 0.11.

from pyalgotrade.broker import backtesting
feed = createFeed(firstDate, endDate)
strat3 = MyStrategy(feed,cash,[80,200]) #short and long moving average
strat3.getBroker().setCommission(backtesting.FixedPerTrade(0.11)) #t-cost per trade = $0.11
strat3.run()
strat3.printTradingPerformance()

Overall, the strategy is still profitable, though we have to be mindful that because BitCoin history is very short, so the statistical significance of the strategy is inconclusive. Note that we assume there are no broker transaction fees. In reality, usually this fee cost 0.7$ per trade.

By the RobustTechHouse team

Tags: FinTech, Machine Learning, Trading

admin