MetaTrader 5 herunterladen

Automatisierte Optimierung eines Handelsroboters in Realem Handel

1 Februar 2016, 11:06
Igor Malcev
1
701

Einführung

Es wird angenommen, dass ein Expert Advisor mit an der Historie ausgerichteten Eingaben, in der ersten (ziemlich kurzen) Zeit, profitabel handeln wird. Indirekte Bestätigungen dieser Empfehlung kamen auf, nachdem ich die Automatisiertes Trading Meisterschaft 2006 angesehen habe. Als die Meisterschaft startete, gab es viel mehr profitable Expert Advisors als später, als einige von ihnen nicht mehr wettbewerbsfähig waren. Deshalb nehme ich an, dass die meisten dieser Expert Advisor, die das Ziel nicht erreichten, nach der Historie ausgerichtet waren.

Die Idee, diese Annahme in der Praxis zu überprüfen, wurde in dem russischen Forum auf dieser Webseite geboren, in dem Bereich Ideal Automatisiertes Handelssystem. Die Grundidee ist es, die Optimierung eines EA automatisch einmal am Tag zu starten, und dann die erhaltenen Optimierungsergebnisse zu analysieren und sie in den Variablen des EA zu notieren.

Um diese Idee umzusetzen, beschlossen wir den fertigen Expert Advisor MACD Sample, aus dem MetaTrader 4 Terminal, zu nehmen, und unsere eigene Funktion der automatisierten Optimierung in ihn einzufügen. Ein wenig später war der Code dieses automatisierten Optimierers fertig, und in dem selben Forum in dem Bereich Automatisierte Optimierer hochgeladen. Nach etwas mehr Zeit, erschienen die ersten Bestätigungen der Idee, in dem Bereich Automatisierte Optimierer. Später wurde der Optimierer in eine mqh-Bibliothek umgewandelt, für eine bessere Bedienbarkeit.


Installation des Automatisierten Optimierer

Unten sehen Sie was Sie tun müssen, um diese Aufgabe auszuführen:

  • kopieren Sie MACD Sample_1.mq4 in den 'Experten' Ordner des MetaTrader 4 Client Terminal vorab installiert und mit dem Internet verbunden, und
  • kopieren Sie den Ordner zusammen mit dem installierten MetaTrader 4 Client Terminal an einen neuen Ort.

Für eine bessere Benutzerfreundlichkeit, werden wir im Folgenden das ursprüngliche Terminal in "Terminal" umbenennen, während die Kopie "Terminal-Tester" genannt wird. Wir werden einen überprüfenden Test auf EURUSD auf dem Zeitrahmen H1 ausführen, unter Verwendung des anfänglich durch das Terminal bereitgestellten Expert Advisor, aber mit leichten Veränderungen - MACD_Sample_1.mp4.


Terminal-Tester Einrichtung

Bitte vergessen Sie nicht MACD_Sample_1.mp4 im Terminal-Tester zu kompilieren. Wir starten zuerst das Client Terminal, dann den Strategie-Tester, und richten ihn ein, so wie in dem Screenshot unten gezeigt.

Die Optimierung wird für drei Tage durchgeführt. Dies ist ausreichend, um den automatisierten Optimierer zu überprüfen. Wir werden das Optimierungsdatum "Von" wählen, entsprechend der folgenden Formel - das aktuelle Datum minus drei Tage. Während der Optimierung muss die benötigte Historie des gewählten Symbols (in unserem Fall ist es EURUSD) heruntergeladen werden.

Diejenigen, die Optimierung zum ersten Mal ausführen, finden die Beschreibung erforderlicher Verfahren im Hilfe-Menü des MetaTrader 4 Client Terminals: <Help - Help Hilfe F1 - Auto Trading - Expert Optimization - Setup>. Oder Sie lesen den Artikel mit dem Namen Testen von Expert Advisors in dem MetaTrader 4 Client Terminal: Ein Blick nach Außen.

Dann lassen Sie uns die Variablen prüfen, die wie unten im Screenshot gezeigt optimiert werden.

Automatisierte Optimierung ist auf vier Variablen beschränkt, aber es wird ausreichen nur drei für unsere Zwecke zu haben, und um Zeit zu sparen. Nachdem die Variablen ausgewählt wurden, speichern wir die Optimierungs-Einstellungen die die set-Datei, mit dem Namen MACD Sample_1.set. Diese Datei muss in dem 'Tester' Ordner des Terminal-Tester gespeichert werden. Dann starten Sie die Vor-Optimierung und merken sich die Startzeit. Dies ist notwendig um die benötigte Zeitperiode für automatisierte Optimierung mit voreingestellten Parametern zu berechnen. Nachdem die Optimierung abgeschlossen ist, werden wir die notwendige Wartezeit berechnen. Dann müssen wir das Terminal schließen, weil wir sonst nich in der Lages sind, es programmgesteuert zu starten.


Einrichtung des im Terminal platzierten Expert Advisor

Hierzu öffnen wir den Test Expert Advisor MACD_Sample_1.mq4 im MetaEditor und führen das folgende durch:

- Einstellen der Startzeit für Auto Optimierung, z.B. 00:01 täglich:

datetime SetHour    = 0;  // Optimization starting hour; 
        datetime SetMinute  = 1;  // Optimization starting minute.

- Einstellen der Menge an Tagen für die Optimierung (es muss die gleiche sein wie bei der Vor-Optimierung):

int TestDay = 3;

- Einstellen der Optimierung Abschluss-Wartezeit, in Minuten, die wir vorher berechnet haben, zum Beispiel 4 Minuten:

int TimeOut = 4;

- Eingeben des Expert Advisor Namen:

string NameMTS = "MACD Sample_1";  // EA's name

- Eingeben des Namen der set-Datei mit den Eistellungen:

// Set-file name with the settings
        string NameFileSet = "MACD Sample_1.set";

- Eingeben des Pfads zu dem Ordner mit dem installierten Terminal-Tester, zum Beispiel:

// Path to the tester        
        string PuthTester = "D:\Program Files\Forex Best Trade Station";

- Einstellen der Priorität beim Filtern:

// Sorting by Maximal profit
        int Gross_Profit = 1;                      
        // Sorting by Maximal profit factor        
        int Profit_Factor = 2;     
        // Sorting by Maximal expected payoff
        int Expected_Payoff = 3;

- Schreiben der Namen der Variablen für Optimierung:

string Per1 = "FastEMA";
        string Per2 = "SlowEMA";
        string Per3 = "SignalSMA";
        string Per4 = "";

- kopieren Sie die angehängte Datei auto_optimization.mqh in den 'Include' Ordner,

- fügen Sie die Bibliothek in den Expert Advisor ein:

//--- Including the auto optimizer's library
#include <auto_optimization.mqh>

- es bleibt nur noch den Code unten an den Anfang der start() Funktion Ihres Expert Advisor zu kopieren. MACD_Sample_1.mq4 enthält ihn bereits.

// Not to be launched at testing and optimizing   
  if(!IsTesting() && !IsOptimization())
    {                
      // Compare the current hour with that preset for launching
      if(TimeHour(TimeLocal()) == SetHour)
        {
          // Protection against restarting
          if(!StartTest)
            {
              // Compare the minute range to the minute
              // preset for launching
              if(TimeMinute(TimeLocal()) > SetMinute - 1)
                {     
                  // the range is necessary, in case that for some reasons 
                  // no new tick is available for a long time
                  if(TimeMinute(TimeLocal()) < SetMinute + 1)
                    {  
                      // Flag of tester launching
                      StartTest    = true;
                      TimeStart    = TimeLocal();
                      Tester(TestDay, NameMTS, NameFileSet, PuthTester, 
                             TimeOut, Gross_Profit, Profit_Factor, 
                             Expected_Payoff, Per1, Per2, Per3, Per4);
                    
                    }
                }
            }
        }
    }
    
                        
   FastEMA      = GlobalVariableGet(Per1);
   SlowEMA      = GlobalVariableGet(Per2);
   SignalSMA    = GlobalVariableGet(Per3);
   TrailingStop = GlobalVariableGet(Per4);  
// If the tester launching is flagged  
  if(StartTest)
    {                                        
      // If more time has elapsed the launching than it was set 
      // to be the test waiting time
      if(TimeLocal() - TimeStart > TimeOut*60)
        {            
          // Zeroize the flag
          StartTest = false;                              
        }
    }

Das ist alles. Nachdem der automatisierte Optimierer neu kompiliert wurde, can er gestartet werden, aber er kann nur für das gleiche Symbol und den gleichen Zeitrahmen verwendet werden, für die die Vor-Optimierung ausgeführt wurde. In unserem Fall ist dies EURUSD auf H1. Um den automatisierten Optimierer zu prüfen, können Sie den unten angegebenen Code eingeben, in die int init () Funktion, dann wird der automatisierte Optimierer beim Start des Expert Advisor starten.

Tester(TestDay,NameMTS,NameFileSet,PuthTester,TimeOut, Gross_Profit,Profit_Factor, 
       Expected_Payoff, Per1,Per2,Per3,Per4);


Wie Automatisierte Optimierer Funktionieren

Der automatisierte Optimierer arbeitet auf Grundlage der Verwendung von Terminal-Tester, um Parameter des an das Chart im Terminal angehangenen Expert Advisor zu optimieren. Dazu sendet das Programm eine Datei mit Optimierungsparamatern (optimize.ini) und startet den Terminal-Tester im Optimierungsmodus. Dann kopiert er die erhaltenen Ergebnisse von "FileReport........htm" zurück zum Terminal und foltert die besten Werte der erhaltenen Ergebnisse.


Weitere Details darüber, Wie Automatisierte Optimierer Funktionieren

Zu der vorgegebenen Zeit, zum Beispiel 00:01, soll der automatisierte Optimierer starten. Variablen sollten mit Werten ausgefüllt sein

// Path to the terminal 
string PuthTerminal = TerminalPath() + "\experts\files";
// Name of the ini file for the tester
string FileOptim    = "optimise.ini";
string FileOptim1   = "\optimise.ini";                                  
// Calculation of the starting date
datetime DayStart   = TimeLocal()-86400*TestDay;
// Optimization starting date
string DateStart    = TimeToStr(DayStart,TIME_DATE);
// Optimization ending date
string DateStop     = TimeToStr(TimeLocal(),TIME_DATE);
// Tester report file name
string FileReport   = "FileReport_" + Symbol() + "_" + DateStop + ".htm";
string FileReport1  = "\FileReport_" + Symbol() + "_" + DateStop + ".htm";
// Limitation for the minimum amount of trades per day
double MinTr        = TestDay - 2;
// Limitation for maximal amount of trades per day
double MaxTr        = (60 / Period()*TestDay) + 2;
// The amount of attempts to copy the report file
int    KvoPptk      = 10;
// The amount of lines for sorting
int    StepRes      = 12;

Dann werden die Parameter der ini Datei in das String Array geschrieben:

// Prepare the ini file for optimization
ArrayOpttim[0] = ";optimise strategy tester";             
// Enable/Disable Expert Advisors
ArrayOpttim[1] = "ExpertsEnable = false";
// Name of the EA file
ArrayOpttim[2] = "TestExpert=" + NameMTS;
// Name of the file containing parameters
ArrayOpttim[3] = "TestExpertParameters=" + NameFileSet;
// Symbol
ArrayOpttim[4] = "TestSymbol=" + Symbol();
// Timeframe
ArrayOpttim[5] = "TestPeriod=" + Period();
// Modeling mode
ArrayOpttim[6] = "TestModel=" + 0;
// Recalculate
ArrayOpttim[7] = "TestRecalculate=false";
// Optimization
ArrayOpttim[8] = "TestOptimization=true";
// Use date
ArrayOpttim[9] = "TestDateEnable=true";
// From
ArrayOpttim[10] = "TestFromDate=" + DateStart;
// To
ArrayOpttim[11] = "TestToDate=" + DateStop;
// Report file name
ArrayOpttim[12] = "TestReport=" + FileReport;
// Rewrite the report file
ArrayOpttim[13] = "TestReplaceReport=true";
// Shut down the terminal upon completion
ArrayOpttim[14] = "TestShutdownTerminal=true";

Die Optimierungsparameter werden in der ini Datei des Array aufgezeichnet. Sie können darüber, wie man eine ini-Datei erstell, auch in der MetaTrader 4 Terminal Hilfe lesen, unter <Hilfe - Hilfe F1 - Tools - Configuration at Startup>.

// Write data into the ini file                
// Find out about the array size
OptimArraySize = ArraySize(ArrayOpttim);
// Open a file to write
opttim = FileOpen(FileOptim, FILE_CSV|FILE_WRITE, 0x7F);
if(opttim > 0)
  {
    for(int i = 0; i < OptimArraySize; i++)
      {
        // from the array into the variable
        ini = ArrayOpttim[i];                                     
        // from the variable into the file
        FileWrite(opttim, ini);
      } 
    // close the file
    FileClose(opttim);
  }
else
  {
    Print("Failed writing data into the ini file. Error No ", 
          GetLastError());
    return(0);
  }

Nachdem die Parameter in der ini-Datei aufgezeichnet wurden, wird die in Standard-Windows enthaltene shell32.dll kontaktiert und die Funktion ShellExecuteA startet.

#import  "shell32.dll"               //Connect a dll (provided with Windows)       
  int ShellExecuteA(int hwnd,string Operation,string 
                    File,string Parameters,string Directory,int ShowCmd); 
#import

Datei, welche die Parameter beinhaltet, wird an den Terminal-Tester Ordner gesendet.

// copy the ini file into the tester folder 
copyini = ShellExecuteA(0,"Open","xcopy", "\"" + PuthTerminal + 
                        FileOptim1 + "\" \"" + PuthTester + "\" /y", 
                        "", 3);
// wait until the file is copied
Sleep(1200);                                                    
if(copyini < 0)
  {
    Print("Failed copying ini file");
    return(0);
  }

Dann ist der Tester gestartet und beginnt festgelegte Variablen zu optimieren. Der Expert Advisor befindet sich während der Optimierung im angehaltenen Status

// Start Tester 
start = ShellExecuteA(0, "Open", "terminal.exe", FileOptim,
                      PuthTester, 3);
if(start < 0)
  {
    Print("Failed starting Tester");
    return(0);
  }
Comment("Wait until optimization is complete");
// wait until optimization is complete
Sleep(60000*TimeOut);

Nachdem die Optimierung abgeschlossen ist, wird der Tester die Ergebnisse automatisch in der Report-Datei aufzeichnen. Diese Datei wird in den Ordner kopiert, der das Terminal enthält.

for(Pptk = 0; Pptk < KvoPptk; Pptk++)
  {                    
    //Start a cycle attempting to compy the resport file
    Comment("Attempt # " + Pptk + " to copy the report file");
    ShellExecuteA(0, "Open", "xcopy", "\"" + PuthTester + FileReport1 + 
                  "\" \"" + PuthTerminal + "\" /y", "", 3);
    // wait until the file is copied
    Sleep(1200);
    // Try to open the report file
    file = FileOpen(FileReport, FILE_READ, 0x7F);
    if(file < 0)
      {
        // if it fails to open, wait some more and try again
        Sleep(60000);
      }                    
    else 
        break;             
  }
if(file < 0)
  {
    Print("Failed copying the report file");
    return(0);
  }

Danach werden die Daten der Report-Datei zur weiteren Verarbeitung in das String Array platziert.

// Read from file into the array
// Cycle, until the file ends
while(FileIsEnding(file) == false)
  {                 
    // Read a string from the report file
    FileLine = FileReadString(file);
    // Find the necessary string and set the reference point there
    index = StringFind(FileLine, "title", 20);
    if(index > 0)
      {
        // Increase the array in size
        ArrayResize(ArrayStrg, NumStr + 1);
        // Record the strings from the file in the array
        ArrayStrg[NumStr] = FileLine;
        NumStr++;
      }
  }
// Close the file
FileClose(file);
// Delete the file in order not to produce too many copies
FileDelete(FileReport);
// Set the array size by the amount of data read from the file
ArrayResize(ArrayData, NumStr);    

Dann werden die notwendigen Werte in dem Array ausgewählt:

for(text = 0; text < NumStr; text++)
     {
      select = ArrayStrg[text]; 
    //-------------------------------------------------------------------------
    //   Reporting text processing (These are apples and oranges)              | 
    //-------------------------------------------------------------------------
    // Position Pass 
    ClStep=StringFind(select, "; \">",20)+4;
    // Find the end of position
    ClStepRazm = StringFind(select, "td>", ClStep);
    // Read the value
    CycleStep = StringSubstr(select, ClStep, ClStepRazm - ClStep);
    // Position Profit 
    // Find the beginning of the position
    GrProf = StringFind(select, "", ClStepRazm);
    // Find the end of position
    GrProfRazm = StringFind(select, "td>", GrProf);
    // Read value
    GrossProfit = StringSubstr(select, GrProf+4, GrProfRazm - (GrProf + 4));
    // Position Total Trades
    // Find the beginning of position
    TotTrad = StringFind(select, "", GrProfRazm);
    // Find the end of position
    TotTradRazm = StringFind(select, "td>", TotTrad);
    // Read the value
    TotalTrades = StringSubstr(select, TotTrad+4, TotTradRazm - 
                               (TotTrad + 4));
    // Position Profitability
    // Find the beginning of position
    ProfFact = StringFind(select, "", TotTradRazm);
    // Find the end of position
    ProfFactRazm = StringFind(select, "td>", ProfFact);
    // Read the value
    ProfitFactor = StringSubstr(select, ProfFact + 4, ProfFactRazm - 
                                (ProfFact + 4));
    // Position Expected Payoff 
    // Find the beginning of position
    ExpPay = StringFind(select, "", ProfFactRazm);
    // Find the dn of position
    ExpPayRazm=StringFind(select, "td>", ExpPay);
    // Read the value
    ExpectedPayoff = StringSubstr(select, ExpPay+4, ExpPayRazm - 
                                  (ExpPay + 4));
    // Variables' positions starting with the second one
    // Find the beginning of position
    P1 = StringFind(select, Per1, 20);
    // Find the end of position
    P1k = StringFind(select, ";", P1);
    // Read the Variable
    Perem1 = StringSubstr(select, P1 + StringLen(Per1) + 1, P1k - 
                          (P1 + 1 + StringLen(Per1)));
    // Find the beginning of position
    P2 = StringFind(select, Per2, 20);
    // Find the end of position
    P2k = StringFind(select, ";", P2); 
    // Read the Variable
    Perem2 = StringSubstr(select, P2 + StringLen(Per2) + 1, P2k - 
                          (P2 + 1 + StringLen(Per2)));
    // Find the beginning of position
    P3 = StringFind(select, Per3, 20);
    // Find the end of position
    P3k = StringFind(select, ";", P3);
    // Read the Variable
    Perem3 = StringSubstr(select, P3 + StringLen(Per3) + 1, P3k - 
                          (P3 + 1 + StringLen(Per3)));
    // Find the beginning of position
    P4 = StringFind(select, Per4, 20);
    // Find the end of position
    P4k = StringFind(select, ";", P4);
    // Read the Variable 
    Perem4 = StringSubstr(select, P4 + StringLen(Per4) + 1, P4k - 
                          (P4 + 1 + StringLen(Per4)));
    Comment("The obtained results are being analyzed");

Danach werden die erhaltenen Ergebnisse, bevor sie in das Zahlenformat umgewandelt werden, gefiltert nach der minimalen und der maximalen Menge an Trades. Null in dem Wert von Profit_Factor wird ersetzt durch 1000, für die korrekte Sortierung und anschließende Überprüfung.

// Transform into number format
TotalTradesTransit = StrToDouble(TotalTrades);
GrossProfitTransit = StrToDouble(GrossProfit);
ExpectedPayoffTran = StrToDouble(ExpectedPayoff);
nodubl = true;
if(MinTr < TotalTradesTransit && MaxTr > TotalTradesTransit)
  {                    
    // Filter by the amount of trades
    PrFactDouble = StrToDouble(ProfitFactor);
    // Replace 0 in the Profit_Factor for proper analysis
    if(PrFactDouble == 0)
      {
        PrFactDouble = 1000;
      }

Dann werden die Werte auf Duplikate geprüft und ausgefiltert.

// Filter data having identical values
for(Dubl = 0; Dubl <= ResizeArayNew; Dubl++)
  {                    
    // Start the loop searching for identical values
    if(GrossProfitTransit == ArrayData[Dubl][1])
      {          
        // check whether the results for maximal profit coincide
        if(TotalTradesTransit == ArrayData[Dubl][2])
          {       
            // check whether the results for the amount of trades coincide
            if(PrFactDouble == ArrayData[Dubl][3])
              {          
                // check whether the results for Profit Factor coincide
                if(ExpectedPayoffTran == ArrayData[Dubl][4])
                  { 
                    // check whether the results for expected payoff coincide
                    nodubl=false;                              
                    // If everything coincides, flag it as coincided
                  }
              }
          }
      }
  }

Anschließend werden die Werte für die im Array geschriebene Sortierung vorbereitet.

// Write the filtered data in the array
if(nodubl)
  {
    ArrayData[text][1] = GrossProfitTransit;                                
    ArrayData[text][2] = TotalTradesTransit;
    ArrayData[text][3] = PrFactDouble;
    ArrayData[text][4] = ExpectedPayoffTran;
    ArrayData[text][5] = StrToDouble(Perem1);
    ArrayData[text][6] = StrToDouble(Perem2);
    ArrayData[text][7] = StrToDouble(Perem3);
    ArrayData[text][8] = StrToDouble(Perem4);
    ResizeArayNew++; 
  }

Dann wird begonnen die Daten in der vorgegebenen Prioritätsfolge zu analysieren. Die Analyse wird wie folgt durchgeführt:

  • die schleife ist gestartet und, im ersten Durchlauf, die Werte werden nach dem ersten Parameter sortiert, zum Beispiel nach maximalem Profit. Mehrere bester Werte sind ausgewählt (12 als Standard), andere werden abgeschnitten,
  • im zweiten Durchlauf werden die Werte nach dem zweiten Parameter sortiert, zum Beispiel nach Profitfaktor. Einige beste Werte werden ausgewählt, ein halber nach der ersten Sortierung, andere werden abgeschnitten,
  • i dritten Durchlauf wird die letzte Sortierung nach dem dritten Parameter ausgeführt, zum Beispiel nach erwarteter Auszahlung. ein halber Wert wird nach der zweiten Sortirung genommen, andere werden abgeschnitten.
// Analyzer
// Analyzing principle is the sequential checking of maximal 
// values according to the predefined filtering priority   
ArrayResize(ArrayTrans, ResizeArayNew - 1);
for(int PrioStep = 1; PrioStep < 4; PrioStep++)
  {
    for(PrCycle = 0; PrCycle < ResizeArayNew; PrCycle++)
      {
        Sort     = ArrayData[PrCycle][0];
        Prior1   = ArrayData[PrCycle][1];             
        transit  = ArrayData[PrCycle][2];
        Prior2   = ArrayData[PrCycle][3];             
        Prior3   = ArrayData[PrCycle][4];             
        transit1 = ArrayData[PrCycle][5];
        transit2 = ArrayData[PrCycle][6];
        transit3 = ArrayData[PrCycle][7];
        transit4 = ArrayData[PrCycle][8]; 
           
        if(PrioStep == 1)
          {
            //Prepare for the 1st sorting
            if(Gross_Profit ==1)
              {
                SortTrans = Prior1;
              }
            if(Profit_Factor == 1)
              {
                SortTrans = Prior2;
              }
            if(Expected_Payoff == 1)
              {
                SortTrans = Prior3;
              }
          }
        if(PrioStep == 2)
          {
            // Restore
            if(Gross_Profit ==1)
              {
                Prior1 = Sort;
              }
            if(Profit_Factor == 1)
              {
                Prior2 = Sort;
              }
            if(Expected_Payoff == 1)
              {
                Prior3 = Sort;
              } 
            //Prepare for the 2nd sorting
            if(Gross_Profit == 2)
              {
                SortTrans = Prior1;
              }
            if(Profit_Factor == 2)
              {
                SortTrans = Prior2;
              }
            if(Expected_Payoff == 2)
              {
                SortTrans = Prior3;
              }
          }
        if(PrioStep == 3)
          {
            // Restore
            if(Gross_Profit == 2)
              {
                Prior1 = Sort;
              }
            if(Profit_Factor == 2)
              {
                Prior2 = Sort;
              }
            if(Expected_Payoff == 2)
              {
                Prior3 = Sort;
              } 
            //Prepare for the 3rd sorting
            if(Gross_Profit ==3)
              {
                SortTrans = Prior1;
              }
            if(Profit_Factor == 3)
              {
                SortTrans = Prior2;
              }
            if(Expected_Payoff == 3)
              {
                SortTrans = Prior3;
              }
          }          
        ArrayTrans[PrCycle][0] = SortTrans;
        ArrayTrans[PrCycle][1] = Prior1;
        ArrayTrans[PrCycle][2] = transit;
        ArrayTrans[PrCycle][3] = Prior2;
        ArrayTrans[PrCycle][4] = Prior3;
        ArrayTrans[PrCycle][5] = transit1;
        ArrayTrans[PrCycle][6] = transit2;
        ArrayTrans[PrCycle][7] = transit3;
        ArrayTrans[PrCycle][8] = transit4;
      }
    ArraySort(ArrayTrans,StepRes, 0, MODE_DESCEND); // Sort the array
    ArrayResize(ArrayTrans, StepRes);               // Cut off the unnecessary things
    for(int CopyAr = 0; CopyAr < StepRes; CopyAr++)
      {
        ArrayData[CopyAr][0] = ArrayTrans[CopyAr][0];
        ArrayData[CopyAr][1] = ArrayTrans[CopyAr][1];
        ArrayData[CopyAr][2] = ArrayTrans[CopyAr][2];
        ArrayData[CopyAr][3] = ArrayTrans[CopyAr][3];
        ArrayData[CopyAr][4] = ArrayTrans[CopyAr][4];             
        // Per1    Variable 1
        ArrayData[CopyAr][5] = ArrayTrans[CopyAr][5];              
        // Per2    Variable 2
        ArrayData[CopyAr][6] = ArrayTrans[CopyAr][6];
        // Per3    Variable 3
        ArrayData[CopyAr][7] = ArrayTrans[CopyAr][7];
        // Per4    Variable 4
        ArrayData[CopyAr][8] = ArrayTrans[CopyAr][8];
      }
   StepRes = StepRes / 2;
  }

Die auf diese Weise gefilterten Werte, werden in globale Variablen geschrieben. Die Werte von globalen Variablen werden im EA ersetzt.

// Write the obtained results in variables
   double Peremen1 = ArrayTrans[0][5];                         
   double Peremen2 = ArrayTrans[0][6];
   double Peremen3 = ArrayTrans[0][7];
   double Peremen4 = ArrayTrans[0][8];
   // If the variable name is specified, write the result in 
   // global variables
   if(Per1 != "")
     {
       GlobalVariableSet(Per1, Peremen1);
     }             
   if(Per2 != "")
     {
       GlobalVariableSet(Per2,Peremen2);
     }
   if(Per3 != "")
     {
       GlobalVariableSet(Per3,Peremen3);
     }
   if(Per4 != "")
     {
       GlobalVariableSet(Per4,Peremen4);
     }
   Comment(Per1, " ", Peremen1, "  | ", Per2, " ", Peremen2, "  | ", Per3, 
           " ", Peremen3, "  | ", Per4, " ", Peremen4);
   Print(Per1, " ", Peremen1, "  | ", Per2, " ", Peremen2, "  | ", Per3, 
         " ", Peremen3,"  | ",Per4," ",Peremen4);
  }  // Function ends. That's all, automated optimization is complete.


Auto Optimierer Betriebsergebnisse

Die Betriebsergebnisse des automatisierten Optimierers können über die Verwendung von Nachrichten beobachtet werden, die in der linken oberen Ecke erscheinen, so wie in dem Screenshot unten gezeigt:

Vollständige Optimierung Referenzzeit.

Analyse der nach der Optimierung Erhaltenen Werte.

Resultierende Werte der Variablen.

Wenn die Optimierungsergebnisse in der Nachricht erscheinen, bedeutet das, dass die Optimierung abgeschlossen ist und die Daten empfangen wurden.

Um den automatisierten Optimierer unabhängig einzuschätzen, kann man durch alle Dateien schauen, die Zwischenergebnisse enthalten und während des Arbeitsvorgangs gespeichert wurden. Der Tester speichert Daten in der Datei mit dem Namen "FileReport_EURUSD_2007.03. 12. htm", wobei das Symbol und das Datum im Dateinamen ersetzt werden, entsprechend dem gewählten Symbol und dem aktuellen Datum der Optimierung. Diese Datei befindet sich im Terminal-Tester Ordner. Diese Dateien mit Berichten werden nicht automatisch gelöscht, wodurch man sie verwenden kann, um die Änderungen der Parameter zu überprüfen.

Die nächste Datei, FileTest1.csv, wird gespeichert, nachdem die Werte nach der Menge der Trades gefiltert und die Kopien gelöscht wurden. Die Datei wird gespeichert unter: D:\Program Files\Terminal_Ordner_Name\Experten/Dateien

Dann werden die nach jeder Untersuchung erhaltenen Werte in in FilerTaes2.csv gespeichert. Die Datei wird auch in dem Ordner D:\Program Files\Terminal_Ordner_Name\Experten/Dateien gespeichert.

Die Tabellen oben zeigen, wie die erhaltenen Werte gefiltert werden. Die Filterreihenfolge wurde so als Standard eingestellt: 1- Gross_Profit, 2- Profit_Factor, 3- Expected_Payoff.

Der Code des Automatisierten Optimierers enthält detaillierte Kommentare und Sie können die am besten geeigneten Parameter anpassen, wenn notwendig. Zum Beispiel, Sie wollen Ihren EA für einen anderen Zeitraum als die letzten Tage optimieren, oder Sie planen die Anzahl der Trades innerhalb der Optimierungsperiode zu erhöhen/verringern. Hierzu müssen Sie nur die entsprechenden Variablen direkt in auto_optimization.mqh ändern.

// Limitation of minimal amount of trades per day
double MinTr   = TestDay - 2; 
// Limitation on maximal amount of trades per day
double MaxTr   = (60 / Period()*TestDay) + 2;
// The amount of attempts to copy the report file
int    KvoPptk = 10;
// The amount of strings to be sorted
int    StepRes = 12;


Fazit

Dieser Artikel ist nicht darauf Ausgerichtet Neulingen die Elemente der Optimierung zu lehren, so dass es sehr zu empfehlen ist, normale Optimierung zu lernen,. bevor Sie automatisierte Optimierung für Ihren Expert Advisor einrichten. Es ist besser den automatisierten Optimierer zu verwenden, nachdem Sie die grundlegenden Variablen ausgewählt haben, die Ihren Expert Advisor zu verschiedenen Zeiten beeinflussen. Das heißt, es ist besser den automatisierten Optimierer zu verwenden, um die Parameter der Variablen anzupassen, die den EA-Betrieb mehr als andere beeinflussen, in Abhängigkeit von der Marktvolatilität.

Außerdem ist es besser, keine sehr lange Optimierungsperiode einzustellen. Angenommen, der Expert Advisor wurde jeden Tag für 6 - 12 Stunden optimiert. Dann taucht die Frage auf: Wann wird er traden? Mit anderen Worten, Optimierung ist kein Selbstzweck. Es wird empfohlen die Optimierungshäufigkeit (die Häufigkeit der Starts des Optimierers ist gemeint) in Anbetracht des Zeitrahmens festzulegen, in dem der EA traden soll. Das bedeutet, dass es nötig ist zu berücksichtigen, dass die historischen Daten gezogen werden, wenn das Tester-Terminal gestartet ist, und es möglich ist, dass der Broker die erforderlichen Daten für den festgelegten Zeitrahmen nicht besitzt. Um die Hypothese zu Beginn dieses Artikels zu verifizieren, benötigen Sie 24 Stunden und eine stabile Internetverbindung.

Die entwickelten Automatisierte Optimierungs Progammer befinden sich in den angehangenen Dateien:: auto_optimization.mqh - die Bibliothek selbst, MACD Sample_1.mq4 - leicht veränderter Expert Advisor, der in der MetaTrader 4 Client Terminal Standardausführung enthalten ist.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1467

Beigefügte Dateien |
MACD_Sample_1.mq4 (8.01 KB)
Letzte Kommentare | Zur Diskussion im Händlerforum (1)
Ralf Broszeit
Ralf Broszeit | 26 Sep 2016 in 13:03
this tool doesnt worked on the current MQL4. :-(
Skype verwenden um Nachrichten von einem Expert Advisor zu senden Skype verwenden um Nachrichten von einem Expert Advisor zu senden

Der Artikel befasst sich mit den Möglichkeiten, wie man Skype verwendet um interne Nachrichten und SMS von einem Expert Advisor zu Mobiltelefonen zu versenden

Techniche Analyse: Mach das Unmögliche Möglich! Techniche Analyse: Mach das Unmögliche Möglich!

Der Artikel beantwortet die Frage: Warum kann das Unmögliche möglich werden, wo vieles anders suggeriert wird? Technische Analyse Argumentation.

Geheimnisse des Client Terminals MetaTrader 4 Geheimnisse des Client Terminals MetaTrader 4

21 Arten dein Leben zu vereinfachen: versteckte Möglichkeiten des Client Terminals MetaTrader 4 Vollbildmodus; Tastenkombinationen; mobile Navigationszeile; Fenster minimalisieren; Favoriten; Den Trafik verlangsamen; Nachrichten deaktivieren; Kombinationen von Symbolen; Das Fenster Pop-up Preise; Vorlagen für Testgrafiken und unabhängigen Grafiken; Profilen; Fadenkreuz; das Lineal; die Grafik Bar um Bar durchgucken; die Konto-History auf der Grafik; die Typs von Pendig-Orders; Stop-Loss und Take-Profit ändern; die Entfernung annullieren; Drücken einer Grafik.

Geheimnisse des Client Terminals MetaTrader 4: Alarm-System Geheimnisse des Client Terminals MetaTrader 4: Alarm-System

Wie Sie immer die aktuelle Lage im Terminal und auf Ihrem Konto wissen können, und dabei nicht immer wieder das Bildschirm angucken. Systemereignisse; Benutzerereignisse; Sounds und ausführbare Dateien; E-Mails; Zugriff-Einstellungen zum SMTP-Server; Veröffentlichen; Zugriff-Einstellungen zum FTP-Server.