Testen von Mustern von Währungspaaren: Praktische Anwendung und echte Handelsperspektiven. Teil IV

31 August 2018, 10:13
Andrei Novichkov
0
150

Einführung

Dieser Artikel schließt die Studie über das Testen von Mustern ab, die beim Handel mit Körben von Währungspaaren entstehen und die hier begonnen wurde. Alles, was noch bleibt, ist das Besprechen der verbleibenden Muster — die Linie, die den gleitenden Durchschnitt kreuzt.

Zuvor haben wir bereits dieses Muster analysiert aber mit Bezug auf bestimmte Bedingungen:

  • Der Händler erhält beim Schließen der Kerze ein Eröffnungssignal, wenn die vereinigte Indikatorlinie für einen der Währungskörbe von seinem eigenen gleitenden Durchschnitt gekreuzt wird. Es gibt zwei derartige Signale - der gleitende Durchschnitt kreuzt die Linie nach unten (Verkauf) oder nach oben (Kauf).

Wir haben herausgefunden, dass die positive Eigenschaft dieses Musters eine große Anzahl von Signalen ist. Der Nachteil ist die Notwendigkeit eines zusätzlichen Filters.

Nun schlage ich vor, dieses Muster der Differenz zwischen den Werten der vereinigten Indikatorlinien für zwei Körbe zu testen: die der Basiswährung und die der notierten Währung (siehe die Details hier). Die Verwendung von zwei Körben mit Währungspaaren anstelle von einem kann als Faktor für eine zusätzliche Filterung dienen.

Darüber hinaus werden wir in der zweiten Hälfte des Artikels auf die Anwendung des erworbenen Wissens im realen Handel eingehen.

Untersuchte Muster

Wiederholen wir die Grundvoraussetzung für das Muster: Der Durchbruch des vereinigten Indikators durch den gleitenden Durchschnitt sollte klar und deutlich sein.

"Gutes" Muster (Signal), das nachdem wir suchen
Kein Muster, "schlechtes" Signal




Die grüne Linie ist eine vereinigte Indikatorlinie, während die rosa Linie der gleitende Durchschnitt ist.

Um das Muster genau zu identifizieren, ist es notwendig, dass der Abstand zwischen dem vereinigten Indikator und dem gleitenden Durchschnitt vor und nach dem Durchbruch nicht kleiner ist als der im linken Bild angegebene (Delta1 und Delta2). Es ist offensichtlich, dass diese Bedingung auf dem rechten Bild in dem von die blauen vertikalen Linien begrenzten Intervall nicht erfüllt ist. Es gibt also kein Muster.

In weiteren Studien werden wir prüfen, wie man die Muster, ähnlich denen auf dem linken Bild, als Eingangssignale verwendet. Die Ankunft des gleichen, aber entgegengesetzt gerichteten Musters kann als Ausstiegssignal dienen. Eine solche Taktik impliziert jedoch eine permanente Präsenz am Markt, was kaum zu einem positiven Ergebnis führen dürfte. Daher ist es möglich, das Erkennen von "schlechten" Mustern als Ausstiegssignal vorzuschlagen. Dies bedeutet, dass Positionen geschlossen werden, ohne gleich eine neue zu eröffnen.

Untersuchungsinstrumente

Wir haben bereits alle Instrumente. Wir haben sie früher, in den vergangenen Artikeln, entwickelt. Obwohl sich der Code nicht viel geändert hat, zeigen wir ihn hier. Der EA testEAbasket3.mq5 EA ist der wesentliche:

//+------------------------------------------------------------------+
//|                                                 testEAbasket.mq5 |
//|                        Copyright 2017, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Trade\\Trade.mqh>


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum BSTATE
  {
   BCLOSE = 0,
   BBUY   = 1,
   BSELL  = 2
  };
//+------------------------------------------------------------------+
//| Initialisierungsfunktion des Experten                            |
//+------------------------------------------------------------------+
input int wpr = 20;
input int ma  = 10;
input double lt=0.01; 

int h;
ulong  Ticket;

double m[1],ml;
double w[1],wl;

BSTATE g_state;

double g_dMinSize = 2.0;
double g_dMaxSize = 50.0;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   h=iCustom(NULL,0,"testWPR&MA3",wpr,ma);
   if(h==INVALID_HANDLE) 
     {
      Print("Error while creating testWPR&MA3");
      return (INIT_FAILED);
     }

   g_state=BCLOSE;
   EventSetTimer(1);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Deinitialisierungsfunktion des Experten                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   IndicatorRelease(h);
   EventKillTimer();

  }
//+------------------------------------------------------------------+
//| Experten Funktion OnTick                                         |
//+------------------------------------------------------------------+
void OnTick()
  {

  }
//+------------------------------------------------------------------+
//| Timer Funktion                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(IsNewCandle())
     {
      wl=w[0];
      CopyBuffer(h,0,1,1,w);
      ml=m[0];
      CopyBuffer(h,1,1,1,m);
      double d1 = MathAbs(w[0] - m[0]);
      double d2 = MathAbs(ml - wl);
      if(w[0]>m[0] && wl<ml) 
        {
         if(g_state!=BCLOSE) CloseAllPos();
         if(d1 >= g_dMinSize && d2 >= g_dMinSize &&
            d1 <= g_dMaxSize && d2 <= g_dMaxSize) 
           {
            EnterBuy(lt);
            g_state=BBUY;
           }
        }
      if(w[0]<m[0] && wl>ml) 
        {
         if(g_state!=BCLOSE) CloseAllPos();
         if(d1 >= g_dMinSize && d2 >= g_dMinSize &&
            d1 <= g_dMaxSize && d2 <= g_dMaxSize) 
           {
            EnterSell(lt);
            g_state=BSELL;
           }
        }
     }
  }
//+------------------------------------------------------------------+

void CloseAllPos()
  {

   CTrade Trade;
   Trade.LogLevel(LOG_LEVEL_NO);
   Trade.PositionClose(Ticket);
   g_state=BCLOSE;

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void EnterBuy(double lot)
  {

   CTrade Trade;
   Trade.LogLevel(LOG_LEVEL_NO);
   Trade.Buy(lot,_Symbol);
   Ticket=Trade.ResultDeal();
   g_state=BBUY;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void EnterSell(double lot)
  {

   CTrade Trade;
   Trade.LogLevel(LOG_LEVEL_NO);
   Trade.Sell(lot,_Symbol);
   Ticket=Trade.ResultDeal();
   g_state=BSELL;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsNewCandle()
  {
   static int candle=-1;
          int t1=0;
   switch(_Period)
     {
      case PERIOD_H1:  t1 = Hour();   break;
      case PERIOD_H4:  t1 = Hour4();  break;
      case PERIOD_D1:  t1 = Day();    break;
     }
     
   if(t1!=candle) {candle=t1; return(true);}
   return (false);
  }
            
  int Hour4(){return((int)Hour()/4);}

int Day()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.day);
  }

int Hour()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.hour);
  }

Dies ist die Version von testEAbasket.mq5 EA aus diesem Artikel bearbeitet für die Eröffnung eines einzelnen Währungspaar statt des gesamten Korbes. Der EA verwendet die Daten des Indikators testWPR&MA3.mq5, die die Version des Indikators testWPR&MA.mq5 aus dem gleichen Artikel ist:

//+------------------------------------------------------------------+
//|                                                      testWPR.mq5 |
//|                                        MetaQuotes Software Corp. |
//|                                               http://fxstill.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_minimum -100
#property indicator_maximum 100


#property indicator_buffers 2
#property indicator_plots   2

input int WPR       = 20; //Periodenlänge des WPR
input int maperiod  = 10; //Periodenlänge des MAs
input color   clr   = clrGreen;
input color   clrMA = clrMagenta;


int h,h1;
double ind[],ma[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
      h = iCustom(NULL,0,"testWPReur",WPR);
      if (h == INVALID_HANDLE) {
         Print("Error while creating testWPR");
         return (INIT_FAILED);
      }
      h1 = iCustom(NULL,0,"testWPRusd",WPR);
      if (h1 == INVALID_HANDLE) {
         Print("Error while creating testWPR");
         return (INIT_FAILED);
      }  
 

   IndicatorSetString(INDICATOR_SHORTNAME,"testWPRusd");
   IndicatorSetInteger(INDICATOR_DIGITS,2);
   IndicatorSetInteger(INDICATOR_LEVELS,2);
   IndicatorSetInteger(INDICATOR_LEVELSTYLE,0,STYLE_SOLID);
   IndicatorSetInteger(INDICATOR_LEVELSTYLE,1,STYLE_SOLID);
   IndicatorSetInteger(INDICATOR_LEVELCOLOR,0,clrRed);
   IndicatorSetInteger(INDICATOR_LEVELCOLOR,1,clrRed);
   IndicatorSetInteger(INDICATOR_LEVELWIDTH,0,1);
   IndicatorSetInteger(INDICATOR_LEVELWIDTH,1,1);
   IndicatorSetDouble(INDICATOR_LEVELVALUE,0,-60);
   IndicatorSetDouble(INDICATOR_LEVELVALUE,1,60);

   ArraySetAsSeries(ind,true);
   SetIndexBuffer(0,ind);
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE);
   PlotIndexSetInteger(0,PLOT_LINE_STYLE,STYLE_SOLID);
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,2);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,clr);
   PlotIndexSetString(0,PLOT_LABEL,"_tstWPRusd_");

   ArraySetAsSeries(ma,true);
   SetIndexBuffer(1,ma);
   PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_LINE);
   PlotIndexSetInteger(1,PLOT_LINE_STYLE,STYLE_SOLID);
   PlotIndexSetInteger(1,PLOT_LINE_WIDTH,1);
   PlotIndexSetInteger(1,PLOT_LINE_COLOR,clrMA);
   PlotIndexSetString(1,PLOT_LABEL,"Middle_Basket_line_MA");


//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetValue(int shift)
  {
   double dBuf[1], dBuf1[1];
   double res=0.0;
   CopyBuffer(h,0,shift,1,dBuf);
   CopyBuffer(h1,0,shift,1,dBuf1);
   return (NormalizeDouble((dBuf[0] - dBuf1[0])/2, _Digits) );
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
      int rt=rates_total-WPR;
      for(int i=1; i<rt; i++)
        {
         ind[i]=GetValue(i);
        }
      rt-=maperiod;
      for(int i=1; i<rt; i++)
        {
         ma[i]=GetMA(ind,i,maperiod,_Digits);
        }
     }
   else
     {
         ind[0] = GetValue(0);
         ma[0]  = GetMA(ind, 0, maperiod, _Digits);        
     }
//--- Rückgabe des Wertes von prev_calculated für den nächsten Aufruf
   return(rates_total);
  }
//+------------------------------------------------------------------+

void OnDeinit(const int reason)
  {
      if(h!=INVALID_HANDLE) IndicatorRelease(h);
      if(h1!=INVALID_HANDLE) IndicatorRelease(h1);
  }
//+------------------------------------------------------------------+

double GetMA(const double &arr[],int index,int period,int digit) 
  {
   double m=0;
   for(int j=0; j<period; j++) m+=arr[index+j];
   m/=period;
   return (NormalizeDouble(m,digit));
  }
//+------------------------------------------------------------------+

Der Indikator wurde geringfügig verändert, um den oben beschriebenen Bedingungen für die Mustererkennung zu entsprechen. Alle verwendeten Instrumente finden Sie im beigefügten Archiv test.zip.

Zuvor begannen ähnliche Studien mit der Definition der potenziellen Anzahl der Markteintritte. Dies ist hier nicht der Fall, da unsere Erfahrung mit dem Testen solcher Muster zeigt, dass die Anzahl der Transaktionen völlig ausreichend sein wird.

Vor dem Testen geben wir die Musterform an. Wir haben bereits genug Zeit den bestimmten Werten der Parameter von Delta1 und Delta2 gewidmet. Diese Werte wurden gefunden und eine strikte Filterung der Eröffnungssignale implementiert. Hier werden wir die Einschränkungen etwas lockern. Dadurch wird die Anzahl der Eröffnungen erhöht, ohne das dem Muster zugrundeliegende Prinzip zu beeinträchtigen: Delta1 und Delta2 sollten mindestens 2% und nicht mehr als 50% betragen.

Wählen wir eine der beiden Teststrategien.

  • Ständige Präsenz im Markt. Händler betreten den Markt durch ein Signal und warten auf ein Eröffnungssignal in die entgegengesetzte Richtung. Dann schließen sie offene Positionen, gehen in die entgegengesetzte Richtung, usw. Wir werden uns nicht an diese Strategie halten, da sie ihre Ineffizienz erwiesen hat.
  • Positionen schließen, ohne sofort eine neue zu eröffnen. Händler treten durch ein Signal in den Markt ein und warten auf ein Ausstiegssignal in Form eines "schlechten" Musters. Es liefert keine Eingangssignale, kann aber vor einer möglichen Trendverlangsamung oder -umkehr warnen. Wir werden diese Strategie zum Testen verwenden.

Nun, lassen Sie uns den Zeitrahmen definieren. In den vorherigen Artikeln haben wir das Muster auf H1, H4 und D1 getestet. D1 hat nur wenige Positionen gezeigt, deshalb werden wir es weglassen. Wir werden nur H1 und H4 verwenden und mit EURUSD testen.

Testen des Musters

Nach der Prüfung mit Kursen des letzten Jahres von H1, erhalten wir folgenden Ergebnisse:

Mit dem Zeitrahmen H4:

Wie in den vorangegangenen Tests sehen wir einen Verlust mit H1 und einen Gewinn mit H4.

Testen wir jetzt das Muster der Hauptwährungspaare: EURUSD, GBPUSD, AUDUSD, NZDUSD, USDCAD, USDCHF und USDJPY.

Der Test hat keine Überraschungen gebracht. Die Ergebnisse sind vergleichbar mit den bereits erhaltenen Daten: ermutigend für H4 und mit Verlust für H1. Die Testberichte finden sich im angehängten Archiv testhtml.zip.

Wir haben bereits Erfahrung sammeln können, die Rentabilität durch die Einführung einer zusätzlichen Sortierung der Eingangssignale zu erhöhen. Verwenden wir den zweiten Filter, der in diesem Artikel angewendet wurde:

  • Händler kaufen NICHT, wenn die kombinierte WPR-Linie die überkaufte Grenze nach oben berührt oder durchbricht.
  • Händler verkaufen NICHT, wenn die kombinierte WPR-Grafik die überkaufte Grenze nach unten berührt oder durchbricht.

Der korrigierte Code des EAs befindet sich im beigefügten Archiv test1.zip. Es macht keinen Sinn, hier den gesamten Code anzuzeigen, da er fast identisch ist mit dem vorher angezeigten. Ich zeige nur die Funktion, die das Muster direkt identifiziert:

//+------------------------------------------------------------------+
//| Timer Funktion                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(IsNewCandle())
     {
      wl=w[0];
      CopyBuffer(h,0,1,1,w);
      ml=m[0];
      CopyBuffer(h,1,1,1,m);
      double d1 = MathAbs(w[0] - m[0]);
      double d2 = MathAbs(ml - wl);
      if(w[0]>m[0] && wl<ml) 
        {
         if(g_state!=BCLOSE) CloseAllPos();
         if(d1 >= g_dMinSize && d2 >= g_dMinSize &&
            d1 <= g_dMaxSize && d2 <= g_dMaxSize && w[0] < 60) 
           {
            EnterBuy(lt);
            g_state=BBUY;
           }
        }
      if(w[0]<m[0] && wl>ml) 
        {
         if(g_state!=BCLOSE) CloseAllPos();
         if(d1 >= g_dMinSize && d2 >= g_dMinSize &&
            d1 <= g_dMaxSize && d2 <= g_dMaxSize && w[0] > -60) 
           {
            EnterSell(lt);
            g_state=BSELL;
           }
        }
     }
  }
//+------------------------------------------------------------------+

Wo sollten wir überkaufte und überverkaufte Werte platzieren? In früheren Artikeln haben wir gezeigt, dass die Standardwerte des kombinierten Indikators auf Basis von WPR (+60 für das überkaufte Niveau und -60 für das überkaufte Niveau) für die getesteten Bedingungen leicht gesenkt werden können. Zusätzlich zur Option Standardwerte testen wir die Werte von + 50% und -50% für überkaufte bzw. überverkaufte Werte. Testberichte für EURUSD mit H1 und H4 befinden sich in den Archiven testhtml50.zip und testhtml60.zip.

Wie wir sehen können, unterscheiden sie sich nicht von den ersten beiden oben beschriebenen Tests. Dieses stehen mit den Resultaten von des vorhergehenden Artikels in Einklang, das dem Testen dieses Musters gewidmet war. Auch ein solcher Filter brachte damals keine nennenswerten Ergebnisse. Deshalb werden wir dieses Muster nicht mit den verbleibenden Paaren testen und zum letzten Teil übergehen - mit ihm als Filter.

Erinnern wir uns kurz an den Fall.

  • Die kombinierte WPR-Grafik durchbricht das überverkaufte Niveau nach oben. Der Durchbruch bleibt beim Schließen der Kerze. Ein Händler kauft nur, wenn der gleitende Durchschnitt "unter" der kombinierten Indikatorlinie liegt.
  • Für den Verkauf sollte die Situation umgekehrt sein.
  • Der Händler verlässt den Markt, wenn die kombinierte WPR-Linie 0% erreicht.

testEAbasket5.mq5 EA wird zum Testen verwendet:

//+------------------------------------------------------------------+
//|                                                 testEAbasket.mq5 |
//|                        Copyright 2017, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Trade\\Trade.mqh>



enum BSTATE
  {
   BCLOSE = 0,
   BBUY   = 1,
   BSELL  = 2
  };
//+------------------------------------------------------------------+
//| Initialisierungsfunktion des Experten                            |
//+------------------------------------------------------------------+
input int wpr = 20;
input int ma  = 10;
input double lt=0.01; //lot

int SELLPROFIT =   0;
int SELL1LIMIT =  50;
int SELL2FROM  =  40;
int SELL2TO    =  20;
int BUYPROFIT  =   0;
int BUY1LIMIT  = -50;
int BUY2FROM   = -40;
int BUY2TO     = -20;


int h;
ulong  Ticket;

double m[1],ml;
double w[1],wl;

BSTATE g_state;

double g_dMinSize = 2.0;
double g_dMaxSize = 50.0;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   h=iCustom(NULL,0,"testWPR&MA3",wpr,ma);
   if(h==INVALID_HANDLE) 
     {
      Print("Error while creating testWPR&MA3");
      return (INIT_FAILED);
     }

   g_state=BCLOSE;
   EventSetTimer(1);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Deinitialisierungsfunktion des Experten                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   IndicatorRelease(h);
   EventKillTimer();

  }
//+------------------------------------------------------------------+
//| Experten Funktion OnTick                                         |
//+------------------------------------------------------------------+
void OnTick()
  {

  }
//+------------------------------------------------------------------+
//| Timer Funktion                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(IsNewCandle())
     {
      wl=w[0];
      CopyBuffer(h,0,1,1,w);
      ml=m[0];
      CopyBuffer(h,1,1,1,m);


      if(g_state==BBUY && (w[0]>=BUYPROFIT))
        {
         CloseAllPos();
        }
      if(g_state==BSELL && (w[0]<=SELLPROFIT))
        {
         CloseAllPos();
        }
      if(g_state==BCLOSE && w[0]>=BUY2FROM && w[0]<=BUY2TO && wl<=BUY1LIMIT && w[0] > m[0])
        {
            EnterBuy(lt);
            return;        
        }
        
 
      if(g_state==BCLOSE && w[0]<=SELL2FROM && w[0]>=SELL2TO && wl>=SELL1LIMIT && w[0] < m[0])
        {
            EnterSell(lt);
            return;        
        }
     }
  }
//+------------------------------------------------------------------+

void CloseAllPos()
  {

   CTrade Trade;
   Trade.LogLevel(LOG_LEVEL_NO);
   Trade.PositionClose(Ticket);
   g_state=BCLOSE;

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void EnterBuy(double lot)
  {

   CTrade Trade;
   Trade.LogLevel(LOG_LEVEL_NO);
   Trade.Buy(lot,_Symbol);
   Ticket=Trade.ResultDeal();
   g_state=BBUY;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void EnterSell(double lot)
  {

   CTrade Trade;
   Trade.LogLevel(LOG_LEVEL_NO);
   Trade.Sell(lot,_Symbol);
   Ticket=Trade.ResultDeal();
   g_state=BSELL;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsNewCandle()
  {
   static int candle=-1;
          int t1=0;
   switch(_Period)
     {
      case PERIOD_H1:  t1 = Hour();   break;
      case PERIOD_H4:  t1 = Hour4();  break;
      case PERIOD_D1:  t1 = Day();    break;
     }
     
   if(t1!=candle) {candle=t1; return(true);}
   return (false);
  }
            
  int Hour4(){return((int)Hour()/4);}

int Day()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.day);
  }

int Hour()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.hour);
  }

Wie zuvor starten wir den Test mit EURUSD H1 und H4.

Ergebnisse des Zeitrahmens H1:

Ergebnisse des Zeitrahmens H4:

Wie wir sehen können, ist die Anzahl der Positionen gering. Wir haben dieses Phänomen bereits diskutiert und sogar seine Ursachen vermutet. Die Anzahl der Positionen kann bei den verbleibenden Paaren noch geringer sein. Deshalb beenden wir den Test, um zu den Schlussfolgerungen kommen.

Ergebnisse

  1. Wir haben die Methode der Verwendung von Körben mit Währungspaaren im Handel besprochen. Grundlagen und Konzepte, sowie Arten von Basisberechnungen wurden zur Verfügung gestellt.
  2. Einige einfache Muster, die beim Handel mit Währungspaar-Körben entstehen, wurden beschrieben.
  3. Komplexere Konstruktionen, die bei der Verwendung von Körben auftreten, wurden kurz betrachtet - gleichzeitige Verwendung von technischen Standardindikatoren und Indikatoren, die speziell für die Arbeit mit Währungspaaren entwickelt wurden; gleichzeitige Verwendung von Oszillatoren und Trendfolgeindikatoren.
  4. Die Effizienz der erkannten Muster wurde überprüft.

Wir haben ein Instrument erhalten, das es uns ermöglicht, den Markt auf eine neue, vernünftige und logische Weise zu beurteilen. Das Testen der Muster hat jedoch keine überzeugenden Ergebnisse gezeigt. Obwohl es unmöglich war, etwas anderes zu erwarten. Schließlich behaupten Handelsaxiome, dass mehrere Signale erforderlich sind, um eine Eintrittsentscheidung zu treffen, während wir eine Entscheidung auf der Grundlage eines einzigen Musters getroffen haben.

Die Erfahrung zeigt, dass der Handel mit den einfachsten Mustern (z.B. wenn eine Linie des Charts einen gleitenden Durchschnitt kreuzt) sehr riskant ist. Wir haben jedoch die einfachen Muster verwendet und in einigen Fällen vielversprechende Ergebnisse erzielen können. Außerdem sollten wir nicht vergessen, unser Ziel nicht ein rentabler EA. Stattdessen wollten wir ein machbares Signal erhalten, das mit anderen Signalen kombiniert werden kann, um eine Handelsentscheidung zu treffen.

Bewerten wir die Perspektiven und Möglichkeiten der Anwendung der beschriebenen Methode in der täglichen Praxis und im automatisierten Handel.

Perspektiven und Anwendung im realen Handel

Bei der Arbeit an diesem Thema kann man nicht auf Testindikatoren und EAs verzichten. Beispiele für den Einsatz zuverlässiger Werkzeuge werden benötigt. Der Market enthält einige davon, während andere demnächst hinzugefügt werden sollen. In dem Artikel werde ich nur Beispiele für solche Programme geben, ohne ihre wirklichen Namen anzugeben. 

Das Thema der Verwendung der Muster von Währungskörben ist sehr groß. Täglich erscheinen neue Handelsmethoden, die es unmöglich machen, sie in einen Artikel zusammenzufassen. Es ist jedoch möglich, diese in Form von separaten Beiträgen, Screenshots oder Templates zu ergänzen. Einige Materialien sind bereits präsent in meinem Blog. Ich werde diese Informationen in Zukunft erweitern.

Eröffnen und Schließen im Detail

Betrachten wir die Details Positionen mit NZDUSD H1 zu eröffnen und zu schließen. Der vereinigte Indikator hat ein Kaufsignal erkannt, das sich als profitabel erwiesen hat (vertikale blaue Linie):



Auf der linken Seite sehen wir die Grafik der Differenz zwischen den Werten eines vereinigten Indikators für die Währungskörben der Basiswährung und der der notierten Währung. Die "Pseudo-Gleichung" dieses Indikators kann wie folgt geschrieben werden:

Indikator (NZDUSD) = Indikator (NZD) - Indikator (USD)

Nehmen wir an, dass diese Art der Darstellung standardmäßig auf alle vereinheitlichten Indikatoren weiter im Artikel angewendet wird, wenn nicht anders angegeben.

Die Eröffnungsmglichkeiten sind wie folgt.

  1. Die untere rote horizontale Linie ist die überverkaufte Ebene. Wir können sehen, dass das Muster des Indikatordiagramms, das dieses Niveau durchbricht, zuerst gebildet wird. Diese Stelle ist durch eine senkrechte grüne Linie markiert, während das Muster selbst beim Öffnen der Kerze 1 erkannt wird. An dieser Stelle können Sie bereits eine Kauforder eröffnen: Der Abwärtstrend hat seine Möglichkeiten ausgeschöpft und beginnt sich umzukehren. Ein Händler erfasst den Beginn dieser Bewegung und hat die Fähigkeit, den gesamten Aufwärtstrend zu erfassen. Wir haben dieses Muster getestet. Sie ist eher riskant (da sich ein Abwärtstrend nach der Korrektur fortsetzen kann) und erscheint selten. Die Verluste des potentiellen Händlers sind in diesem Fall nicht allzu groß. Hier kann ein enger Stop-Loss verwendet werden.
  2. Auf dem Screenshot sehen wir jedoch, dass ein neuer Aufwärtstrend an Fahrt gewinnt. Es entsteht ein neues Muster - der Indikatorlinie durchbricht den gleitenden Durchschnitt. Dies ist ein guter Signalfilter, nachdem das überkaufter Niveau gekreuzt wurde. Das reduziert das Risiko eines anhaltenden Abwärtstrends. Das Muster ist ebenfalls mit einer grünen vertikalen Linie markiert und kann an der Öffnung der Kerze 2 erkannt werden. Auch hier könnte man in den Markt einsteigen. Generell sollte ein Stop-Loss weiter sein (definiert durch die Parameter des gleitenden Mittelwerts).
  3. Nachdem der Aufwärtstrend an Stärke gewonnen hat, erscheint ein neues Muster - der schnelle gleitende Durchschnitt durchbricht den langsamen. Dieses Muster wird beim Öffnen der Kerze 3 erkannt. Im Vergleich zu den beiden vorangegangenen Fällen ist das Risiko minimal. Allerdings ist ein Gewinnniveau niedriger, während ein Stop-Loss weiter ist. Achten wir darauf, wie sich der Abstand zwischen den gleitenden Durchschnitten vergrößert, nachdem das Muster erkannt wurde. Dies deutet darauf hin, dass der Trend stärker wird - ein günstiges Signal für einen Händler. Ein abnehmender Abstand deutet auf eine Verlangsamung und Schwächung hin (siehe linker Screenshot).

Beachten Sie, dass die ersten beiden beschriebenen Varianten der Eröffnung über die Muster typisch für alle Arten von Oszillatoren sind und gut bekannt sind. Das dritte Muster ist nicht so bekannt. Es funktioniert mit allen Oszillatoren, aber hier gilt es als Beispiel für den Markteintritt mit einem etablierten, entwickelten Trend.

Alle drei Eröffnungsmöglichkeiten werden durch ein starkes Startsignal vereinheitlicht - überverkaufter Level-Durchbruch. Ein solches Signal ist jedoch recht selten. Lassen Sie es uns noch einmal kurz analysieren.

  • Auf dem rechten Screenshot sehen wir, wie die Indikatorlinie in den überkauften (oder überkauften) Bereich gelangt. Die entsprechende Stelle wird durch das grüne Rechteck markiert. Im Anzeigefenster wird derselbe Indikator anders dargestellt - getrennt für die Körbe NZD (hellblaue Linie) und USD (dunkelgrüne Linie). Wir können sehen, dass der USD-Korb irgendwann überkauft wurde, während der NZD-Korb längere Zeit bereits überverkauft ist. Die gleichzeitige Kombination solcher Zustände der Körbe erzeugt ein Bild, wie im linken Screenshot, wo die kombinierte Indikatorlinie für NZDUSD in den überkauften Bereich mit dem anschließenden Durchbruch des überkauften Levels und der Trendumkehr eintritt.

Solche günstigen Kombinationen von Ereignissen treten jedoch nur selten auf. Heißt das, wir sollten wochenlang auf ein Signal warten? Nicht unbedingt. Es ist davon auszugehen, dass sich die überkauften/überverkauften Niveaus auf etwas niedrigeren Niveaus befinden. Der Wert kann für jedes Paar und jeden Zeitraum unterschiedlich sein. Aber es scheint, dass in den meisten Fällen die Werte von + 50% und -50% ausreichend sind. Das erhöht zweifellos das Risiko. Schauen wir uns noch einmal den rechten Screenshot an. Eine neue Anordnung der Ebenen bedeutet, dass einer der beiden Körbe (oder sogar beide!) seine Bewegung noch nicht ausgeschöpft hat. So kann es weitergehen, und ein Händler riskiert, gegen einen Trend zu handeln. Daher ist das Muster 3 von besonderer Bedeutung, da es eine Eröffnungs in Trendrichtung bedeutet. Aber auch hier gibt es eine Falle in Form einer Divergenz:



Auf dem rechten Screenshot sehen wir, wie der schnelle MA den langsamen nach oben durchbricht, während sich der Indikator selbst ebenfalls nach oben bewegt. Auf dem linken Screenshot links sehen wir eine Abweichung: Der Indikator und die MA-Linien bewegen sich in verschiedene Richtungen. Natürlich sollte das Signal mit einer Divergenz ignoriert werden! Mein Nachrichtenblog enthält weitere Beispiele für verschiedene Muster mit und ohne Divergenz.

Denken wir nun über mögliche Wege nach, den Markt zu verlassen (die Positionen zu schließen).

Angenommen, ein Händler ist auf eine der drei beschriebenen Arten in den Markt eingetreten. Ein entgegengesetztes Signal kann verwendet werden, um eine Position ganz oder teilweise zu schließen oder einen Breakeven festzumachen.

1. Der Indikator tritt beispielsweise in den überkauften Bereich ein - dies ist ein wichtiger Grund, um Kaufpositionen zu schließen oder Breakeven festzumachen (das Gegenteil gilt für Verkaufspositionen).

2. Ein Händler mit offenen Positionen kann das Kreuzen des MAs mit der Indikatorlinie in die entgegengesetzte Richtung zu den zuvor geöffneten Position erkennen.

3. Ein Händler kann erkennen, dass sich ein Trend wegen einer sich verringernden Distanz zwischen dem schnellen und dem langsamen Durchschnitt verlangsamt.

4. Schließlich kann das Erreichen der Werte, die vom Indikator NICHT überkauft/überverkauft sind, als Signal verwendet werden, um die Breakeven festzumachen. Dies kann z.B. Level 0% sein. Dieser Level bedeutet die "Gleichheit" beider Währungskörbe. Der Indikator neigt dazu, bei solch einem Niveau zu "stolpern". Daher ist dieses Niveau wie ein Widerstand:

Dafür können Fibo_level der vereinigten Indikators verwendet werden. 

5. Zuletzt noch: Ein Händler kann einen Stop-Loss setzen und den Gewinn auf der Grundlage seiner eigenen Überlegungen oder einer technischen Standardanalyse verwenden.

Wir haben uns überlegt, wie man Positionen öffnen und schließen kann. Nun suchen wir nach Mustern auf dem Chart und analysieren sie.

Arbeiten mit vereinigten Indikatoren


Um erkannte Muster zu identifizieren, platzieren wir den vereinigten Indikator auf dem Chart und betrachten die Ergebnisse. Hier ist ein aktuelles Beispiel für NZDUSD H1 (das Chart ist aufgrund der Größenbeschränkungen in zwei Bilder unterteilt):


Beachten Sie, dass die Muster 3 und 7 in der Nähe des Ausgangs aus überkauften/überverkauften Bereichen erkannt werden. Hier gibt es keine Divergenz, während sich der Preis stark nach oben bewegt und das Nullniveau im Muster 3 überschreitet. Auf der anderen Seite sind die Bewegungen im Bereich des Musters 7 relativ schwach. Die starke Bewegung verlangsamt sich und kehrt sich um. Die Indikatorlinie hat die Nulllinie noch nicht überschritten und ist in der Lage, von ihr abzuprallen (was genau das ist, was wir sehen).

Das Muster 8 zeigt eine Erholung vom überkauften Niveau. Die Indikatorlinie berührte es, kehrte sich um und ging stark nach oben und bildete das Muster. Das Null-Level wird überschritten, so dass es möglich ist, zu kaufen. Die Indikatorlinie und der Preis kehren sich jedoch um und bewegen sich in die entgegengesetzte Richtung. Etwas später kann ein Händler die Position mit einem minimalen Verlust schließen, ansonsten kann der Verlust durchaus spürbar werden.

Das Muster 6 ist nicht sehr vielversprechend: Das Verkaufspotenzial ist nahezu ausgeschöpft und das überverkaufte Niveau erreicht. Das Risiko einer Umkehr ist hoch. In der Praxis sehen wir eine anhaltende flache Bewegung, die sich nicht lohnt. Die Abwärtsbewegung beginnt wieder, wenn auch viel später: Das Muster kann dort als altbewährt angesehen werden.

Unter ähnlichen Bedingungen wie beim Muster 6 ist das Muster 5 sehr vielversprechend. Daher sollten wir die vom Indikator erkannten Muster in der Nähe der überkauften/überverkauften Bereiche nicht eindeutig verwerfen, da sich der Trend zum Zeitpunkt der Erkennung noch fortsetzen kann.

Das Muster 4 bewegt sich ebenfalls um den Nullpunkt, ohne ihn zu kreuzen. Es gibt keine Divergenz, die Indikatorlinie bewegt sich horizontal.

Das Muster 2 ist vielversprechend. Die Abwärtsbewegung verlangsamt sich und kehrt um, ohne das Nullniveau zu erreichen. Es gibt keine Divergenz, da die Grafik noch nicht das überverkaufte Niveau erreicht hat. Obwohl sich der Indikator dann flach bewegt, bringt das Muster dennoch einen guten Gewinn.

Wir werden das Muster 1 nicht berücksichtigen: Wir wissen nicht, was vor seiner Entstehung geschah.

Zusätzlich zu den gefundenen Mustern lohnt es sich, auf die mit einem blauen Pfeil markierten Bereiche zu achten. Dies ist eine kraftvolle und stetige Bewegung von der überkauften Ebene mit dem Durchbrechen der Nulllinie und dem Aufstieg in den überkauften Bereich. Der Indikator hat das Muster nicht gefunden, obwohl beide MAs gekreuzt wurden. Es gibt keine Divergenz. Wir erwägen den Markteintritt, wenn der Indikator das Nullniveau durchbricht, zumal dieser Durchbruch mit dem Durchbruch des schnellen MA durch den langsamen zusammenfällt.

Bitte beachten Sie, dass unsere Analysemethode nicht einfach ist. Sie enthält viel Unklarheit, da wir mindestens einmal einen Verlust erleiden könnten. Um die Analysemöglichkeiten mit Hilfe von kombinierten Indikatoren zu erhöhen, sollten wir auf die nächste Stufe - die "erweiterte" Analyse - zurückgreifen.


Erweiterte Arbeit mit kombinierten Indikatoren

Das erste, worüber wir reden sollten, ist die Verwendung von zwei Kopien eines kombinierten Indikators auf einem einzigen Chart. Indirekt wurde diese Möglichkeit bereits im vorherigen Abschnitt erwähnt. Nun werden wir uns eingehender damit befassen.

  • Das Chart enthält zwei Instanzen eines kombinierten Indikators mit ähnlichen Einstellungen, aber unterschiedlichen Darstellungsmethoden:
    1. Die Voreinstellung ist das V1-Fenster.
    2. Zwei separate Charts jeweils für die Währungskörbe der Basiswährung und der notierten Währung (Fenster V2).

Es sind die Indikatoren für USDCAD. Im Fenster V2 wird der Zustand des USD-Währungskorbes als dunkelgrüne Linie angezeigt, während die CAD-Linie als orange Linie angezeigt wird.

Im Fenster V1 erkannte der Indikator zwei Eingabemuster (1 und 2). In beiden Fällen gibt es keine Divergenzen und der Markteintritt kann sich lohnen.

Werfen wir einen Blick auf das Fenster V2, Muster 1. Hier sehen wir, dass der CAD-Korb überkauft war und sich nun dem Nullniveau nähert. Auch der USD-Korb schwächte sich ab, während er den überkauften Bereich verließ. Doch die Schwächung hörte schließlich auf, um sich in eine horizontale Bewegung zu verwandeln. Im Moment der Mustererkennung tendierte die Bewegung nach oben. Damit ist eine Kaufposition gerechtfertigt.

Lassen Sie uns einen Blick auf Punkt 2 werfen. Hier ist die Situation riskanter, da beide Körbe das horizontale Segment im V2-Fenster passieren. Daher kann jeder von ihnen in jede Richtung gehen und einen möglichen Verlust verursachen.

Außerdem kann ein Händler auf Punkt 3 achten. Es gibt dort kein Muster, aber im V2-Fenster sehen wir deutlich, dass beide Körbe über die überkauften und überverkauften Bereiche hinausgehen. Dies bedeutet, dass ein Händler den Beginn eines Trends, der sich gerade umgekehrt hat, erfassen kann.

In diesem Fall sucht ein Händler "standardmäßig" nach Mustern mit der Indikatorlinie und verfeinert das Bild durch eine andere Art der Darstellung der Daten mit der zweiten Instanz des gleichen Indikators.

Die zweite interessante Möglichkeit, mit den kombinierten Indikatoren zu arbeiten, besteht darin, sie zusammen mit Standardindikatoren zu verwenden. Hier ist ein Beispiel für die Verwendung eines kombinierten Indikators basierend auf WPR mit dem üblichen Standard WPR:

Dies ist fast das gleiche Segment aus dem USDCAD-Chart. Bisher haben wir bereits festgestellt, dass das Muster 1 für den Markteintritt geeignet ist, während das Muster 2 ein größeres Risiko birgt. Schauen Sie sich nun das Muster 3 an, das ebenfalls erfolglos ist. Es gibt keine Divergenz, aber es bringt auch keinen Gewinn. Im Standard WPR-Fenster wird deutlich, warum dies geschieht: WPR ist im überkauften Bereich. Infolgedessen verliert das Paar an Wert, was entweder zu einer Korrektur oder sogar zu einer Trendwende führen kann. Das Muster 2 zeigt auch hier eine flache Bewegung mit anschließender Korrektur. Das Muster 1 ist immer noch stark. Bei einem Trendfolgeeintrag hat der WPR-Indikator noch genügend Reichweite bis zum überkauften Bereich, während die Nulllinie bereits überschritten ist. Dies impliziert die potentielle Profitabilität des Musters, die anschließend bestätigt wird.

Nun wollen wir ein Beispiel für eine weniger eindrucksvolle "Zusammenarbeit" geben. Wir werden das gleiche USDCAD-Paar verwenden. Auch das Segment und der Zeitrahmen sind gleich. Das Fenster enthält kombinierte STOCH und Standard WPR. Die vertikalen Linien, die die zuvor erkannten Muster anzeigen, werden als Referenz belassen:


Der kombiniert STOCH ergab keine signifikanten Muster. Wie beim kombinierten WPR wird davon ausgegangen, dass die Muster 1 und 3 für die Eingabe geeignet sind. Das Muster 2 zeigt Divergenz, so dass wir es nicht für den Markteintritt nutzen können. Bitte beachten Sie, dass die von WPR als überkaufte Zonen eingestuften Flächen von der kombinierten STOCH meist als flache Zonen erscheint. Dies ist noch ein weiteres Beispiel für die Kombination der Indikatoren.

Die oben beschriebenen Methoden der Arbeit mit kombinierten Indikatoren sind nicht die einzigen möglichen, aber sie sind durchaus erkennbar, offensichtlich und effizient.

Schlussfolgerung

In unserer Artikelserie haben wir überlegt, mit den Mustern zu arbeiten, die beim Handel mit Währungskörben entstehen. Wir haben die Art und Weise des Markteintritts und -austritts sowie wichtige Grundsätze der Anwendung beschrieben.

Die meisten Beispiele wurden mit dem kombinierten WPR realisiert. Es gibt jedoch auch andere kombinierte Indikatoren wie STOCH, RSI, TDI, etc. Zusammen bilden sie die Indikatorstrategie für den Handel mit Währungskörben. Diese Strategie ist nicht einfach und kann nur von einem erfahrenen und durchdachten Händler beherrscht werden.

Gibt es weitere Entwicklungsmöglichkeiten? Natürlich gibt es sie. Wir werden sie sicher später beschreiben.


Die dieses Artikels

 # Name
Typ
 Beschreibung
1 test.zip Archive
Die Testinstrumente der Muster
2
testhtml.zip Archive Testergebnisse mittels der Instrumente aus test.zip
3 test1.zip Archive Code des EAs für die Tests mit dem Filter
4 testhtml50.zip Archive Testergebnisse mittels der Instrumente aus test1.zip
5
testhtml60.zip Archive
Testergebnisse mittels der Instrumente aus test1.zip
 6 testEAbasket5.mq5  EA Test-EA


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

Beigefügte Dateien |
test.zip (15.54 KB)
testhtml.zip (1197.56 KB)
testhtml50.zip (226.91 KB)
testhtml60.zip (200.84 KB)
testEAbasket5.mq5 (4.81 KB)
Tiefe Neuronale Netzwerke (Teil VII). Ensembles von Neuronalen Netzen: Stacking Tiefe Neuronale Netzwerke (Teil VII). Ensembles von Neuronalen Netzen: Stacking

Wir erstellen weitere Ensembles. Diesmal wird das zuvor mittels Bagging geschaffene Ensemble durch einen trainierbaren Kombinator (Combiner) - ein tiefes neuronales Netzwerk - ergänzt. Ein neuronales Netz kombiniert die 7 besten Ensemble-Ergebnisse nach der Bereinigung (pruning). Der zweite nimmt alle 500 Ausgänge des Ensembles als Input, bereinigt sie und kombiniert sie neu. Die neuronalen Netze werden mit dem keras/TensorFlow-Paket für Python aufgebaut. Die Eigenschaften des Pakets werden kurz erläutert. Es werden Tests durchgeführt und die Klassifizierungsqualität der Ensembles mit Bagging und Stacking verglichen.

So formulieren Sie das Pflichtenheft eines Auftrages für einen Handelsroboter So formulieren Sie das Pflichtenheft eines Auftrages für einen Handelsroboter

Handeln Sie nach Ihrer eigenen Strategie? Wenn Sie Ihre Handelsregeln formalisieren und als Algorithmus für ein Programm beschreiben können, wäre es doch besser, Ihren Handel einem automatisierten Expert Advisor anzuvertrauen. Ein Roboter braucht weder Schlaf noch Nahrung und ist keinen menschlichen Schwächen unterworfen. In diesem Artikel zeigen wir Ihnen, wie Sie, um einen Handelsroboter im Freelance-Service in Auftrag zu geben, das sogenannte Pflichtenheft erstellen.

Integration von MQL-basierten Expert Advisors und Datenbanken (SQL Server, .NET und C#) Integration von MQL-basierten Expert Advisors und Datenbanken (SQL Server, .NET und C#)

Der Artikel beschreibt die Möglichkeit, wie ein MQL5-basierter Expert Advisors mit dem Datenbankserver Microsoft SQL Server arbeiten kann. Es wird der Import von Funktionen aus einer DLL-Datei verwendet. Die DLL wird mit der Microsoft.NET-Plattform in der Sprache C# erstellt. Die im Artikel verwendeten Methoden eignen sich, mit kleinen Anpassungen, auch für Experten, die in MQL4 geschrieben sind.

Die Überwachung des Handelskontos ist ein unverzichtbares Werkzeug für den Händler. Die Überwachung des Handelskontos ist ein unverzichtbares Werkzeug für den Händler.

Die Überwachung des Handelskontos bietet einen detaillierten Bericht über alle abgeschlossenen Geschäfte. Alle Handelsstatistiken werden automatisch gesammelt und Ihnen als leicht verständliche Diagramme und Grafiken zur Verfügung gestellt.