IndiTest
Download scriptThis 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.
//+------------------------------------------------------------------+
//| 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