Klassische Strategien neu interpretieren (Teil 18): Suche nach Kerzenmustern

Kerzenmuster werden seit langem von professionellen Händlern verwendet, um sich auf den Finanzmärkten zurechtzufinden und die Stimmung der Anleger einzuschätzen. Diese Muster können manchmal zutreffend sein und zuverlässige Ergebnisse liefern. Es ist jedoch auch bekannt, dass sie je nach der vorherrschenden Marktlage schwanken können. In diesem Artikel wollen wir uns mit den verfügbaren Kerzenmustern befassen und untersuchen, ob algorithmische Verbesserungen vorgenommen werden können, um die Einschränkungen ihrer klassischen Interpretation zu überwinden.

In der heutigen Diskussion werden wir uns auf Kerzenmuster konzentrieren, die gemeinhin als Engulfing-Kerzen bezeichnet werden. Es gibt viele Herausforderungen, die es Praktikern schwer machen, zuverlässige Kerzenmuster zu finden. Das erste Problem, auf das die meisten Praktiker stoßen, ist die Tatsache, dass es sehr viele verschiedene Kerzenmuster gibt, denen jeder Händler folgen kann. Erschwerend kommt hinzu, dass dieser Raum nur manuell durchsucht werden kann, was bedeutet, dass der Praktiker die Regeln und Bedingungen in seinem Algorithmus, die das spezifische Kerzenmuster beschreiben, das ihm vorschwebt, oft von Hand definieren muss.

Wie wir wissen, gibt es eine Vielzahl von Kerzenmustern, und es kann für neue und unerfahrene Mitglieder unserer Gemeinschaft einschüchternd sein, diesen Bereich von Hand zu durchsuchen. Dieser Artikel soll einen praktischen Leitfaden bieten, wie wir ein bekanntes Kerzenmuster verbessern können. Das Engulfing-Kerzenmuster, das wir heute untersuchen werden, wird von den meisten Händlern als Zeichen eines potenziellen Ausbruchs auf dem Markt erkannt. Diese Kerzenmuster deuten häufig auf ein steigendes offenes Interesse und damit auf die Möglichkeit eines starken Ausbruchs auf einer Seite des Marktes hin.

In den meisten unserer Artikel in dieser Serie konzentrieren wir uns auf KI-gestützte Handelsstrategien und technische Indikatoren als wichtigste Signalgeneratoren. Nur selten geben wir Kerzenmustern die Möglichkeit, die Entscheidungsfindung des Algorithmus zu beeinflussen. Es gibt viele Gründe, warum es schwieriger sein kann, Kerzenmuster in Handelsstrategien zu integrieren.

Zum einen ist der durch die Kerzenmuster definierte Raum beträchtlich. Es gibt so viele Kerzenmuster, die existieren können, und jedes von ihnen hat seine eigenen Varianten, in denen sie Gestalt annehmen können. Da die Kerzenmuster nicht immer die gleiche Form haben, ist es ziemlich schwierig, diesen Raum zu durchsuchen und neue Muster zu finden, da dies von Hand geschehen muss. Es ist ein schwer algorithmisch zu durchforstender Raum.

Außerdem können die Muster selbst wiederholt werden, wobei jedes Mal andere Ergebnisse erzielt werden. Daher kann man argumentieren, dass Kerzenmuster nicht robust sind, da jedes Auftreten desselben Musters zu unterschiedlichen Ergebnissen führen kann. Dies ist nicht unbedingt ein Hinweis auf die beabsichtigte Richtung des Marktes.

Die klassische Strategie visualisieren

Damit sind wir bereit, mit der Visualisierung der klassischen Umsetzung der Handelsstrategie zu beginnen. Normalerweise wird eine Engulfing-Kerze dadurch definiert, dass der Eröffnungskurs der Kerze höher ist als der Schlusskurs der vorangegangenen Kerze und das Gegenteil für den Schlusskurs zutrifft. In den meisten Fällen handelt es sich bei einer engulfing candle um ein klassisches Muster aus zwei Kerzen. Er dient als Einstiegssignal und wird in der Regel nicht auf niedrigen Zeitrahmen verwendet. In dem von uns verwendeten Code-Beispiel werden wir die Strategie auf dem täglichen Zeitrahmen implementieren. In Abbildung 1 haben wir zur Veranschaulichung das Muster einer Engulfing-Kerze für das EURUSD-Paar hervorgehoben.

Abbildung 1: Erkennen des klassischen Engulfing-Kerze

Richtig erkannt, folgt auf das Kerzenmuster in der Regel eine starke Preisbewegung in die erwartete Richtung, wie wir in Abbildung 2 für den Leser visualisiert haben. Dies ist der Grund, warum das Muster in Handelskreisen so beliebt ist.

Wie wir jedoch bald sehen werden, ergeben sich bei der Umsetzung des Algorithmus in Code einige Herausforderungen. Wir haben diese klassische Version der Strategie verwendet, um ein grundlegendes Leistungsniveau für unsere Anwendung festzulegen. Nachdem wir dieser klassischen Version der Strategie einige Verfeinerungen hinzugefügt hatten, konnten wir mehr Rauschen aus dem Markt herausfiltern und höhere Rentabilitätsniveaus erzielen, wobei wir weniger Abschlüsse benötigten als die Anzahl der Abschlüsse, die die lautere Version des Musters erforderte.

Abbildung 2: Das Muster erzeugt ein angemessenes Maß an Zuversicht aufgrund seiner früheren Leistungen

In dieser Serie werden wir über 5 einzigartige Kerzenmuster suchen. Aber für heute wollen wir uns zunächst nur auf die Engulfing-Kerzen konzentrieren. Wie bei den meisten unserer Anwendungen beginnen wir mit der Definition von Systemkonstanten, um sicherzustellen, dass wir in beiden Tests die gleiche Losgröße verwenden. 

//+------------------------------------------------------------------+
//|                                        Candle Stick Patterns.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

//+------------------------------------------------------------------+
//| This application attempts to reliably use different candlestick  |
//| patterns. The application will employ the following:             |
//|                                                                  |
//|   1) Engulfing Candle                                            |
//|   2) Momentum Candle                                             |
//|   3) Doji Candle                                                 |
//|   4) Shooting Star Candle                                        |
//|   5) Hammer Candle                                               |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| System constants                                                 |
//+------------------------------------------------------------------+
#define LOT_SIZE SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN)

Importieren Sie die Handelsbibliothek.

//+------------------------------------------------------------------+
//| Trading libraries                                                |
//+------------------------------------------------------------------+
#include  <Trade\Trade.mqh>
CTrade Trade;

Jetzt laden wir die technischen Indikatoren, die wir benötigen. Wir werden den ATR-Indikator verwenden, um Stop-Loss- und Take-Profit-Levels für unsere Anwendung zu definieren.

//+------------------------------------------------------------------+
//| Indicators                                                       |
//+------------------------------------------------------------------+
int atr_handler;
double atr[];

Wie bei den meisten Anwendungen benötigen wir ein paar globale Variablen. Diese werden dafür verantwortlich sein, den Lauf der Zeit und die Veränderungen des Preisniveaus zu verfolgen.

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
MqlDateTime time_stamp,current_time;
double bid,ask;

Bei der ersten Initialisierung der Anwendung werden der Zeitstempel-Parameter und das ATR eingerichtet.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Set the time
   TimeLocal(time_stamp);
   atr_handler = iATR(Symbol(),PERIOD_CURRENT,14);
//---
   return(INIT_SUCCEEDED);
  }

Wenn unsere Anwendung nicht mehr verwendet wird, geben wir den Speicher frei, der zuvor mit dem benötigten Indikator verbunden war.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
IndicatorRelease(atr_handler);
  }

Immer wenn neue Preisdaten eingehen, aktualisiert das System zunächst die aktuelle Uhrzeit und prüft, ob der aktuelle Tag und der gespeicherte Zeitstempel nicht übereinstimmen. Wenn dies der erste Tick seit der Initialisierung ist, spiegelt der Zeitstempel immer noch den Anfangswert wider. Wenn ein neuer Tag erkannt wird, wird der Zeitstempel aktualisiert, gefolgt von einer Aktualisierung der Marktdaten – einschließlich der ATR-Pufferwerte und der aktuellen Geld- und Briefkurse.

Wenn keine offenen Positionen vorhanden sind, sucht der Algorithmus nach dem Engulfing-Kerzenmuster. Typischerweise erstreckt sich dieses Muster über zwei Kerzen – die aktuelle (sich noch bildende) Kerze und die Kerze des Vortages. Dementsprechend werden iOpen und iClose mit 0 bzw. 1 indiziert, um auf die aktuelle bzw. die vorherige Kerze zu verweisen.

Ein „bullish engulfing“ liegt vor, wenn die aktuelle Kerze unter dem Schlusskurs des Vortages eröffnet und der aktuelle Schlusskurs den Eröffnungswert des Vortages übersteigt, sodass eine Kerze entsteht, die die vorherige Kerze vollständig verschlingt. Die umgekehrten Bedingungen definieren das fallendes Setup.

Diese Regeln generieren Einstiegssignale mit Take-Profit-Levels in 1,5-fachen ATR-Intervallen, wobei ein 1:1-Risiko-Ertrags-Verhältnis eingehalten wird.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Update the current time
   TimeLocal(current_time);

//--- Check if a new candle has fully formed
   if(time_stamp.day != current_time.day)
     {
     //--- Update the time
      TimeLocal(time_stamp);
      
      //--- A new candle has formed
      //--- Update the ATR reading
      CopyBuffer(atr_handler,0,0,1,atr);
      ask = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
      bid = SymbolInfoDouble(Symbol(),SYMBOL_BID);
      
      //--- First check if we have no open positions
      if(PositionsTotal() == 0)
        {
         //--- Then check for a trade
         //--- Check for a bullish engulfing candle stick pattern
         if((iOpen(Symbol(),PERIOD_D1,0)<iClose(Symbol(),PERIOD_D1,1)) && (iClose(Symbol(),PERIOD_D1,0)>iOpen(Symbol(),PERIOD_D1,1)))
           {
            //--- Then, enter long positions 
           Trade.Buy(LOT_SIZE,Symbol(),ask,(ask - (atr[0]*1.5)),(ask + (atr[0]*1.5)));
           }

         //--- Otherwise we may check for bearish engulfing candlestick pattern
         if((iOpen(Symbol(),PERIOD_D1,0)>iClose(Symbol(),PERIOD_D1,1)) && (iClose(Symbol(),PERIOD_D1,0)<iOpen(Symbol(),PERIOD_D1,1)))
           {
            //--- Then, enter long positions 
           Trade.Sell(LOT_SIZE,Symbol(),ask,(ask + (atr[0]*1.5)),(ask - (atr[0]*1.5)));
           }
        }
     }
//--- Otherwise, the current candle has not fully formed
  }
//+------------------------------------------------------------------+

Am Ende der Anwendung löschen wir wie immer alle Systemvariablen.

//+------------------------------------------------------------------+
//| System definitions                                               |
//+------------------------------------------------------------------+
#undef LOT_SIZE

Auswahl der Backtest-Tage für unsere Benchmark-Version der Anwendung. Wir werden Daten aus 2 Jahren verwenden, die sich von 2023 bis 2025 erstrecken.

Abbildung 3: Testen der Benchmark-Version des klassischen Kerzenmusters

Die ersten Leistungsindikatoren, die wir erhalten haben, sind ermutigend. Es scheint, dass die Engulfing-Kerzen ein gewisses Maß an Zuverlässigkeit besitzt. In dem 2-Jahres-Zeitraum erwirtschaftete es einen Nettogewinn von insgesamt 127,64 $ (115). Dies wurde mit einer Genauigkeit von 55,7 % erreicht, mit einer gesunden Verteilung von langen und kurzen Einträgen. Wiederkehrende Leser werden sich daran erinnern, wie schwierig es für uns war, solche symmetrischen Handelsverteilungen aus einem statistischen Modell in unserer letzten Diskussion in der vergangenen Woche zu erhalten, der Link ist hier.

Abbildung 4: Die statistischen Ergebnisse, die mit dem klassischen Aufbau erzielt wurden

Die ursprüngliche Version des Kerzenmusters ergab eine Kapitalkurve mit Rentabilitätsniveaus, die solide erscheinen und einen langfristigen Aufwärtstrend aufweisen. Dies gibt uns zusätzliches Vertrauen, dass die Strategie die Mühe wert ist, die es braucht, um sie weiter zu verfeinern.

Abbildung 5: Die von der Benchmark-Strategie erstellte Kapitalkurve weist einen langfristigen Aufwärtstrend auf

Visualisierung der neu konzipierten Strategie

Nach reiflicher Überlegung kamen mir mehrere Verbesserungsmöglichkeiten in den Sinn.

Die erste bestand darin, die beiden Kerzen nicht nur anhand ihres Eröffnungs- und Schlusskurses zu vergleichen, sondern auch anhand der Höchst- und Tiefstwerte ihrer Dochte. Auf diese Weise werden Störungen herausgefiltert und die auffälligeren Kerzen hervorgehoben, d. h. diejenigen, die durch ein ausreichendes Volumen unterstützt werden, um einen Trend oder eine starke Richtungsänderung zu unterstützen.

Die zweite Verbesserung ist eher technischer Natur und bezieht sich auf die Funktionsweise des Backtests auf der MetaTrader 5-Plattform. Bei den Backtests eines Handelsroboters in MetaTrader 5 beginnt die Simulation zu Beginn einer jeden Kerze – um Mitternacht. Infolgedessen wird jede Handelslogik, die von den Eröffnungs-, Hoch-, Tief- und Schlusswerten einer vollständig ausgebildeten Tageskerze abhängt, zu diesem Zeitpunkt unwirksam. Aus der Sicht von MQL5 ist es daher praktischer, das Muster als eine Struktur aus drei Kerzen zu behandeln, bei der jeder neue Tag sowohl auf den Vortag als auch auf den vorherigen Tag verweist.

In der Praxis überprüfen wir zu Wochenbeginn am Montag, ob die Kerze vom Freitag die vom Donnerstag verschlungen hat. Diese Erkenntnis fließt dann in unsere Handelsentscheidungen für den Montag ein, anstatt zu versuchen zu bestimmen, ob die Kerze vom Montag die vom Freitag verschlingt, da sich die Kerze vom Montag bei Markteröffnung noch bildet. Auf der Grundlage dieser Überlegungen haben wir ein verfeinertes Muster entwickelt, das in Abbildung 6 dargestellt ist.

Abbildung 6: Identifizierung der verbesserten Version des Kerzenmusters, nach dem wir jetzt suchen

Die ersten Testergebnisse waren ermutigend und ließen darauf schließen, dass die Strategie vielversprechend ist. Aber wie immer müssen die Daten letztlich für sich selbst sprechen.

Abbildung 7: Die vorläufigen Ergebnisse, die wir mit unserem vorgeschlagenen Kerzenmuster erzielt haben, sind ermutigend

Wir haben die Handelsanwendung entsprechend aktualisiert und die Eingaben so konditioniert, dass Kerzendochte geprüft werden, anstatt sich ausschließlich auf Eröffnungs- und Schlusskurse zu verlassen. Wir haben auch eine bessere Verwendung für den Eröffnungskurs gefunden: Anstatt ihn direkt mit dem Schlusskurs zu vergleichen, haben wir seine Entwicklung über die letzten zwei Tage ausgewertet. Ein steigender Eröffnungskurs während einer Engulfing-Bewegung signalisierte eine Aufwärts-Stimmung, während ein fallender Eröffnungskurs auf eine Abwärts-Stimmung hindeutete.

//--- Then check for a trade
//--- Check for a bullish engulfing candle stick pattern
if((iLow(Symbol(),PERIOD_D1,1)<iLow(Symbol(),PERIOD_D1,2)) && (iHigh(Symbol(),PERIOD_D1,1)>iHigh(Symbol(),PERIOD_D1,2)) && (iOpen(Symbol(),PERIOD_D1,1)>iOpen(Symbol(),PERIOD_D1,2)))
  {
   //--- Then, enter long positions 
  Trade.Buy(LOT_SIZE,Symbol(),ask,(ask - (atr[0]*1.5)),(ask + (atr[0]*1.5)));
  }

//--- Otherwise we may check for bearish engulfing candlestick pattern
if((iLow(Symbol(),PERIOD_D1,1)<iLow(Symbol(),PERIOD_D1,2)) && (iHigh(Symbol(),PERIOD_D1,1)>iHigh(Symbol(),PERIOD_D1,2)) && (iOpen(Symbol(),PERIOD_D1,1)<iOpen(Symbol(),PERIOD_D1,2)))
  {
   //--- Then, enter long positions 
  Trade.Sell(LOT_SIZE,Symbol(),ask,(ask + (atr[0]*1.5)),(ask - (atr[0]*1.5)));
  }

Derr erneute Durchlauf im selben Testfenster führte zu besseren Ergebnissen. 

Abbildung 8: Die verbesserte Version unserer Anwendung ist bereit zum Testen

Der Gesamtnettogewinn stieg von 126 $ auf 160 $, während die Gesamtzahl der Handelsgeschäfte zurückging – ein Beweis für eine effizientere Nutzung des Kapitals. Dies deutet darauf hin, dass die Vorgängerversion ein unnötiges Risiko bei der Erkennung von Engulfing-Kerzen mit sich brachte. Interessanterweise blieb der Anteil profitabler Handelsgeschäfte mit 55 % in etwa gleich, was sinnvoll ist, da beide Strategien Variationen desselben zugrunde liegenden Kerzenkonzepts sind.

Abbildung 9: Die detaillierten Ergebnisse, die wir mit unserer verbesserten Version der Handelsanwendung erzielt haben

Schließlich haben wir bei der Analyse der Kapitalkurve des verbesserten Musters einen klaren Ausbruch zu neuen Höchstständen beobachtet, der mit der ursprünglichen Strategie nie erreicht wurde.

Abbildung 10: Die Kapitalkurve, die sich aus unserer überarbeiteten Version der Handelsstrategie ergibt

Schlussfolgerung

Abschließend hat dieser Artikel gezeigt, wie man die beliebte Engulfing-Kerzen in einer für die MQL5-Plattform besser geeigneten Form effektiv anwenden kann. Es zeigt, dass Kerzenmuster auch in ihrer klassischen Form weiterhin einen praktischen Wert haben und dass sie mit durchdachten Verfeinerungen robuster und kapitaleffizienter werden können.

Wir haben auch gezeigt, wie diese Muster mit dem ATR-Indikator kombiniert werden können, um ein besseres Risikomanagement zu erreichen, da Kerzenformationen allein keine integrierten Risikohinweise bieten. Wir freuen uns darauf, diese Erkundung in unserer nächsten Diskussion fortzusetzen, in der wir das zweite Kerzenmuster in unserer fünfteiligen Serie verbessern werden.

Dateiname	Beschreibung der Datei
Candle Stick Benchmark.mq5	Die Benchmark-Version unserer Anwendung, die wir zur Ermittlung der wichtigsten Leistungsindikatoren entwickelt haben.
Candle Stick Patterns.mq5	Die verbesserte Anwendung, die wir erstellt haben, übertrifft die zuvor erreichten Leistungsniveaus.