Discusión sobre el artículo "Características del Wizard MQL5 que debe conocer (Parte 23): Redes neuronales convolucionales (CNNs, Convolutional Neural Networks)"

[MetaQuotes]

Artículo publicado Características del Wizard MQL5 que debe conocer (Parte 23): Redes neuronales convolucionales (CNNs, Convolutional Neural Networks):

Las redes neuronales convolucionales son otro algoritmo de aprendizaje automático que tiende a especializarse en descomponer conjuntos de datos multidimensionales en partes constituyentes clave. Examinamos cómo se consigue esto normalmente y exploramos una posible aplicación para los operadores en otra clase de señal del asistente MQL5.

Continuamos con esta serie en la que analizamos ideas de aprendizaje automático y estadística que podrían ser beneficiosas para los traders dado el rápido entorno de pruebas y creación de prototipos que ofrece el asistente MQL5. El objetivo sigue siendo ver una sola idea dentro de un artículo y para esta pieza, inicialmente había pensado que esto tomaría al menos 2 artículos, sin embargo parece que somos capaces de exprimirlo en uno. Las redes neuronales convolucionales (CNNs, Convolutional Neural Networks), como su nombre indica, procesan datos multidimensionados en convoluciones gracias a los núcleos. 

Estos núcleos contienen los pesos de la red y, al igual que los datos de entrada multidimensionales, suelen estar en formato de matriz. Tienen dimensiones totales más pequeñas en comparación con los datos de entrada y, al iterar sobre la matriz de datos de entrada durante un avance, como veremos más adelante, cada iteración recorre esencialmente los datos de entrada. Es este «ciclo» el que le da el nombre de «convolucional». 

Así que para este artículo vamos a tener una introducción a los pasos clave que intervienen en una CNN, construir una simple clase MQL5 que implementa estos pasos, integrar esta clase en una clase de señal personalizada MQL5 asistente, y, finalmente, realizar ejecuciones de prueba con un Asesor Experto que se ensambla a partir de esta clase de señal.

Autor: Stephen Njuki

[Somkait Somsanitungkul]

No se puede compilar porque muchos archivos pierden. tales como

//--- trailing disponible

#include <Expert\Trailing\TrailingNone.mqh>

//--- gestión de dinero disponible

#include <Expert\Money\MoneyFixedMargin.mqh>

[Stephen Njuki]

Somkait Somsanitungkul gestión de dinero disponible

#include <Expert\Money\MoneyFixedMargin.mqh>

Hola

Los archivos a los que te refieres vienen con MQL5 IDE. Hay guías aquí y aquí sobre cómo usar el asistente.

Gracias por leernos.

[Israel Goncalves Moraes De Souza]

2024.08.30 19:02:07.453 2020.01.28 00:00:00 índice fuera de rango en 'SignalWZ_23_.mqh' (191,38)

[Tobias Johannes Zimmer]

Israel Goncalves Moraes De Souza fuera de rango en «SignalWZ_23_.mqh» (191,38)

A mí me pasa lo mismo. El error se debe a que el vector _c[] no se ha copiado. Al igual que _ma[0] representa el precio de la última barra de una media móvil, _c[] representa el último precio de cierre. Unas líneas más abajo se actualiza, pero parece que se ha saltado de alguna manera.

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("Las entradas son: \n", _inputs);
         CNN.Set(_inputs);
         CNN.Pad();
         //Print("las entradas rellenadas son: \n", CNN.inputs);
         CNN.Convolve();
         CNN.Activate();
         CNN.Pool();
         // objetivos, ya que los cambios de precio que puedan producirse con cada matriz sirven como indicador de tendencia alcista, bajista o de movimientos bruscos
         // lo que implica matrices para el caso eventual:
         // grandes variaciones de precios
         // cambios en los precios bajos
         // variaciones del precio de cierre,
         // respectivamente
         //
         // Las variaciones de precio en cada columna corresponden a 1 barra, 2 barras y 3 barras, respectivamente.
         // y las variaciones de precio en cada fila se deben a diferentes ponderaciones del precio aplicado con respecto a otros precios aplicados
         // así pues, el máximo es: solo máximos (H); (máximos + máximos + cierre)/3 (HHC); y (máximos + cierre)/3 (HC)
         // mientras que «low» es: solo mínimos (L); (mínimos + mínimos + cierre)/3 (LLC); y (mínimos + cierre)/3 (LC)
         // y el cierre es: solo el cierre (C); (máximos + mínimos + cierre + cierre)/3 (HLCC); y (máximos + mínimos + cierre)/3 (HLC)
         //
         // Las hipótesis en este caso son:
         // Los valores elevados en los máximos indican una tendencia alcista
         // Los valores elevados en los mínimos indican una tendencia bajista
         // y una amplitud reducida en un mercado muy ajustado indican un mercado con fuertes oscilaciones
         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)// máximos de «optimismo»
                 {
                  _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)// mínimos para la «tendencia bajista»
                    {
                     _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)// cierre por «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("Los objetivos para: " + IntegerToString(i) + " son: \n", _targets[i]);
           }
         CNN.Get(_targets);
         CNN.Evolve(m_learning_rate);
        }
     } // Fin del bucle «for»

   _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));
  }

Sustituye este método

[Stephen Njuki]

Tobias Johannes Zimmer #:

A mí me pasa lo mismo. El error se debe a que el vector _c[] no se copia. Al igual que _ma[0] representa el último precio de barra de una media móvil, _c[] representa el último precio de cierre. Unas líneas más abajo se actualiza, pero parece que se ha saltado de alguna manera.

Sustituye este método

Consulte el archivo adjunto corregido.

[Stephen Njuki]

Por favor, consulta el archivo adjunto depurado.