Author: Denis Janulis
IndiTest

This script is designed as an automated trading assistant that utilizes artificial intelligence—specifically a neural network—to identify "OverBought" and "OverSold" conditions in financial markets. Instead of relying on simple static rules, it attempts to "learn" market patterns from historical data to make predictions about price movements.

How the Logic Works

1. Data Collection and Preparation The script constantly monitors the market by gathering a variety of technical indicators (Moving Averages). It looks at how these averages have shifted over time to create a comprehensive "picture" of current market conditions. This information is converted into a standardized format so that the neural network can interpret it clearly as a set of inputs.

2. Dual-Network System The logic operates two distinct neural networks simultaneously:

  • OverBought Network: Trained to recognize conditions where prices may be too high and likely to pull back (potential Sell signals).
  • OverSold Network: Trained to recognize conditions where prices may be too low and likely to bounce back (potential Buy signals).

3. Continuous Learning (Training) The script doesn't just set a model and forget it; it performs two types of learning:

  • Initial Training: When the script first starts, it looks back at a specific amount of historical data (the "History" bars) to build its initial understanding of what a "Buy" or "Sell" environment looks like.
  • Ongoing Learning (Post-Training): As new market data arrives in real-time, the script evaluates whether the market is moving as expected. If it identifies a confirmed movement, it feeds that "success" back into the neural networks to refine their accuracy.

4. Network Maintenance (Self-Optimization) To ensure the AI remains accurate and doesn't get cluttered with "noise," the script performs regular maintenance:

  • Pruning: It identifies and removes "weak" neurons (data points that aren't contributing effectively to accurate predictions).
  • Age Management: It can remove old data/neurons to ensure the AI stays focused on recent market trends.
  • Weight Adjustment: It recalculates the importance (weights) of different data points to ensure the most relevant information has the biggest impact on the final prediction.

5. Signal Generation Finally, the script combines the outputs of both networks into a single score.

  • By comparing the intensity of the "OverBought" vs. "OverSold" predictions, it calculates a balance.
  • It then compares this balance against specific "Activation" thresholds. If the market sentiment becomes extreme enough in either direction (surpassing the calculated limits), the script triggers an alert to notify the user of a potential Buy or Sell opportunity.

Summary for the User

Think of this script as an automated analyst that is constantly studying the history of the charts. It builds a "memory" of what past winning trades looked like and constantly tweaks its internal logic based on new market events. It then alerts you when the current market behavior closely resembles those profitable patterns from the past, while actively "cleaning" its own brain to stay sharp and relevant.

Indicators Used
Moving average indicator
Miscellaneous
It issuies visual alerts to the screen
1 Views
1 Downloads
0 Favorites
IndiTest
//+------------------------------------------------------------------+
//|                                                       expert.mq4 |
//|                                                    Denis Janulis |
//|                                                  denis.j@mits.lv |
//+------------------------------------------------------------------+
#property copyright "Denis Janulis"
#property link      "denis.j@mits.lv"


#property indicator_chart_window

#import "dpnn.dll" 
extern int lastBar=0;
/* 
extern int Start=0;   
extern int TargetUp=60;
extern int TargetDown=60;
extern int Totalsignals=1000;
extern bool UPDirection=true; 
*/                                    // DPNN.DLL - ïîäêëþ÷àåì ñåòü
//--------------------------------------------------------------------
extern double MinW = 0.00100200;                           // êðèòåðèé ñëàáîñòè íåéðîíîâ.     Åñëè 0, òî æèâóò âå÷íî     
extern double LifeTime = 500;                              // âðåìÿ æèçíè íåéðîíîâ (â áàðàõ). Åñëè 0, òî æèâóò âå÷íî
extern double MinTV = 0.2;                                 // Ïîðîã êîíôëèêòîâ
extern double MaxTV = 0.95; 
                              // Ïîðîã èíäèâèäóàëüíîñòè
//--------------------------------------------------------------------
                                                           // Îñíîâíûå íåîáõîäèìûå ôóíêöèè ðàáîòû ñ ñåòüþ                                                          
    double CreateNet(string NN, int InputVectorSize,       // Ñîçäàåò ñåòü ñ êîëè÷åñòâîì íåéðîíîâ âî âõîäíîì âåêòîðå <i>. 
                     double MinTV, double MaxTV,           // è âîçâðàùàåò íîìåð ñåòè, ïîä êîòîðûì ñîçäàëàñü
                     double MW , int NL);          
    int    DestroyNet(string NN);                          // Óíè÷òîæàåò ñåòü <NetName>, âîçâðàùàåò êîëè÷åñòâî îñòàâøèõñÿ ñåòåé
    double TrainNet(string NetName,double& iX[],int T,datetime sT);    // Îáó÷àåò ñåòü íà ïðèìåðå Õ[InputVectorSize] c îòâåòîì Ò
    double GetPredict(string NetName,double& iX[],datetime sT);        // Âîçâðàùàåò ïðåäñêàçàíèå ñåòè 0<=Out<=1
    void   Shrink(string NetName);                         // ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
    void   WReset(string NetName);                         // (A) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
    void   AEqual(string NetName);                         // (A) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
    void   CW(string NetName);                             // (w) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ                        
    int SizeOfNet(string NetName);                         // Âîçâðàùàåò êîëè÷åñâî Ãàóññîâñêèõ íåéðîíîâ
    void KillWeaks(string NetName); 
    void KillOlds(string NetName,datetime sT);
//-------------------------------------------------------------------
int InputVectorSize = 24;                                  // Ðàçìåðíîñòü âõîäíîãî âåêòîðà
double X[24];                                              // Âõîäíîé âåêòîð ñåòè
//-------------------------------------------------------------------
extern int    n = 10;                                      // Ïàðàìåòðû äëÿ "ó÷èòåëÿ" ñì. èíäèêàòîð djama
extern int    p = 2;                                       
extern int    q = 2;
extern bool   allowTrailingStop   = true;                  // Ðàçðåøàåì òðàëû
extern bool   allowPostTraining   = true;                  // Ðàçðåøàåì äîîáó÷åíèå
extern int    StopLoss            =   50;                   
extern int    TakeProfit          =  400;
extern int    TrailingStop = 150;
extern int    HistoryBars         = 500;                  // Íà ñêîëüêèõ áàðàõ ïðîâîäèòü ïðåäâàðèòåëüíîå îáó÷åíèå
extern int    Repetitions         =    5;                  // Ñêîëüêî ðàç ïðîãíÿòü îáó÷åíèå ñåòè ????                                            
extern int    Activation_n = 100;                          // Ïàðàìåòðû äëÿ "àêòèâàöèîííîé ôóíêéèè" ñì. èíäèêàòîð djama   
extern int    Activation_p = 2;                            
extern int    Activation_q = 30;                    
extern double ActivationMax = 0.95;
extern double ActivationMin = 0.6;
extern double ActivationK  = 15000;  

       double ActivationBuy;
       double ActivationSell; 
//--------------------------------------------------------------------
       double Lots                =  0.1;
       int    MinMargin           =  200;   // Ìèíèìàëüíàÿ ìàðæà
     datetime prevtime            =    0;
       double Out;                          // Ðåçóëüòàò ðàáîòû ñåòåé 
bool existent = false;                                 
//********************************************************************
void BuildX(int FinishBar)                  // Ìîäóëü ñîáèðàåò è ïîäãîòàâëèâàåò äàííûå äëÿ çàãðóçêè â ñåòü
 {                                          // FinishBar - Ñ êàêîãî áàðà ñíèìàòü çíà÷åíèÿ.
 int B = InputVectorSize;
 double rD[24][24];
 double Min[24];
 double Max[24];
 if (FinishBar > Bars)
    { 
     Print("MaxBars Error = ",Bars);
     return;
    }
 for (int i=B-1;i>=0;i--)
      {
      rD[i][0] = iMA(NULL,0,2,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,2,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][1] = iMA(NULL,0,4,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,4,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][2] = iMA(NULL,0,6,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,6,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][3] = iMA(NULL,0,8,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,8,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][4] = iMA(NULL,0,10,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,10,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][5] = iMA(NULL,0,12,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,12,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][6] = iMA(NULL,0,14,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,14,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][7] = iMA(NULL,0,16,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,16,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][8] = iMA(NULL,0,18,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,18,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][9] = iMA(NULL,0,20,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,20,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][10] = iMA(NULL,0,22,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,22,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][11] = iMA(NULL,0,24,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,24,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][12] = iMA(NULL,0,26,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,26,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][13] = iMA(NULL,0,28,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,28,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][14] = iMA(NULL,0,30,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,30,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][15] = iMA(NULL,0,32,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,32,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][16] = iMA(NULL,0,34,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,34,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][17] = iMA(NULL,0,36,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,36,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][18] = iMA(NULL,0,38,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,38,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][19] = iMA(NULL,0,40,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,40,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][20] = iMA(NULL,0,42,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,42,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][21] = iMA(NULL,0,44,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,44,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][22] = iMA(NULL,0,46,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,46,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][23] = iMA(NULL,0,48,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,48,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  for (int n = 0; n <= B-1; n++)                      // Îïðåäåëÿåì ìèíèìàëüíûå è ìàêñèìàëüíûå âåëè÷èíû
  {
   Min[n] = rD[0][n];
   Max[n] = rD[0][n];
   for ( i = 0; i <= B-1; i++)
   {
   if (rD[i][n] > Max[n]) Max[n] = rD[i][n];
   if (rD[i][n] < Min[n]) Min[n] = rD[i][n];
   }
  } 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  for ( n = 0; n <= B-1; n++)                                              // Íîðìèðóåò âõîäíîé âåêòîð íà 1
  {
    if (Max[n]== Min[n]) 
        {
         for ( i = 0; i <= B-1; i++) X[i] = Max[n];
         return;
        }
 X[n] = (rD[0][n] - Min[n])/(Max[n]-Min[n]);                               // Âõîäíîé âåêòîð, íîðìèðîâàííûé íà 1    
  }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
  
return;   
 }
//-------------------------------------------------------------------------------------------------------------------
int BuildT(int i)                                                          // Òóò ïîëó÷àåì ïðàâèëüíûé îòâåò ïî ïåðåêóïëåííîñòè 
{                                                                          // èëè ïåðåïðîäàííîñòè
  int T= 0;

  double Previous = djama(n,p,q,i+1);    
  double Current = djama(n,p,q,i);
  double Next = djama(n,p,q,i-1);
 
  if (Current <= Next) T = -1; 
  if (Current > Next) T =  1;  
  return (T);
}
//*******************************************************************************************************************
int Create(string NetName,int InputVectorSize)                             // Ñîçäàåò ñåòü ñ èìåíåì <NetName> è âõîäíûì âåêòîðîì ðàçìåðà
{                                                                          // InputVectorSize. Âûâîäèò íîìåð ñåòè (òóò îí æå îáùåå êîëè÷åñòâî
 int NeuronLife = Period()*60*LifeTime;                                    // ñåòåé) â áèáëèîòåêå. 
 int Out =  CreateNet(NetName,InputVectorSize,MinTV,MaxTV,MinW,NeuronLife);     
return(Out);
}
//-------------------------------------------------------------------------------------------------------------------
int Destroy(string NetName)                                                // Óíè÷òîæàåò ñåòü ñ èìåíåì <NetName> è âîçâðàùàåò îáùåå
{                                                                          // êîëè÷åñòâî ñåòåé îñòàâøèõñÿ â áèáëèîòåêå
return(DestroyNet(NetName));
}
//-------------------------------------------------------------------------------------------------------------------
double Train(string NetName,double& iX[],int T)                            // Ïîäàåò â ñåòü <NetName> âåêòîð X è îòâåò T äëÿ îáó÷åíèÿ íà ïðèìåðå i
{                                                                          // Âîçâðàùàåò Out cåòè
 double Out =  TrainNet(NetName,iX,T,iTime(Symbol(),0,1));                                    // Out=1, ñåòü äîáàâèëà íîâûé îáðàç. Out =2 - ñåòü ðàñïîçíàëà îáðàç è ïîäïðàâèëàñü.
return(Out);
} 

//-------------------------------------------------------------------------------------------------------------------
double Predict(string NetName)                                             // Ïîäàåò â ñåòü <NetName> âåòîð X äëÿ ïðåäñêàçàíèÿ    
{ 
 BuildX(1+lastBar);                                       
 double Out =  GetPredict(NetName,X,iTime(Symbol(),0,1));                                      // Âîçâðàùàåò Out cåòè
return(Out);
}
//--------------------------------------------------------------------------------------------------------------------
double PostTraining(string NetName,int ST)
{
 int T = BuildT(2+lastBar);                                                        // Ñ÷èòûâàåì ïðàâèëüíûé îòâåò
    if (T == ST)                                                           // Îáó÷àåì òîëüêî íà òîì ïðèìåðå, êîòîðûé ïîäõîäèò äëÿ îáó÷åíèÿ
     {
      BuildX(2+lastBar);                                                           // Ôîðìèðóåì âõîäíîé îáó÷àþùèé âåêòîð
      Train(NetName,X,T);                                                  // Îáó÷àåì ñåòü íà êîíêðåòíîì ïðèìåðå
      Print("New neurons amount: ",SizeOfNet("OverBought")," ; ",SizeOfNet("OverSold"));
     } 
return (0);
}     
//-------------------------------------------------------------------------------------------------------------------
double InitialTraining(string NetName,int HistoryBars,int ST)              // Ðóêîâîäèò çàãðóçêîé äàííûõ â ñåòü äëÿ ïåðâè÷íîãî îáó÷åíèÿ
{                                                                          // çà ïåðèîä HistoryBars
  for ( int i = HistoryBars-1; i > 6; i--)                                 // ïî áàðàì
   {
    int T = BuildT(i+lastBar);                                                     // Ñ÷èòûâàåì ïðàâèëüíûé îòâåò
    if (T == ST)                                                           // Îáó÷àåì òîëüêî íà òîì ïðèìåðå, êîòîðûé ïîäõîäèò äëÿ îáó÷åíèÿ
     {
      BuildX(i+lastBar);                                                           // Ôîðìèðóåì âõîäíîé îáó÷àþùèé âåêòîð
      Train(NetName,X,T);                                                  // Îáó÷àåì ñåòü íà êîíêðåòíîì ïðèìåðå
     } 
    } 
return (0);
}
//-------------------------------------------------------------------------------------------------------------------
int init()
{
 NetInitialTraining();  
} 
//********************************************************************
int start()
  {

//-------------------------------------------------------------------
if (allowPostTraining)
{
 if (LifeTime > 0) KillOlds("OverBought",iTime(Symbol(),0,1));          // Óáèâàåì ñòàðûå íåéðîíû 
 PostTraining("OverBought",-1);                                         // Äîîáó÷àåì ïî õîäó äåëà 
 Shrink("OverBought");                                                  // Ìîäåðíèçèðóåì ñåòü
 //AEqual("OverBought");                                                // Óñòàíàâëèâàåì âñå A =1
 CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
 KillWeaks("OverBought");                                               // Óáèâàåì ñëàáûå íåéðîíû
 CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
 
 if (LifeTime > 0) KillOlds("OverSold",iTime(Symbol(),0,1));            // Óáèâàåì ñòàðûå íåéðîíû 
 PostTraining("OverSold",1);                                            // Äîîáó÷àåì ïî õîäó äåëà
 //AEqual("OverSold");                                                  // Óñòàíàâëèâàåì âñå A =1
 Shrink("OverSold");                                                    // Ìîäåðíèçèðóåì ñåòü
 CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
 KillWeaks("OverSold");                                                 // Óáèâàåì ñëàáûå íåéðîíû
 CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
}
//--------------------------------------------------------------------
double OverBought = Predict("OverBought");
double OverSold   = Predict("OverSold");
Out = (OverBought - OverSold)/(OverBought+OverSold);
Alert("OverBought"+OverBought);
Alert("OverSold "+OverSold);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Activation(1);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if ( Out < (-1)*ActivationBuy)Alert("sell");
if (Out > ActivationSell)Alert("buy");
 return(0);
  }
//+------------------------------------------------------------------+
int deinit()
{
if (!IsOptimization())
{
 Print("Destroying net=>",Destroy ("OverBought"));                           // Óáèâàåì, ÷òî ïîðîäèëè
 Print("Destroying net=>",Destroy ("OverSold"));                             // Óáèâàåì, ÷òî ïîðîäèëè
 }
}

//-------------------------------------------------------------------------------------

///////////////////////////////////////////////////////////////////////////////

//------------------------------------------
double Activation(int i )
{
double t = (djama(Activation_n,Activation_p,Activation_q,i)-djama(Activation_n,Activation_p,Activation_q,i+Activation_n))/Activation_n;

//~~~~ActivationBuy 
 double M = (ActivationMin-ActivationMax)/(-ActivationK);
 if (t <= 0) ActivationBuy = ActivationMax;
 if (t >= M) ActivationBuy = ActivationMin;
 if ((t > 0) && (t < M)) ActivationBuy = -ActivationK*t+ActivationMax;
//~~~~ActivationSell
 M = (ActivationMin-ActivationMax)/(-ActivationK);
 if (t >= 0) ActivationSell = ActivationMax;
 if (t <= -M) ActivationSell = ActivationMin;
 if ((t < 0) && (t > -M)) ActivationSell = ActivationK*t+ActivationMax;
return(t); 
}
//-------------------------------------------
void NetInitialTraining()
{
int  Size0 = 0;
int  Size1 = 0;

    Print("Net Created with number: ",Create("OverBought",24)); // Ñîçäàåì ñåòü äëÿ ñèãíàëîâ Sell
    Print("Net Created with number: ",Create("OverSold",24));   // Ñîçäàåì ñåòü äëÿ ñèãíàëîâ Buy

//~~
    Print("Initial training started ...");
    for (int R = 1; R <= Repetitions; R++)                                  // Ïðîöåññ ïåðâè÷íîãî îáó÷åíèÿ 
    {                                                                       // íà èñòîðè÷åñêèõ äàííûõ    
     WReset("OverBought");                                                  // Îáíóëÿåì çíà÷åíèÿ À
     InitialTraining("OverBought",HistoryBars,-1);                          // Ïðîãîíÿåì îáó÷åíèå 
     Shrink("OverBought");                                                  // Ìîäåðíèçèðóåì ñåòü
     AEqual("OverBought");                                                  // Óñòàíàâëèâàåì âñå A =1
     CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
     KillWeaks("OverBought");                                               // Óáèâàåì ñëàáûå íåéðîíû
     CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
         
     WReset("OverSold");                                                    // Îáíóëÿåì çíà÷åíèÿ À
     InitialTraining("OverSold",HistoryBars,1);                             // Ïðîãîíÿåì îáó÷åíèå 
     AEqual("OverSold");                                                    // Óñòàíàâëèâàåì âñå A =1
     Shrink("OverSold");                                                    // Ìîäåðíèçèðóåì ñåòü
     CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
     KillWeaks("OverSold");                                                 // Óáèâàåì ñëàáûå íåéðîíû
     CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
          
     Print("Cycle ",R," completed. Neurons: ",SizeOfNet("OverBought")," ; ",SizeOfNet("OverSold"));
     if ((SizeOfNet("OverBought") == Size0) && (SizeOfNet("OverSold") == Size1)) break;
     Size0 = SizeOfNet("OverBought");
     Size1 = SizeOfNet("OverSold");
    }
     Print("Initial training completed.");
}
//-------------------------------------------------------------+
double djama(int n, int p, int q, int i)
{
 return(iCustom(Symbol(),0,"djama",n,p,q,0,i+lastBar));
} 
//-------------------------------------------------------------+



Comments