Simple neural network autoencoder with candlesticks and 🍺 – Neural Networks – 7 April 2023

Cool let’s create our sample collector real quick , simple sh*t from the ohlc history of the chart.

#property version   "1.00"
#include "miniNeuralNet.mqh";


  
    class ae_sample{
           public:
    double min,max,range;
    double bars[];
           ae_sample(void){reset();}
          ~ae_sample(void){reset();}
      void reset(){
           ArrayFree(bars);
           min=INT_MAX;
           max=INT_MIN;
           range=0.0;
           }
      void fill(int oldest_bar,int size){
           
             
               ArrayResize(bars,size,0);
               ArrayFill(bars,0,size,0.0);
               int co=-1;
               for(int i=oldest_bar;i>oldest_bar-size;i--){
                  co++;
                  if(iHigh(_Symbol,_Period,i)>max){max=iHigh(_Symbol,_Period,i);}
                  if(iLow(_Symbol,_Period,i)<min){min=iLow(_Symbol,_Period,i);}
                  bars[co]=iClose(_Symbol,_Period,i)-iOpen(_Symbol,_Period,i);
                  }
               
                 range=max-min;
               
                 for(int i=0;i<size;i++){
                    bars[i]/=range;
                    
                    bars[i]=(bars[i]+1.0)/2.0;
                    }
               
           }
    };

Good , the loss function can be an indication with the comment function ,then 2 edits and a resource.
Let’s start there , a box to which we send bar-sizes of a % to its sides size and we plot the “logical” sequence of them
hopefully , if we get out of bounds we’ll need to extend the “hypothetical canvas” though because we need to see.

Okay less typing more typing :

void create_fake_chart(double &fake_bars[],
                       uint &pixels[],
                       int &side_size,
                       color bgColor,
                       color upColor,
                       color dwColor
                       ){

  ArrayFill(pixels,0,ArraySize(pixels),ColorToARGB(bgColor,255));
  
  double tfb=((double)ArraySize(fake_bars));
  double bar_size=((double)side_size)/(((tfb+1.0)/2.0)+tfb);
  double gap_size=bar_size/2.0;
  
  
  double start_x=gap_size;
  
  
}

That means the inputs are hidden by default and there should be a pause button above them , hopefully the last mods we do , we set the loaded indication as true we add a busy indication and we are good to go .

So we add these 2 parameters on top 

input bool reset_stats_after_batch=true;
input double base_learning_rate=0.001;

Then a switch to indicate training is not paused

bool Train=false;

and this is what the training block looks like :

  if(!SystemBusy&&Train){
  SystemBusy=true;
  
  
    
    int ix=0;
    for(int i=0;i<ArraySize(COLLECTION.samples);i++)
     {
     
       ix+=MathRand();
       while(ix>=ArraySize(COLLECTION.samples)){ix-=ArraySize(COLLECTION.samples);}
     
       net.feed_forward(COLLECTION.samples[ix].bars);
     
       net.calculate_loss(COLLECTION.samples[ix].bars);
     
       net.back_propagation();  
     } 
     
     double max_loss=net.get_max_loss_per_sample();
     double cur_loss=net.get_current_loss_per_sample();
     double a=(cur_loss/max_loss)*base_learning_rate;
     net.adjust(a);
     if(reset_stats_after_batch){net.reset_loss();} 
     string comm="Loss ("+cur_loss+")/("+max_loss+")";
     Comment(comm);     
  
  SystemBusy=false;
  }

Okay , now , lastly , when the pause button is hit we :

1. change it to “Continue”
2. show the 2 node inputs
3. show the display block
4. set Train to false

void OnChartEvent(const int id,const long& lparam,const double& dparam,const string& sparam)
  {
  if(Loaded&&id==CHARTEVENT_OBJECT_CLICK){
    if(sparam==SYSTEM_TAG+"_PAUSE"&&Train){
      ObjectSetString(ChartID(),SYSTEM_TAG+"_PAUSE",OBJPROP_TEXT,"Continue");
      for(int i=0;i<middleNodes;i++){
         ObjectSetInteger(ChartID(),SYSTEM_TAG+"_NODE"+IntegerToString(i),OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);    
         }
      ObjectSetInteger(ChartID(),SYSTEM_TAG+"_DISPLAY",OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);
      Train=false;
      }else if(sparam==SYSTEM_TAG+"_PAUSE"&&!Train){
      ObjectSetString(ChartID(),SYSTEM_TAG+"_PAUSE",OBJPROP_TEXT,"Pause");
      for(int i=0;i<middleNodes;i++){
         ObjectSetInteger(ChartID(),SYSTEM_TAG+"_NODE"+IntegerToString(i),OBJPROP_TIMEFRAMES,OBJ_NO_PERIODS);    
         }
      ObjectSetInteger(ChartID(),SYSTEM_TAG+"_DISPLAY",OBJPROP_TIMEFRAMES,OBJ_NO_PERIODS);
      Train=true;      
      }
    }
  }

      void partial_feed_forward(int from_layer_ix){
           for(int i=from_layer_ix;i<ArraySize(layers);i++){
              layers[i].feed_forward(layers[i-1]);
              }
           }

Simple , we see that the feed forward will start from the layer we send in so if we filled outputs for the layer the arrow is pointint up to then we will start from the next layer , so 0 , 1, 2 ,thats layer 3 .

And we will fill up a “fake bars” array to send down to the plotter. we don’t forget our output is between 0.0 and 1.0 and we need to turn it to  -1.0 to 1.0 

  else if(Loaded&&id==CHARTEVENT_OBJECT_ENDEDIT){
    
      if(StringFind(sparam,SYSTEM_TAG+"_NODE",0)!=-1){
        for(int i=0;i<middleNodes;i++){
           
             double v=(double)StringToDouble(ObjectGetString(ChartID(),SYSTEM_TAG+"_NODE"+IntegerToString(i),OBJPROP_TEXT));
           
             if(v<0.0){v=0.0;}else if(v>1.0){v=1.0;}
           
             net.layers[2].nodes[i].output=v;
           }
        
          net.partial_feed_forward(3);
        
          double fake_bars[];
          ArrayResize(fake_bars,20,0);
          for(int i=0;i<20;i++){fake_bars[i]=net.get_output(i);}
          
          for(int i=0;i<20;i++){fake_bars[i]=(fake_bars[i]*2.0)-1.0;}
          create_fake_chart(fake_bars,display,display_size,clrBlack,clrGreen,clrCrimson);
          
            if(ResourceCreate("DISPLAY",display,display_size,display_size,0,0,display_size,COLOR_FORMAT_ARGB_NORMALIZE)){
              ChartRedraw();
              }
        }
    }

Then we create the resource , redraw the chart .But it would be convenient to throw that into a function because we may need
to call it elsewhere too so :

void calculate_fake_chart(){
        for(int i=0;i<middleNodes;i++){
           
             double v=(double)StringToDouble(ObjectGetString(ChartID(),SYSTEM_TAG+"_NODE"+IntegerToString(i),OBJPROP_TEXT));
           
             if(v<0.0){v=0.0;}else if(v>1.0){v=1.0;}
           
             net.layers[2].nodes[i].output=v;
           }
        
          net.partial_feed_forward(3);
        
          double fake_bars[];
          ArrayResize(fake_bars,20,0);
          for(int i=0;i<20;i++){fake_bars[i]=net.get_output(i);}
          
          for(int i=0;i<20;i++){fake_bars[i]=(fake_bars[i]*2.0)-1.0;}
          create_fake_chart(fake_bars,display,display_size,clrBlack,clrGreen,clrCrimson);
          
            if(ResourceCreate("DISPLAY",display,display_size,display_size,0,0,display_size,COLOR_FORMAT_ARGB_NORMALIZE)){
              ChartRedraw();
              }
}

and we add a call when we pause the learnign and when we update the node values manually.neat

Well as expected , there is a bottleneck in samples filling up 

So we’ll have to presize the samples in the collection …. but , bright side we’ll get 90k samples , that’s good , will be slow af but good.

So we are changing the fill function of the sample collector to this : 

          int fill(int window_size){
              
                int barz=iBars(_Symbol,_Period);
                if(barz>TerminalInfoInteger(TERMINAL_MAXBARS)){barz=TerminalInfoInteger(TERMINAL_MAXBARS);}
                
                
                
                  int samples_possible=barz-window_size;
                  if(samples_possible>1000){
                  
                    int co=-1;
                    ArrayResize(samples,samples_possible,0);
                    for(int i=barz-1;i>=(1+window_size);i--){
                       Comment("Filling "+i);
                       co++;
                       samples[co].fill(i,window_size);
                       
                       }
                    ArrayResize(samples,co+1,0);
                  } 
              return(ArraySize(samples));
              }

Now this run into nan -nan errors at first , so , theres issues in the sample collection , you won’t see them as i’ll edit the code snippets.

The second run was better , it converged faster and had no weird alien numbers , and it kinda looks like a real chart when you hit pause .

And it looks like price action when we manually tune the nodes in the middle 

of course one can say , bruh , everything that comes out of the output could be plotted as price action . true.

Let’s see if we can animate this sh*t , and understand what the 2 knobs …

what the 2 nobs mean . That’s how AIs are drawing things btw , all you gotta do (or it) is figure out what the little nodes in the middle tune.

So , let’s add a button that stops training but starts animating next to the pause , we could make this look better but i can just go look in the mirror 😇 (jk) sco lets finish this.

we add the button ,we add the animating switch , and steps and current values for the nobs. the animator will be taking one step  per timer entry and drawing it.

Lets see what happens :

hmm it looks price actiony

what if we start from different values for the nodes ?

There are combinations in there that could be describing different activity , so if one figures out what the encoder parameters do then you could be looking at an artificial training price feed for instance that resembles usdjpy (in this example)

Read more about the simplest neural net here