Diskussion zum Artikel "MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 23): CNNs"

[MetaQuotes]

Neuer Artikel MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 23): CNNs :

Convolutional Neural Networks sind ein weiterer Algorithmus des maschinellen Lernens, der sich darauf spezialisiert hat, mehrdimensionale Datensätze in ihre wichtigsten Bestandteile zu zerlegen. Wir sehen uns an, wie dies typischerweise erreicht wird, und untersuchen eine mögliche Anwendung für Händler in einer anderen Signalklasse des MQL5-Assistenten.

Wir setzen diese Serie fort, in der wir Ideen zum maschinellen Lernen und zur Statistik betrachten, die für Händler angesichts der schnellen Test- und Prototyping-Umgebung, die der MQL5-Assistent bietet, von Nutzen sein könnten. Das Ziel ist nach wie vor, eine einzige Idee in einem Artikel zu behandeln, und für diesen Beitrag hatte ich ursprünglich gedacht, dass dafür mindestens 2 Artikel nötig wären, aber es scheint, dass wir es in einen einzigen quetschen können. Convolutional Neural Networks (CNNs) verarbeiten, wie der Name schon sagt, mehrdimensionale Daten mit Hilfe von Kerneln in Form von Faltungen. 

Diese Kernel enthalten die Netzgewichte und liegen wie die mehrdimensionalen Eingabedaten in der Regel im Matrixformat vor. Sie haben im Vergleich zu den Eingabedaten eine geringere Gesamtgröße, und durch die Iteration über die Eingabedatenmatrix während eines Vorwärtsdurchgangs, wie wir weiter unten sehen werden, durchläuft jede Iteration im Wesentlichen die Eingabedaten. Dieser „Zyklus“ ist der Grund für die Bezeichnung „convolutional“ (Faltung). 

In diesem Artikel werden wir eine Einführung in die wichtigsten Schritte eines CNN geben, eine einfache MQL5-Klasse erstellen, die diese Schritte implementiert, diese Klasse in eine nutzerdefinierte MQL5-Assistenten-Signalklasse integrieren und schließlich Testläufe mit einem Expert Advisor durchführen, der aus dieser Signalklasse zusammengestellt wurde.

Autor: Stephen Njuki

[Somkait Somsanitungkul]

Kann nicht kompiliert werden , da viele Dateien verloren gehen, wie z.B.

//--- available trailing

#include <Expert\Trailing\TrailingNone.mqh>

//--- verfügbare Geldverwaltung

#include <Expert\Money\MoneyFixedMargin.mqh>

[Stephen Njuki]

Somkait Somsanitungkul Geldverwaltung

#include <Expert\Money\MoneyFixedMargin.mqh>

Hallo

Die Dateien, auf die Sie sich beziehen, werden mit MQL5 IDE geliefert. Es gibt Anleitungen hier und hier, wie man den Assistenten verwendet.

Vielen Dank für die Lektüre.

[Israel Goncalves Moraes De Souza]

2024.08.30 19:02:07.453 2020.01.28 00:00:00 index out of range in 'SignalWZ_23_.mqh' (191,38)

[Tobias Johannes Zimmer]

Israel Goncalves Moraes De Souza außerhalb des zulässigen Bereichs in „SignalWZ_23_.mqh“ (191,38)

Das habe ich auch. Der Fehler rührt von dem Vektor _c[] her, der nicht kopiert wurde. Genauso wie _ma[0] für den aktuellen Balkenkurs eines gleitenden Durchschnitts steht, steht _c[] für den aktuellen Schlusskurs. Ein paar Zeilen weiter unten wird er aktualisiert, anscheinend ist das irgendwie übersehen worden.

double CSignalCNN::GetOutput()
  {
   int _index = 5;
   matrix _inputs;
   vector _ma, _h, _l, _c;
   _inputs.Init(m_input_size, m_input_size);
   for(int g = 0; g < m_epochs; g++)
     {
      for(int h = m_train_set - 1; h >= 0; h--)
        {
         _inputs.Fill(0.0);
         _index = 0;
         for(int i = 0; i < m_input_size; i++)
           {
            for(int j = 0; j < m_input_size; j++)
              {
               if(_ma.CopyIndicatorBuffer(m_ma[_index].Handle(), 0, h, __KERNEL + 1)
                  && _h.CopyRates(m_symbol.Name(), m_period, 2, h, __KERNEL + 1)
                  && _l.CopyRates(m_symbol.Name(), m_period, 4, h, __KERNEL + 1)
                  && _c.CopyRates(m_symbol.Name(), m_period, 8, h, __KERNEL + 1))
                 {
                  _inputs[i][j] = _c[0] - _ma[0];
                  _index++;
                 }
              }
           }
         //

         //Print(" Die Eingaben lauten: \n", _inputs);
         CNN.Set(_inputs);
         CNN.Pad();
         //Print("Die aufgefüllten Eingaben lauten: \n", CNN.inputs);
         CNN.Convolve();
         CNN.Activate();
         CNN.Pool();
         // Zielwerte, da die jeweiligen Preisänderungen bei jeder Matrix als Indikator für eine bullische, bärische oder schwankende Entwicklung dienen
         // impliziert Matrizen für „eventuell“:
         // starke Preisänderungen
         // Geringe Preisänderungen
         // Veränderungen des Schlusskurses,
         // bzw.
         //
         // Die Preisänderungen in den einzelnen Spalten beziehen sich jeweils auf 1, 2 bzw. 3 Balken.
         // & Preisänderungen in jeder Zeile ergeben sich aus unterschiedlichen Gewichtungen des angewandten Preises im Vergleich zu anderen angewandten Preisen
         // „So hoch“ bedeutet: nur Höchststände (H); (Höchststände + Höchststände + Schlusskurs)/3 (HHC); und (Höchststände + Schlusskurs)/3 (HC)
         // Dabei gilt für „low“: nur Tiefststände (L); (Tiefststände + Tiefststände + Schlusskurs)/3 (LLC); und (Tiefststände + Schlusskurs)/3 (LC)
         // und der Schlusskurs lautet: nur Schlusskurs (C); (Höchstkurse + Tiefstkurse + Schlusskurs + Schlusskurs)/3 (HLCC); und (Höchstkurse + Tiefstkurse + Schlusskurs)/3 (HLC)
         //
         // Die Annahmen lauten hier wie folgt:
         // Hohe Werte im Bereich „Highs“ deuten auf eine bullische Stimmung hin
         // Hohe Werte bei den Tiefstständen deuten auf eine rückläufige Tendenz hin
         // und geringe Volatilität bei engen Kursspannen deuten auf einen Whipsaw-Markt hin
         matrix _targets[];
         ArrayResize(_targets, __KERNEL_SIZES.Size());
         for(int i = 0; i < int(__KERNEL_SIZES.Size()); i++)
           {
            _targets[i].Init(__KERNEL_SIZES[i], __KERNEL_SIZES[i]);
            //
            for(int j = 0; j < __KERNEL_SIZES[i]; j++)
              {
               if(i == 0)// Höchstwerte für „Hausse-Stimmung“
                 {
                  _targets[i][j][0] = _h[j] - _h[j + 1];
                  _targets[i][j][1] = ((_h[j] + _h[j] + _c[j]) / 3.0) - ((_h[j + 1] + _h[j + 1] + _c[j + 1]) / 3.0);
                  _targets[i][j][2] = ((_h[j] + _c[j]) / 2.0) - ((_h[j + 1] + _c[j + 1]) / 2.0);
                 }
               else
                  if(i == 1)// Tiefststände für „Bärenstimmung“
                    {
                     _targets[i][j][0] = _l[j] - _l[j + 1];
                     _targets[i][j][1] = ((_l[j] + _l[j] + _c[j]) / 3.0) - ((_l[j + 1] + _l[j + 1] + _c[j + 1]) / 3.0);
                     _targets[i][j][2] = ((_l[j] + _c[j]) / 2.0) - ((_l[j + 1] + _c[j + 1]) / 2.0);
                    }
                  else
                     if(i == 2)// Schließen wegen „Whipsaw“
                       {
                        _targets[i][j][0] = _c[j] - _c[j + 1];
                        _targets[i][j][1] = ((_h[j] + _l[j] + _c[j] + _c[j]) / 3.0) - ((_h[j + 1] + _l[j + 1] + _c[j + 1] + _c[j + 1]) / 3.0);
                        _targets[i][j][2] = ((_h[j] + _l[j] + _c[j]) / 2.0) - ((_h[j + 1] + _l[j + 1] + _c[j + 1]) / 2.0);
                       }
              }
            //
            //Print(" Ziele für: " + IntegerToString(i) + " sind: \n", _targets[i]);
           }
         CNN.Get(_targets);
         CNN.Evolve(m_learning_rate);
        }
     } // Ende der for-Schleife

   _index = 0;
   _h.CopyRates(m_symbol.Name(), m_period, 2, 0, __KERNEL + 1);
   _l.CopyRates(m_symbol.Name(), m_period, 4, 0, __KERNEL + 1);
   _c.CopyRates(m_symbol.Name(), m_period, 8, 0, __KERNEL + 1);
   for(int i = 0; i < m_input_size; i++)
     {
      for(int j = 0; j < m_input_size; j++)
        {
         if(_ma.CopyIndicatorBuffer(m_ma[_index].Handle(), 0, 0, __KERNEL + 1))
           {
            _inputs[i][j] = _c[__KERNEL] - _ma[__KERNEL];
            _index++;
           }
        }
     }
   CNN.Set(_inputs);
   CNN.Pad();
   CNN.Convolve();
   CNN.Activate();
   CNN.Pool();
   double _long = 0.0, _short = 0.0;
   if(CNN.output[0].Median() > 0.0)
     {
      _long = fabs(CNN.output[0].Median());
     }
   if(CNN.output[1].Median() < 0.0)
     {
      _short = fabs(CNN.output[1].Median());
     }
   double _neutral = fabs(CNN.output[2].Median());
   if(_long + _short + _neutral == 0.0)
     {
      return(0.0);
     }
   return((_long - _short) / (_long + _short + _neutral));
  }

Ersetze diese Methode

[Stephen Njuki]

Tobias Johannes Zimmer #:

Das habe ich auch. Der Fehler rührt von dem Vektor _c[] her, der nicht kopiert wurde. Genauso wie _ma[0] für den aktuellen Bar-Kurs eines gleitenden Durchschnitts steht, steht _c[] für den aktuellen Schlusskurs. Ein paar Zeilen weiter unten wird er aktualisiert, anscheinend ist das irgendwie übersehen worden.

Ersetze diese Methode

Bitte beachten Sie den korrigierten Anhang.

[Stephen Njuki]

Siehe bitte den Anhang mit den Debugging-Ergebnissen.