Bitcoin – hodl??

A buy and hold strategy works extremely well when a price bubble grows, and extremely bad when it bursts. And indeed, apparently all finance and economy gurus (well, all but John McAfee) tell you that the cryptocurrency market, and especially bitcoin, is a bubble, even a “scam with no substantial worth”, and will soon experience a crash “worse than the 17th century tulip mania” or the “18th century South Sea Company fraud”.

By definition, a bubble is a price largely above the ‘real value’ or ‘fair value’ of an asset, and it bursts when people realize that. So what is the fair value of a bitcoin? Obviously not zero, since blockchain based currencies have (aside from their disadvantages) several advantages over traditional currencies, on the economy level as well as on the private level. Such as:

• They break the link of money and debt. Cryptocurrencies don’t require the bank credit mechanism for money creation.
• They can be used where normal money would be impractical, such as fee transfers between machines or trading in multiplayer games.
• They allow low-cost and anonymous money transactions. At least in theory.
• They replace banks for storing and mattresses for stashing money.

I’m ready to believe that blockchain is the future of money transfer and storage. But that does not mean an ever-rising bitcoin price. Hundreds of cryptocurrencies came out in the last two years, any single of them with a better blockchain technology than bitcoin, and any good programmer can add a new coin anytime. Few will survive. Countries or big companies might sooner or later issue their own crypto tokens, as Venezuela already is attempting. The release of an official blockchain Dollar, Yuan, or Euro would leave the old bitcoin with its energy hungry transaction algorithm in thin air. Thus, when investing in bitcoin, we should not hope for a rosy future, but look for its present ‘real value’.

Due to its extreme volatility, bitcoin can not replace bank tresors. But it is already used in some situations for reducing money transfer costs, since the miners get any transaction rewarded in bitcoin. And above all, anonymity can be a substantial motive to own it. When you need a hacker to delete your drunk driving record, pay her in bitcoin. But how big is the online market for illegal hacker jobs, kill contracts, money laundering, drugs, weapons, or pro-Trump facebook advertisements? No one knows, but when we compare it with cash, another form of anonymous payment, we get interesting results.

The current cash in circulation in the US is approximately $1.5 trillion dollars. And the current bitcoin supply, about 17 million bitcoins, represents a total value of about $250 billion. Which means that you can already replace 15% of all US cash with bitcoin! Not to mention all the other cryptos. I fear that this supply already exceeds the demand of anonymous online payment for today and also the next future.

For those reasons, a bitcoin “hodl” system, despite its extreme historical performance, is high risk. We don’t know when and how the bubble will burst – maybe bitcoin will go up to $100,000 before – but we have some reason to suspect that at some point sooner or later the bitcoin price might drop like a stone down to its ‘real value’. Which is unknown, but for practical purposes is probably not in the $15,000 area, but more like $15.

So we need some other method to tackle the cryptocurrency trading problem. The first question: Has the crypto market already developed price curve inefficiencies that can be exploited in a trading system? In (1) we see some tests with basic bitcoin strategies. Our own tests came to the same results. Momentum based strategies can work, and mean-variance optimizing portfolio systems can achieve even extreme returns with crytrocurrencies – up to 10 times higher than “hodl”. But that’s not really surprising due to the high momentums and volatilities of crypto coins. The problem is that all crypto portfolios are exposed to high risk. Other conventional model-based strategies don’t work well anyway with cryptos.

When we concentrate on bitcoin, our proposed system must be a fast trading, trend-agnostic strategy. That means it holds positions only a few minutes, and is not exposed to the bubble risk. I can already tell that short-term mean reversion – even with a more sophisticated system as in (1) – produces no good result with cryptos. So only a few possibilities remain. One of them is exploiting short-term price patterns. This is the strategy that we will develop. And I can already tell that it works. But for this we’ll need a deep machine learning system for detecting the patterns and determining their rules.

Selecting a machine learning library

The basic structure of such a machine learning system is described here. Due to the low signal-to-noise ratio and to ever-changing market conditions, analyzing price series is one of the most ambitious tasks for machine learning. Compared with other AI algorithms, deep learning systems have the highest success rate. Since we can connect any Zorro based trading script to the data analysis software R, we’ll use a R based deep learning package. There are meanwhile many available. Here’s the choice:

• Deepnet, a lightweight and straightforward neural net library with a stacked autoencoder and a Boltzmann machine. Produces good results when the feature set is not too complex. The basic train and predict functions for using a deepnet autoencoder in a Zorro strategy:

  library('deepnet') 
  
  neural.train = function(model,XY) 
  {
    XY <- as.matrix(XY)
    X <- XY[,-ncol(XY)]
    Y <- XY[,ncol(XY)]
    Y <- ifelse(Y > 0,1,0)
    Models[[model]] <<- sae.dnn.train(X,Y,
        hidden = c(30), 
        learningrate = 0.5, 
        momentum = 0.5, 
        learningrate_scale = 1.0, 
        output = "sigm", 
        sae_output = "linear", 
        numepochs = 100, 
        batchsize = 100)
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- t(X)
    return(nn.predict(Models[[model]],X))
  }
  

• H2O, an open-source software package with the ability to run on distributed computer systems. Coded in Java, so the latest version of the JDK is required. Aside from deep autoencoders, many other machine learning algorithms are supported, such as random forests. Features can be preselected, and ensembles can be created. Disadvantage: While batch training is fast, predicting a single sample, as usually needed in a trading strategy, is relatively slow due to the server/client concept. The basic H2O train and predict functions for Zorro:

  library('h2o') 
  # also install the Java JDK
  
  neural.train = function(model,XY) 
  {
    XY <- as.h2o(XY)
    Models[[model]] <<- h2o.deeplearning(
      -ncol(XY),ncol(XY),XY,
      hidden = c(30),  seed = 365)
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- as.h2o(as.data.frame(t(X)))
    else X <- as.h2o(X)
    Y <- h2o.predict(Models[[model]],X)
    return(as.vector(Y))
  }

• Tensorflow in its Keras incarnation, a neural network kit by Google. Supports CPU and GPU and comes with all needed modules for tensor arithmetics, activation and loss functions, covolution kernels, and backpropagation algorithms. So you can build your own neural net structure. Keras offers a simple interface for that.

  Keras is available as a R library, but installing it requires also a Python environment. First install Anaconda from www.anaconda.com. Open the Anaconda Navigator and install the RStudio application (installing Keras outside an Anaconda environment fails on some PCs with an error message). Then open Rstudio inside the Navigator, install the Keras package, then finally execute library(‘keras’) and install_keras(). These steps usually succeed.

  The Keras train and predict functions for Zorro:

  library('keras')
  #needs Python 3.6 and Anaconda
  #call install_keras() after installing the package
  
  neural.train = function(model,XY) 
  {
    X <- data.matrix(XY[,-ncol(XY)])
    Y <- XY[,ncol(XY)]
    Y <- ifelse(Y > 0,1,0)
    Model <- keras_model_sequential() 
    Model %>% 
      layer_dense(units=30,activation='relu',input_shape = c(ncol(X))) %>% 
      layer_dropout(rate = 0.2) %>% 
      layer_dense(units = 1, activation = 'sigmoid')
    
    Model %>% compile(
      loss = 'binary_crossentropy',
      optimizer = optimizer_rmsprop(),
      metrics = c('accuracy'))
    
    Model %>% fit(X, Y, 
      epochs = 20, batch_size = 20, 
      validation_split = 0, shuffle = FALSE)
    
    Models[[model]] <<- Model
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- t(X)
    X <- as.matrix(X)
    Y <- Models[[model]] %>% predict_proba(X)
    return(ifelse(Y > 0.5,1,0))
  }
  

• MxNet, Amazon’s answer on Google’s Tensorflow. Offers also tensor arithmetics and neural net building blocks on CPU and GPU, as well as high level network functions similar to Keras (the next Keras version will also support MxNet). Just as with Tensorflow, CUDA is supported, but not (yet) OpenCL, so you’ll need a Nvidia graphics card to enjoy GPU support. In direct comparison (2), MxNet was reported to be less resource hungry and a bit faster than Tensorflow, but so far I could not confirm this. The standard train and predict functions:

  # how to install the CPU version:
  #cran <- getOption("repos")
  #cran["dmlc"] <- "https://s3-us-west-2.amazonaws.com/apache-mxnet/R/CRAN/"
  #options(repos = cran)
  #install.packages('mxnet')
  library('mxnet')
  
  neural.train = function(model,XY) 
  {
    X <- data.matrix(XY[,-ncol(XY)])
    Y <- XY[,ncol(XY)]
    Y <- ifelse(Y > 0,1,0)
    Models[[model]] <<- mx.mlp(X,Y,
         hidden_node = c(30), 
         out_node = 2, 
         activation = "sigmoid",
         out_activation = "softmax",
         num.round = 20,
         array.batch.size = 20,
         learning.rate = 0.05,
         momentum = 0.9,
         eval.metric = mx.metric.accuracy)
  }
  
  neural.predict = function(model,X) 
  {
    if(is.vector(X)) X <- t(X)
    X <- data.matrix(X)
    Y <- predict(Models[[model]],X)
    return(ifelse(Y[1,] > Y[2,],0,1))
  }
  

By replacing the neural.train and neural.predict functions, and other functions for saving and loading models that are not listed here, you can run the same strategy with different deep learning packages and compare. We’re currently using Keras for most machine learning strategies, and I’ll also use it for the short-term bitcoin trading system presented in the upcoming 2nd part of this article. There is no bitcoin futures data available yet, so tick based price data from several bitcoin exchanges will have to do for the backtest.

I’ve uploaded the interface scripts for Deepnet, H2O, Tensorflow/Keras, and MxNet to the 2018 script repository, so you can run your own deep learning experiments and compare the packages. Here’s a Zorro script for downloading bitcoin prices from Quandl – EOD only, though, since the exchanges demand dear payment for their tick data.

void main()
{
  assetHistory("BITFINEX/BTCUSD",FROM_QUANDL);
}

You can also get Bitcoin M1 data from Kaggle in CSV format. Here’s a Zorro script for converting it to a Zorro T6 dataset:

void main()
{
	string InName = "History\\bitstampUSD_1-min_data_2012-01-01_to_2019-03-13.csv";
	string Format = "+%t,f3,f1,f2,f4,f6";
	dataParse(1,Format,InName); 
	dataSave(1,"History\\BTCUSD.t6");
}

Further reading

(1) Nicolas Rabener, Quant Strategies in the Cryptocurrency Space

(2) Julien Simon, Tensorflow vs MxNet

(3) Zachary Lipton et al, MxNet – The Straight Dope
(Good introduction in deep learning with MxNet / Gluon examples)

(4) F.Chollet/J.J.Allaire, Deep Learning with R
(Excellent introduction in Keras)