Cool let’s create our pattern collector actual fast , easy sh*t from the ohlc historical past of the chart.

#property model   "1.00"
#embrace "miniNeuralNet.mqh";


  
    class ae_sample{
           public:
    double min,max,vary;
    double bars[];
           ae_sample(void){reset();}
          ~ae_sample(void){reset();}
      void reset(){
           ArrayFree(bars);
           min=INT_MAX;
           max=INT_MIN;
           vary=0.0;
           }
      void fill(int oldest_bar,int measurement){
           
             
               ArrayResize(bars,measurement,0);
               ArrayFill(bars,0,measurement,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);
                  }
               
                 vary=max-min;
               
                 for(int i=0;i<measurement;i++){
                    bars[i]/=vary;
                    
                    bars[i]=(bars[i]+1.0)/2.0;
                    }
               
           }
    };

Good , the loss perform might be a sign with the remark perform ,then 2 edits and a useful resource.
Let’s begin there , a field to which we ship bar-sizes of a % to its sides measurement and we plot the “logical” sequence of them
hopefully , if we get out of bounds we’ll want to increase the “hypothetical canvas” although as a result of we have to see.

Okay much less typing extra typing :

void create_fake_chart(double &fake_bars[],
                       uint &pixels[],
                       int &side_size,
                       colour bgColor,
                       colour upColor,
                       colour 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;
  
  
}

Which means the inputs are hidden by default and there must be a pause button above them , hopefully the final mods we do , we set the loaded indication as true we add a busy indication and we’re good to go .

So we add these 2 parameters on prime 

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

Then a swap to point coaching is just not paused

bool Prepare=false;

and that is what the coaching block appears to be like like :

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

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

1. change it to “Proceed”
2. present the two node inputs
3. present the show block
4. set Prepare to false

void OnChartEvent(const int id,const lengthy& lparam,const double& dparam,const string& sparam)
  {
  if(Loaded&&id==CHARTEVENT_OBJECT_CLICK){
    if(sparam==SYSTEM_TAG+"_PAUSE"&&Prepare){
      ObjectSetString(ChartID(),SYSTEM_TAG+"_PAUSE",OBJPROP_TEXT,"Proceed");
      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);
      Prepare=false;
      }else if(sparam==SYSTEM_TAG+"_PAUSE"&&!Prepare){
      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);
      Prepare=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]);
              }
           }

Easy , we see that the feed ahead will begin from the layer we ship in so if we stuffed outputs for the layer the arrow is pointint as much as then we are going to begin from the following layer , so 0 , 1, 2 ,thats layer 3 .

And we are going to refill a “pretend bars” array to ship all the way down to the plotter. we do not overlook our output is between 0.0 and 1.0 and we have to flip 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;}
           
             internet.layers[2].nodes[i].output=v;
           }
        
          internet.partial_feed_forward(3);
        
          double fake_bars[];
          ArrayResize(fake_bars,20,0);
          for(int i=0;i<20;i++){fake_bars[i]=internet.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,show,display_size,clrBlack,clrGreen,clrCrimson);
          
            if(ResourceCreate("DISPLAY",show,display_size,display_size,0,0,display_size,COLOR_FORMAT_ARGB_NORMALIZE)){
              ChartRedraw();
              }
        }
    }

Then we create the useful resource , redraw the chart .However it could be handy to throw that right into a perform as a result of we might have
to name 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;}
           
             internet.layers[2].nodes[i].output=v;
           }
        
          internet.partial_feed_forward(3);
        
          double fake_bars[];
          ArrayResize(fake_bars,20,0);
          for(int i=0;i<20;i++){fake_bars[i]=internet.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,show,display_size,clrBlack,clrGreen,clrCrimson);
          
            if(ResourceCreate("DISPLAY",show,display_size,display_size,0,0,display_size,COLOR_FORMAT_ARGB_NORMALIZE)){
              ChartRedraw();
              }
}

and we add a name once we pause the learnign and once we replace the node values manually.neat

Nicely as anticipated , there’s a bottleneck in samples filling up 

So we’ll should presize the samples within the assortment …. however , vibrant aspect we’ll get 90k samples , that is good , will likely be sluggish af however good.

So we’re altering the fill perform of the pattern 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--){
                       Remark("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 points within the pattern assortment , you will not see them as i will edit the code snippets.

The second run was higher , it converged sooner and had no bizarre alien numbers , and it kinda appears to be like like an actual chart once you hit pause .

And it appears to be like like value motion once we manually tune the nodes within the center 

after all one can say , bruh , all the pieces that comes out of the output may very well be plotted as value motion . true.

Let’s have a look at if we are able to animate this sh*t , and perceive what the two knobs …

what the two nobs imply . That is how AIs are drawing issues btw , all you gotta do (or it) is work out what the little nodes within the center tune.

So , let’s add a button that stops coaching however begins animating subsequent to the pause , we may make this look higher however i can simply go look within the mirror 😇 (jk) sco lets end this.

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

Lets see what occurs :

hmm it appears to be like value actiony

what if we begin from totally different values for the nodes ?

There are mixtures in there that may very well be describing totally different exercise , so if one figures out what the encoder parameters do then you possibly can be a synthetic coaching value feed for example that resembles usdjpy (on this instance)

Learn extra concerning the easiest neural internet right here