Neural networks in Ripple

We need data. We need a model to process the data. We need the model to evolve.

The full code can be found at https://github.com/jhlq/trademaker/blob/master/AI.jl

All trades in the Ripple network are stored, the first thousand BTC trades are here: https://ripple.com/chart/BTC/XRP/trades.json?since=1

To get a random set of a thousand trades in Julia we first define
start=1000*abs(rand(Int)%100)
Then do:
trades=JSON.parse(readall(`curl https://ripple.com/chart/BTC/XRP/trades.json?since=$start`))
Or, using the Requests package:
trades=JSON.parse(get("https://ripple.com/chart/BTC/XRP/trades.json?since=$start").data)

This will yield non overlapping sets which facilitates database storage (there is a SQLite package) however for training purposes overlapping sets are often better since this translates to more training examples.

Next we divide the trades, one part the model looks at to predict the other part.
np=100
peek=zeros(np,2)
for t in 1:np
  peek[t,1]=float(trades[t]["price"])
  peek[t,2]=float(trades[t]["amount"])*(0.5+0.5*t/100)
end
The amount is scaled so that a most recent trade contributes twice as much as one a hundred trades ago.

Now we make a histogram, for algorithmic reasons the number of intervals should be odd.
ma=maximum(peek[:,1])
mi=minimum(peek[:,1])
niv=33
bars=zeros(niv)
intervall=(ma-mi)/niv
for t in 1:np
  for iv in 1:niv
    if peek[t,1]<mi+intervall*iv
      bars[iv]+=peek[t,2]
      break
    end
  end
end

Here is where the model decides which bids to place, lets put one each in two of the most popular intervalls:
maxi=sortperm(bars,rev=true)
bidiv1=maxi[1]*intervall+mi
bidiv2=maxi[2]*intervall+mi

If they both get bought we make a profit so lets grade the bids based on how long it takes for one BTC to be traded in both intervalls.
bid1val=0
bid2val=0
barval=0
for testi in 101:1000
  test=[float(trades[testi]["price"]),float(trades[testi]["amount"])]
  for iv in 1:niv
    if test[1]bidiv1-intervall
      bid1val+=test[2]
      break
    elseif test[1]bidiv2-intervall
      bid2val+=test[2]
      break
    end
  end
  if bid1val>1 && bid2val>1
    println(testi)
    barval=1-(testi-101)/900
    break
  end
end

The bars and barval are what matters, they are the training sample and its prediction target. Lets make some functions for working with neural networks, the ones in AI.jl are called: makenet, mutate and feed. The bars are not quite ready to be fed to a network, first we need to make them spatially invariant since a vector of [1,0,1,0,0] contains essentially the same information as [0,0,1,0,1] but they will be treated entirely different, lets see them both as a vector containing a gap of length one.
function transpatinvari(d)
  dn=d/maximum(abs(d))
  nd=length(dn)
  if nd%2==0
    push!(dn,0) #for symmetry
    nd+=1
  end
  t=zeros(nd)
  for da in 1:nd
    for dat in 0:nd-da
      t[1+dat]+=dn[da]*simil(dn[da],dn[da+dat])
      #simil is a custom similarity measure
    end
  end
  return t
end

After feeding the network these transformed bars its prediction is scored based on the similarity to barval. Many algorithms can be based on such a score, below is one which randomly mutates the top performers in each generation.
function evolve(net=makenet(33,50,3),gens=3,its=9)
  #its is the number of iterations per generation
  nn=9
  m1=6
  nets=mutate(net,nn)
  tnets=nets
  scores=Array(Array,gens)
  for gen in 1:gens
    scores[gen]=score(nets,its)
    tops=sortperm(scores[gen],rev=true)
    tnets[1:m1]=mutate(nets[tops[1]],m1)
    tnets[m1+1:end]=mutate(nets[tops[2]],nn-m1)
    nets=tnets
  end
  return nets,scores
end

nets=evolve()

Evolution can be boosted by having the mutator evolve. Each time a neuron is perturbed the result is logged and the mutator remembers the effect of mutating that neuron.