Simple neural network autoencoder with candlesticks and 🍺

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";

//sample collector 
  //one sample has x bars values and the range min max 
    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){
           //get a windows data essentially
             //we'll use iseries here - make sure your chart is properly loaded 
               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 
                 range=max-min;
               //divisions
                 for(int i=0;i<size;i++){
                    bars[i]/=range;//-1.0 to 1.0
                    //turn to 0.0 to 1.0 because we have sigmoid and it wont be able to match outputs to inputs ever
                    bars[i]=(bars[i]+1.0)/2.0;
                    }
               //nice
           }
    };

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[],//we receive the %'s here 
                       uint &pixels[],//the pixels where we draw 
                       int &side_size,//the size of the sides of the output pixels
                       color bgColor,//background color
                       color upColor,//up fake bar color
                       color dwColor//down fake bar color
                       ){
//erase 
  ArrayFill(pixels,0,ArraySize(pixels),ColorToARGB(bgColor,255));
  /*
  this needs to be visible above all so we have x amount of bars 
  x+1 amount of gaps on the horizontal axis 
  each gap is half the fake bar so we have x+(x+1)/2 steps 
  tfb=total_fake_bars
  about x axis : 
      gap_size=bar_size/2;
      total_x=gap_size*(tfb+1)+bar_size*tfb;
      total_x=(bar_size/2)*(tfb+1)+bar_size*tfb;
      total_x=(bar_size)*[((tfb+1)/2)+tfb];
      bar_size=total_x/[((tfb+1)/2)+tfb];
  */
  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;
  //neat
  //starting x
  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;//reset stats after batch
input double base_learning_rate=0.001;//base learning rate 

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;
  
  //train a batch
    //we will train a random order amount of samples 
    int ix=0;
    for(int i=0;i<ArraySize(COLLECTION.samples);i++)
     {
     //first create xor inputs 0 or 1 and the expected result 
       ix+=MathRand();
       while(ix>=ArraySize(COLLECTION.samples)){ix-=ArraySize(COLLECTION.samples);}
     //lets pass the features through the network
       net.feed_forward(COLLECTION.samples[ix].bars);//bars are the features
     //and lets calculate the loss 
       net.calculate_loss(COLLECTION.samples[ix].bars);//bars are also the results   
     //and lets backpropagate the error (we are not adjusting -learning- anything yet)
       net.back_propagation();  
     } 
     //"learn"
     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){
    //find which node 
      if(StringFind(sparam,SYSTEM_TAG+"_NODE",0)!=-1){
        for(int i=0;i<middleNodes;i++){
           //get the value 
             double v=(double)StringToDouble(ObjectGetString(ChartID(),SYSTEM_TAG+"_NODE"+IntegerToString(i),OBJPROP_TEXT));
           //restrict it 
             if(v<0.0){v=0.0;}else if(v>1.0){v=1.0;}
           //pass it in the middle layer as output 
             net.layers[2].nodes[i].output=v;
           }
        //and do a partial feed forward 
          net.partial_feed_forward(3);
        //fill fake bars 
          double fake_bars[];
          ArrayResize(fake_bars,20,0);
          for(int i=0;i<20;i++){fake_bars[i]=net.get_output(i);}
          //awesome but wait , these bars are 0.0 to 1.0 we must turn them to -1.0 to 1.0
          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);
          //create resource 
            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++){
           //get the value 
             double v=(double)StringToDouble(ObjectGetString(ChartID(),SYSTEM_TAG+"_NODE"+IntegerToString(i),OBJPROP_TEXT));
           //restrict it 
             if(v<0.0){v=0.0;}else if(v>1.0){v=1.0;}
           //pass it in the middle layer as output 
             net.layers[2].nodes[i].output=v;
           }
        //and do a partial feed forward 
          net.partial_feed_forward(3);
        //fill fake bars 
          double fake_bars[];
          ArrayResize(fake_bars,20,0);
          for(int i=0;i<20;i++){fake_bars[i]=net.get_output(i);}
          //awesome but wait , these bars are 0.0 to 1.0 we must turn them to -1.0 to 1.0
          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);
          //create resource 
            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){
              //get the bars of the chart 
                int barz=iBars(_Symbol,_Period);
                if(barz>TerminalInfoInteger(TERMINAL_MAXBARS)){barz=TerminalInfoInteger(TERMINAL_MAXBARS);}
                //we kinda want more than a 1000 samples 
                //let's create a sliding window so 19 of the 20 ... wait
                //window_size-1 of the bars will be the same across samples , this will create some interesting uses
                  int samples_possible=barz-window_size;
                  if(samples_possible>1000){
                  //okay so from the oldest bar possible to the recent bar possible 
                    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);
                       //add_sample(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