Wie man rasch einen Expert Advisor für den Automatisierten Trading-Wettbewerb 2010 erzeugt

Andrey Kornishkin | 8 März, 2016

Einleitung

Zur Entwicklung eines Experts zur Teilnahme am Automatisierten Trading-Wettbewerb 2010, nehmen wir ein Template des fertigen Expert Advisors aus dem Beitrag Der Prototyp eines Handels-Roboters her. Selbst noch unerfahrene MQL5 Programmierer können diese Aufgabe bewältigen, da ja für die Strategien die grundlegenden Klassen, Funktionen und Templates schon entwickelt sind.. Daher genügt es, nur ein bisschen Code zur Implementierung Ihres Trading-Konzepts zu schreiben.

Und um folgende Punkte müssen wir uns kümmern:

• Wahl der Strategie
• Schreibens eines Expert Advisors
• Test
• Optimierung im Strategie-Tester
• Optimierung der Strategie
• Testen auf verschiedenen Intervallen

1. Wahl der Strategie

Man nimmt an, dass Handeln mit Trends rentabler ist als das Handeln in einem Bereich und dass die Schwungkraft von Intraday-Ebenen öfters auftritt als der Zusammenbruch von Kanalränder.

Ausgehend von diesen Annahmen, eröffnen wir die Position in Richtung des aktuellen Trends auf der Schwungkraft der Kanalränder (Envelopes). Wir schließen die Position bei einem Signal die Position zu schließen oder wenn die Stop Loss- oder Take Profit-Ebenen erreicht sind.

Als Trendsignal verwenden wir das MACD Wachsen oder Schrumpfen auf dem Tageschart und wir handeln au f der Schwungkraft der Kanalränder im Stunden-Zeitraum.

Abb. 1 MACD Indikator auf EURUSD Tageschart

Sobald der MACD Indikator auf zwei Balken in Folge anwächst, ist das das Buy-Signal. Schrumpft er auf zwei Balken in Folge, ist das das Sell-Signal.

Abb. 2 Preissprung von zwei Envelope-Grenzen

2 Einen Expert Advisor schreiben

2.1 Mit eingeschlossene Module

Der Expert wird mit der ExpertAdvisor Klasse aus dem ExpertAdvisor.mqh Modul arbeiten.

#include <ExpertAdvisor.mqh>

2,2. Eingabe-Variablen

input int    SL        =  50; // Stop Loss distance
input int    TP        = 100; // Take Profit distance
input int    TS        =  50; // Trailing Stop distance
input int    FastEMA   =  15; // Fast EMA
input int    SlowEMA   =  26; // Slow EMA
input int    MACD_SMA  =   1; // MACD signal line
input int    EnvelPer  =  20; // Envelopes period
input double EnvelDev  = 0.4; // Envelopes deviation
input double Risk      = 0.1; // Risk

2,3. Erzeugung einer vom CExpertAdvisor vererbten Klasse

class CMyEA : public CExpertAdvisor
  {
protected:
   double            m_risk;          // size of risk
   int               m_sl;            // Stop Loss
   int               m_tp;            // Take Profit
   int               m_ts;            // Trailing Stop
   int               m_pFastEMA;      // Fast EMA
   int               m_pSlowEMA;      // Slow EMA
   int               m_pMACD_SMA;     // MACD signal line
   int               m_EnvelPer;      // Envelopes period
   double            m_EnvelDev;      // Envelopes deviation
   int               m_hmacd;         // MACD indicator handle
   int               m_henvel;        // Envelopes indicator handle
public:
   void              CMyEA();
   void             ~CMyEA();
   virtual bool      Init(string smb,ENUM_TIMEFRAMES tf); // initialization
   virtual bool      Main();                              // main function
   virtual void      OpenPosition(long dir);              // open position on signal
   virtual void      ClosePosition(long dir);             // close position on signal
   virtual long      CheckSignal(bool bEntry);            // check signal
  };
//------------------------------------------------------------------

//------------------------------------------------------------------    
void CMyEA::~CMyEA()
  {
   IndicatorRelease(m_hmacd);  // delete MACD indicator
   IndicatorRelease(m_henvel); // delete Envelopes indicator
  }
//------------------------------------------------------------------    

//------------------------------------------------------------------    Init
bool CMyEA::Init(string smb,ENUM_TIMEFRAMES tf)
  {
   if(!CExpertAdvisor::Init(0,smb,tf)) return(false);    // initialize parent class
   // copy parameters
    m_risk=Risk; 
   m_tp=TP; 
   m_sl=SL; 
   m_ts=TS;
   m_pFastEMA=FastEMA; 
   m_pSlowEMA=SlowEMA; 
   m_pMACD_SMA=MACD_SMA;
   m_EnvelPer = EnvelPer;
   m_EnvelDev = EnvelDev;
   m_hmacd=iMACD(m_smb,PERIOD_D1,m_pFastEMA,m_pSlowEMA,m_pMACD_SMA,PRICE_CLOSE);      // create MACD indicator
   m_henvel=iEnvelopes(m_smb,PERIOD_H1,m_EnvelPer,0,MODE_SMA,PRICE_CLOSE,m_EnvelDev); // create Envelopes indicator
   if(m_hmacd==INVALID_HANDLE ||m_henvel==INVALID_HANDLE ) return(false);             // if there is an error, then exit
   m_bInit=true; 
   return(true);                                                                      // trade allowed
  } 

2,6. Handelsfunktion

//------------------------------------------------------------------    CheckSignal
long CMyEA::CheckSignal(bool bEntry)
  {
   double macd[4],   // Array of MACD indicator values
         env1[3],    // Array of Envelopes' upper border values
         env2[3];    // Array of Bollinger Bands' lower border values
   MqlRates rt[3];   // Array of price values of last 3 bars
   
   if(CopyRates(m_smb,m_tf,0,3,rt)!=3) // Copy price values of last 3 bars to array
     {
       Print("CopyRates ",m_smb," history is not loaded"); 
        return(WRONG_VALUE);
     }
   // Copy indicator values to array
   if(CopyBuffer(m_hmacd,0,0,4,macd)<4 || CopyBuffer(m_henvel,0,0,2,env1)<2 ||CopyBuffer(m_henvel,1,0,2,env2)<2)
     { 
        Print("CopyBuffer - no data"); 
       return(WRONG_VALUE);
     }
   // Buy if MACD is growing and if there is a bounce from the Evelopes' lower border
   if(rt[1].open<env2[1] && rt[1].close>env2[1] && macd[1]<macd[2] &&  macd[2]<macd[3])
      return(bEntry ? ORDER_TYPE_BUY:ORDER_TYPE_SELL); // condition for buy
   // Sell if MACD is dwindling and if there is a bounce from the Evelopes' upper border
   if(rt[1].open>env1[1] && rt[2].close<env1[1]&& macd[1]>macd[2] &&  macd[2]>macd[3])
      return(bEntry ? ORDER_TYPE_SELL:ORDER_TYPE_BUY); // condition for sell

   return(WRONG_VALUE); // if there is no signal
  }

CMyEA ea; // class instance

Nach dem Schreiben des Codes wird dann der entsprechende Expert an den Strategie-Tester geschickt.

3. Test

Wir erhalten im Strategie-Tester für den Zeitraum "Letztes Jahr" auf EURUSD folgendes Chart:

Abb. 3 Testergebnisse des Handelssystems mit Initial-Parametern

Die Ergebnisse hauen einen nicht um, also optimieren wir daher die Stop Loss- und Take Profit-Ebenen.

4. Optimierung im Strategie-Tester

Wir optimieren die Stop Loss und Take Profit-Parameter im Intervall 10-500 mit Schritt 50.

Beste Ergebnisse: Stop Loss = 160, Take Profit = 310. Nach der Stop Loss- und Take Profit-Optimierung erzielten wir 67% gewinnbringenden Handel verglichen mit den vorigen 36%, und einen Nettogewinn von $1522,97. Wir haben unser System also durch einfache Eingriffe auf einen Break-Even ausgebaut und sogar etwas Gewinn gemacht.

Abb. 4 Testergebnisse des Handelssystems mit optimierten Stop Loss und Take Profit

Als nächstes optimieren wir den Envelopes-Zeitraum und die Abweichung.

Der Envelopes-Zeitraum verändert sich von 10 auf 40, mit Schritt 4; die Abweichung von 0,1 auf 1 mit Schritt 0,1.

Die besten Ergebnisse der Optimierung: Envelopes-Zeitraum = 22, Envelopes-Abweichung = 0,3. Selbst jetzt haben wir $14418,92 Nettogewinn und 79% gewinnbringende Handel.

Abb. 5 Testergebnisse des Handelssystems mit optimiertem Envelopes-Zeitraum und Abweichung

Wenn wir das Risiko auf 0,8 erhöhen, erhalten wir $77330,95 Nettogewinn.

Abb. 6 Testergebnisse des Handelssystems mit optimiertem Risiko

5. Optimierung der Strategie

Eine Optimierung der Strategie kann aus folgenden Schritten bestehen:

• Trend-Indikator ändern
• Einen anderen Envelope wählen
• Einen anderen Zeitraum wählen
• Handelsbedingungen ändern

5.1 Trend-Indikator ändern

Wie wir aus dem Beitrag Mehrere Möglichkeiten einen Trend in MQL5 zu entdecken entnehmen können, sind die besten Trend-Indikatoren gleitender Durchschnitt und ein "Fan" des gleitenden Durchschnitts.

Ersetzen wir daher den MACD Indikator durch einfachen gleitenden Durchschnitt. Der Code für den Experten steht in der angehängten Macena.mq5 Datei.

5.2 Einen anderen Envelope wählen

Neben dem Envelope können Sie auch andere, Ihnen zur Verfügung stehende Envelopes wählen. Zum Beispiel: Preiskanal, Bollinger Bänder oder einen auf gleitendem Durchschnitt basierenden Envelope.

Ein Beispiel eines Experten, der MA (gleitender Durchschnitt) und Bollinger Bänder verwendet, ist in der angehängten Maboll.mq5 Datei zu finden.

5.3 Einen andern Zeitraum wählen

Machen wir nun den Zeitraum größer oder kleiner. Nehmen wir H4 als größeren und M15 als kleineren Zeitraum und testen und optimieren dann unser System.

Dazu müssen wir nur eine Zeile im Code ersetzen:

m_henvel=iEnvelopes(m_smb,PERIOD_H1,m_EnvelPer,0,MODE_SMA,PRICE_CLOSE,m_EnvelDev);  // create Envelopes indicator

In the case of H4 timeframe:

m_henvel=iEnvelopes(m_smb,PERIOD_H4,m_EnvelPer,0,MODE_SMA,PRICE_CLOSE,m_EnvelDev);  // create Envelopes indicator

Für den M15 Zeitraum:

m_henvel=iEnvelopes(m_smb,PERIOD_M15,m_EnvelPer,0,MODE_SMA,PRICE_CLOSE,m_EnvelDev);  // create Envelopes indicator

5,4. Handelsbedingungen ändern

Und als Experiment verändern wir nun auch noch die Handelsbedingungen.

1. Wir erlauben dem System nun, sich umkehren zu können. Wir kaufen auf der Schwungkraft der Untergrenze des Envelopes und verkaufen auf der Schwungkraft seiner Obergrenze.
2. Überprüfen Sie das System ohne dem Tagestrend zu folgen. Dies geschieht schlicht durch einfügen des folgenden Codes in den Handelsblock:
   

   //------------------------------------------------------------------ CheckSignal
   long CMyEA::CheckSignal(bool bEntry)
     {
      double env1[3],   // Array of Envelopes' upper border values
            env2[3];    // Array of Bollinger Bands' lower border values
      MqlRates rt[3];   // Array of price values of last 3 bars
   
      if(CopyRates(m_smb,m_tf,0,3,rt)!=3) // Copy price values of last 3 bars to array
        {
         Print("CopyRates ",m_smb," history is not loaded");
         return(WRONG_VALUE);
        }
   // Copy indicator values to array
      if(CopyBuffer(m_henvel,0,0,2,env1)<2 || CopyBuffer(m_henvel,1,0,2,env2)<2)
        {
         Print("CopyBuffer - no data");
         return(WRONG_VALUE);
        }
   // Buy if there is a bounce from the Evelopes' lower border
      if(rt[1].open<env2[1] && rt[1].close>env2[1])
         return(bEntry ? ORDER_TYPE_BUY:ORDER_TYPE_SELL); // condition for buy
   // Sell if there is a bounce from the Evelopes' upper border
      if(rt[1].open>env1[1] && rt[2].close<env1[1])
         return(bEntry ? ORDER_TYPE_SELL:ORDER_TYPE_BUY); // condition for sell
   
      return(WRONG_VALUE); // if there is no signal
     }
   
   CMyEA ea; // class instance
   //------------------------------------------------------------------    OnInit

3. Die Short-Position schließen wir dann, wenn der Preis nicht stark fiel, sondern sich drehte und anstieg.

4. Die Long-Position schließen wir dann, wenn der Preis nicht stark anstieg, sondern sich drehte und fiel.

Sie können zur Optimierung einer Handelsstrategie noch viele weitere Möglichkeiten ersinnen, von denen einige in der entsprechenden Literatur beschrieben werden.

Alle weitere Information liegt bei Ihnen.

6. Tests auf unterschiedlichen Intervallen

Test unseres Expert Advisors auf gleichen Zeit-Intervallen mit einer Verschiebung von 1 Monat. Nehmen wir als Test-Zeitraum das "Letzte Jahr" Zeitspanne - 3 Monate.

Fazit

Kurzes Fazit: auf der Basis dieses Templates können Sie Ihr Trading-Konzept rasch mit nur minimalem Zeit- und Kräfteaufwand implementieren.

Auch die Optimierung der System-Parameter und Handels-Kriterien geht vollkommen problemlos vonstatten.

Zur Erzeugung eine gleichmäßiger und stabiler arbeitenden Handelssystems, wird die Optimierung aller Parameter über längere Zeit-Intervalle empfohlen.

1. Beitrag 20 Handelssignale in MQL5.
2. Beitrag Der Prototyp eines Handels-Roboters.
3. Beitrag Verschiedene Wege zur Ermittlung eines Trends in MQL5c.
4. Beitrag Expert Advisors auf Grundlage beliebter Handelssysteme und die Alchemie der Optimierung von Handels-Robotern.
5. Beitrag Beschränkungen und Verifizierungen in Expert Advisors.
6. Beitrag Einen Expert Advisor mit Hilfe des MQL5 Objekt-orientierten Programmieransatzes schreiben.
7. Beitrag Money Management Funktionen in einem Expert Advisor.