Discussão do artigo "Técnicas do MQL5 Wizard que você deve conhecer (Parte 23): CNNs"

[MetaQuotes]

Novo artigo Técnicas do MQL5 Wizard que você deve conhecer (Parte 23): CNNs foi publicado:

As Redes Neurais Convolucionais são outro algoritmo de aprendizado de máquina que tende a se especializar em decompor conjuntos de dados multidimensionais em partes constituintes principais. Vamos ver como isso é normalmente alcançado e explorar uma possível aplicação para traders em outra classe de sinais do MQL5 Wizard.

Continuamos esta série em que analisamos ideias de aprendizado de máquina e estatísticas que podem ser benéficas para os traders, dado o ambiente de testes rápidos e prototipagem fornecido pelo MQL5 Wizard. O objetivo continua sendo abordar uma única ideia em um artigo e, para este, inicialmente pensei que levaria pelo menos 2 artigos. No entanto, parece que conseguimos encaixar tudo em um. Redes Neurais Convolucionais (CNNs), como o nome sugere, processam dados multidimensionais em convoluções graças aos kernels. 

Esses kernels carregam os pesos da rede e, assim como os dados de entrada multidimensionais, geralmente estão em formato de matriz. Eles possuem dimensões menores em comparação com os dados de entrada, e ao iterar sobre a matriz de dados de entrada durante um feed forward, como veremos abaixo, cada iteração essencialmente percorre os dados de entrada. É esse ‘ciclo’ que dá o nome ‘convolucional’. 

Portanto, neste artigo, vamos introduzir os principais passos envolvidos em uma CNN, construir uma classe simples em MQL5 que implemente esses passos, integrar essa classe em uma classe de sinal personalizada do MQL5 Wizard e, por fim, realizar testes com um Expert Advisor montado a partir dessa classe de sinal.

Autor: Stephen Njuki

[Somkait Somsanitungkul]

Cannot Compile porque muitos arquivos foram perdidos, como

//--- trailing disponível

#include <Expert\Trailing\TrailingNone.mqh>

//--- gerenciamento de dinheiro disponível

#include <Expert\Money\MoneyFixedMargin.mqh>

[Stephen Njuki]

Somkait Somsanitungkul gerenciamento de dinheiro disponível

#include <Expert\Money\MoneyFixedMargin.mqh>

Olá

Os arquivos a que você se refere vêm com o MQL5 IDE. Há guias aqui e aqui sobre como usar o assistente.

Obrigado pela leitura.

[Israel Goncalves Moraes De Souza]

2024.08.30 19:02:07.453 2020.01.28 00:00:00:00 índice fora do intervalo em 'SignalWZ_23_.mqh' (191,38)

[Tobias Johannes Zimmer]

Israel Goncalves Moraes De Souza fora do intervalo em 'SignalWZ_23_.mqh' (191,38)

Estou com o mesmo problema. O erro decorre do vetor _c[], que não foi copiado. Assim como _ma[0] representa o preço da última barra de uma média móvel, _c[] representa o preço de fechamento mais recente. Algumas linhas abaixo ele é atualizado, parece que acabou passando despercebido de alguma forma.

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("as entradas são: \n", _inputs);
         CNN.Set(_inputs);
         CNN.Pad();
         //Print("as entradas preenchidas são: \n", CNN.inputs);
         CNN.Convolve();
         CNN.Activate();
         CNN.Pool();
         // metas, já que as eventuais variações de preço em cada matriz servem como indicador de tendência de alta, de baixa ou de oscilações bruscas
         // definindo matrizes para o caso de:
         // grandes variações de preço
         // variações de preço mais baixas
         // variações no preço de fechamento,
         // respectivamente
         //
         // as variações de preço em cada coluna correspondem a mais de 1 barra, 2 barras e 3 barras, respectivamente
         // e as variações de preço em cada linha decorrem de ponderações diferentes do preço aplicado em relação a outros preços aplicados
         // portanto, a máxima é: apenas máximas (H); (máximas + máximas + fechamento)/3 (HHC); e (máximas + fechamento)/3 (HC)
         // enquanto “low” é: apenas mínimas (L); (mínimas + mínimas + fechamento)/3 (LLC); e (mínimas + fechamento)/3 (LC)
         // e o preço de fechamento é: apenas o fechamento (C); (Máximas + Mínimas + Fechamento + Fechamento)/3 (HLCC); e (Máximas + Mínimas + Fechamento)/3 (HLC)
         //
         // as premissas aqui são:
         // valores elevados na banda de alta indicam tendência de alta
         // valores elevados nas mínimas indicam tendência de baixa
         // e uma variação pequena em um período curto sugere um mercado volátil
         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)// picos de “otimismo”
                 {
                  _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 o “sentimento de baixa”
                    {
                     _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)// fechar para evitar “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("Os alvos para: " + IntegerToString(i) + " são: \n", _targets[i]);
           }
         CNN.Get(_targets);
         CNN.Evolve(m_learning_rate);
        }
     } // Fim do ciclo “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));
  }

Substitua este método

[Stephen Njuki]

Por favor, veja o anexo com o código depurado.