MetaTrader 5 / Sistemas de negociação
English Русский 中文 Español Deutsch 日本語
preview
Experimentos com redes neurais (Parte 4): Padrões

Experimentos com redes neurais (Parte 4): Padrões

MetaTrader 5 — Sistemas de negociação | 20 junho 2023, 09:31
287 0
Roman Poshtar
Roman Poshtar

Introdução

Boa tarde, caros usuários da comunidade MQL5. Gostaria de poder compartilhar com vocês com mais frequência, mas, como podem imaginar, isso requer tempo e recursos de informática que, infelizmente, são muito escassos em comparação com as tarefas que tenho em mãos.

Nos artigos anteriores (Parte 1, Parte 2, Parte 3) experimentamos com formas e ângulos de inclinação, cujos valores foram transmitidos para o perceptron e a rede neural construída com base na biblioteca DeepNeuralNetwork.mqh.  Também realizamos experimentos sobre métodos de otimização no testador de estratégias. Para ser honesto, não fiquei completamente satisfeito com os resultados do trabalho das redes neurais que utilizaram a biblioteca DeepNeuralNetwork.mqh, assim como com a operação lenta do astuto algoritmo de otimização que descrevi na terceira parte. Os resultados em um simples perceptron acabaram por ser melhores do que em uma rede neural. Talvez estejamos a fornecer dados inadequados para a rede neural para tais tarefas, cujo intervalo de dispersão não pode conduzir a um resultado estável.  Além disso, nos comentários aos artigos anteriores, notei críticas sobre a proporção entre o TakeProfit e o StopLoss. Bem, todos os desejos serão considerados nos próximos experimentos.

Em minhas buscas, deparei-me com um algoritmo de rastreamento de padrões interessante em nosso fórum MQL5 favorito. A sua essência residia na adaptação do preço a um determinado padrão para determinar a entrada em uma posição, e não se referia ao seu uso em redes neurais.

Denominei esta "tecnologia" de padrões. Não sei se é apropriado ou não, mas me pareceu a palavra mais adequada.

Uma tarefa relevante nos experimentos de hoje foi monitorar a influência da quantidade de dados transmitidos e a profundidade do histórico de onde extraímos esses dados. Outra tarefa foi revelar padrões, sejam melhores os padrões curtos ou mais longos, e usar menos ou mais parâmetros para a transmissão.

Atualmente, estou escrevendo esta introdução e, sinceramente, não sei a qual resultado chegaremos no final. Gostaria de percorrer todo esse caminho junto com vocês, meus leitores. Bem, a ideia existe, e a tarefa está definida, é hora de começar. Como já se tornou tradição, utilizamos apenas os recursos do MetaTrader 5, sem a utilização de softwares de terceiros. Este artigo provavelmente se assemelhará a um tutorial passo a passo. Da minha parte, tentarei explicar tudo da forma mais clara e simples possível.

Temos muito trabalho pela frente, vamos começar!


1. Par de moedas, alcance da otimização e testes forward, bem como opções

Aqui vou dar todos os parâmetros para otimização e teste para que não se repitam no texto:

  • Mercado Forex;
  • Par de moedas EURUSD;
  • Período H1;
  • Padrões: Leque, Paralelogramo, Triângulo;
  • StopLoss e TakeProfit para as modificações correspondentes 600 e 60, 200 e 230 para equilíbrio, levando em conta o spread; adicionamos 30 pips acima de cinco dígitos ao TakeProfit, 200 e 430 TakeProfit duas vezes maior que o Stop Loss, 30 pips acima de cinco dígitos ao TakeProfit para equilíbrio;
  • Modo de otimização e teste "Somente preços de abertura" e "Máximo de critério complexo". É muito importante usar o modo "Máximo critério complexo", já que mostrou resultados mais estáveis e lucrativos em comparação com "Máxima lucratividade";
  • Faixa de otimização de 3 anos. De 18.02.2019 a 18.02.2022. 3 anos não é critério nenhum. Você pode tentar mais ou menos sozinho;
  • Intervalo de teste forward de 1 ano. De 18.02.2022 a 18.02.2023. Verificamos tudo com base no algoritmo descrito no meu artigo (Experimentos com redes neurais (Parte 3): Uso pratico). Ou seja, negociação simultânea de vários melhores resultados de otimização;
  • Vamos agora realizar a otimização 20 vezes. Aumentamos em 2 vezes em comparação com os testes anteriores e vemos os resultados. 
  • 40 resultados de otimização foram usados ​​simultaneamente em todos os testes forward. Em relação aos testes anteriores em meus artigos, o valor é aumentado em um fator de 2;
  • Otimização de Expert Advisors com perceptron "(algoritmo genético) rápido";
  • Otimização de Expert Advisors na biblioteca DeepNeuralNetwork.mqh "(algoritmo genético) rápido". Devido à otimização lenta do algoritmo discutido na (Parte 2), decidi otimizar usando o MetaTrader 5 diretamente;
  • Depósito inicial 10.000 unidades;
  • Alavancagem 1:500.

Quase esqueci de contar como otimizo 20, 40 ou mais vezes no modo "(algoritmo genético) rápido". Para fazer isso, eu uso um pequeno autoclicker, um programa que escrevi em Delphi. Não posso publicá-lo aqui, mas enviarei a quem precisar em mensagens privadas se me escrever. Ele funciona assim:

  1. Inserimos o número necessário de otimizações.
  2. Movemos o cursor sobre o botão “Iniciar” no otimizador de estratégia.
  3. Tratamos dos nossos assuntos.

A otimização termina após os ciclos especificados e o programa é fechado. O autoclicker responde à mudança na cor do botão “Iniciar”. Abaixo está uma captura de tela do programa. 

Autoclicker


2. Padrões

O leque é uma construção semelhante a um "padrão flutuante". Seus valores estão constantemente mudando dependendo da situação do mercado, mas cada um deles está dentro de um determinado intervalo, que é o que precisamos para nossos experimentos. Como já sabemos, os dados que transmitimos para a rede neural devem estar dentro de um intervalo específico. O valor no leque é arredondado para um número inteiro para simplificar e melhorar a compreensão do perceptron e da rede neural. Dessa forma, obtemos mais situações para condições de ativação e menos carga no perceptron e na rede neural. Na captura de tela abaixo, você pode ver o primeiro dos padrões que me veio à mente. Eu o chamei de "leque", pois a semelhança é óbvia. Neste artigo, não usaremos indicadores, estaremos trabalhando com velas.

Abaixo estão exemplos que utilizam o zoom do histórico, permitindo-nos analisar um histórico mais curto ou mais profundo.

Não é um requisito usar um número igual de velas nos modelos, o que proporciona um campo adicional para refletir sobre a relevância dos valores anteriores dos preços. No nosso caso, estamos usando os preços de fechamento das velas.

É importante entender que nos exemplos usando a biblioteca DeepNeuralNetwork.mqh para 24 velas, utilizamos diferentes bibliotecas que foram descritas nos artigos anteriores. Com diferentes configurações de entrada. Ou seja, 4 e 8 parâmetros para a entrada da rede neural. Mas não se preocupe com isso, no anexo, adicionei os Expert Advisors e as bibliotecas necessárias.

2.1 O padrão é um leque de quatro valores, estendido por 24 velas. No período H1, equivale a um dia. 

Leque 4 24

E assim descreveremos o que transmitiremos para o perceptron e a rede neural, a fim de obter uma compreensão mais clara:

  1. Distância arredondada em pontos do ponto 1 ao ponto 2;
  2. Distância arredondada em pontos do ponto 1 ao ponto 3;
  3. Distância arredondada em pontos do ponto 1 ao ponto 4;
  4. Distância arredondada em pontos do ponto 1 ao ponto 5;

E assim seria apresentado no código para EAs do perceptron: 

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   a1 = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point()));
   a2 = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   a3 = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point()));
   a4 = (int)(a4/100)*100;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Assim é como seria apresentado no código para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point()));
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point()));
   xInputs[3] = (int)(a4/100)*100;  
   
   return(1);

  }

2.2 O padrão é um leque de oito valores, estendido por 24 velas. No período H1, equivale a um dia.

Padrão 8 24

 

 

O que transmitimos para o perceptron e a rede neural, para obter uma compreensão mais clara:

  1. Distância arredondada em pontos do ponto 1 ao ponto 2;
  2. Distância arredondada em pontos do ponto 1 ao ponto 3;
  3. Distância arredondada em pontos do ponto 1 ao ponto 4;
  4. Distância arredondada em pontos do ponto 1 ao ponto 5;
  5. Distância arredondada em pontos do ponto 1 ao ponto 6;
  6. Distância arredondada em pontos do ponto 1 ao ponto 7;
  7. Distância arredondada em pontos do ponto 1 ao ponto 8;
  8. Distância arredondada em pontos do ponto 1 ao ponto 9;

E assim seria apresentado no código para EAs do perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   double v1 = y1 - 10.0;
   double v2 = y2 - 10.0;
   double v3 = y3 - 10.0;
   double v4 = y4 - 10.0;
   
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   a1 = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,4))/Point()));
   a2 = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point()));
   a3 = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,10))/Point()));
   a4 = (int)(a4/100)*100;
   
   int b1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   b1 = (int)(b1/100)*100;
   int b2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,16))/Point()));
   b2 = (int)(b2/100)*100;
   int b3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point()));
   b3 = (int)(b3/100)*100;
   int b4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,22))/Point()));
   b4 = (int)(b4/100)*100;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   v1 * b1 + v2 * b2 + v3 * b3 + v4 * b4);
  }

E como isso será representado no código para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,4))/Point()));
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point()));
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,10))/Point()));
   xInputs[3] = (int)(a4/100)*100;
   
   int g1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   xInputs[4] = (int)(g1/100)*100;
   int g2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,16))/Point()));
   xInputs[5] = (int)(g2/100)*100;
   int g3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point()));
   xInputs[6] = (int)(g3/100)*100;
   int g4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,22))/Point()));
   xInputs[7] = (int)(g4/100)*100;
   
   return(1);

  }

2.3 O padrão é um leque de quatro valores, estendido por 48 velas. No período H1, equivale a dois dias.

Leque 48

Então, descrevamos o que é o quê, para uma melhor compreensão:

  1. Distância arredondada em pontos do ponto 1 ao ponto 2;
  2. Distância arredondada em pontos do ponto 1 ao ponto 3;
  3. Distância arredondada em pontos do ponto 1 ao ponto 4;
  4. Distância arredondada em pontos do ponto 1 ao ponto 5;

Assim seria representado no código para EAs do perceptron. Aqui temos o exemplo anterior, estendido no tempo por 2 dias:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   a1 = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   a2 = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point()));
   a3 = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point()));
   a4 = (int)(a4/100)*100;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Assim seria apresentado no código da nossa biblioteca DeepNeuralNetwork.mqh. Aqui temos o exemplo anterior, estendido no tempo por 2 dias: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point()));
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point()));
   xInputs[3] = (int)(a4/100)*100;  
   
   return(1);

  }

2.4 O padrão é um leque de oito valores, estendido por 48 velas. No período H1, equivale a dois dias.

Leque 8 48

O que transmitimos para o perceptron e a rede neural, para obter uma compreensão mais clara, os pontos de referência foram deslocados um número igual de velas:

  1. Distância arredondada em pontos do ponto 1 ao ponto 2;
  2. Distância arredondada em pontos do ponto 1 ao ponto 3;
  3. Distância arredondada em pontos do ponto 1 ao ponto 4;
  4. Distância arredondada em pontos do ponto 1 ao ponto 5;
  5. Distância arredondada em pontos do ponto 1 ao ponto 6;
  6. Distância arredondada em pontos do ponto 1 ao ponto 7;
  7. Distância arredondada em pontos do ponto 1 ao ponto 8;
  8. Distância arredondada em pontos do ponto 1 ao ponto 9;

Código nos EAs no perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   double v1 = y1 - 10.0;
   double v2 = y2 - 10.0;
   double v3 = y3 - 10.0;
   double v4 = y4 - 10.0;
   
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   a1 = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point()));
   a2 = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   a3 = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point()));
   a4 = (int)(a4/100)*100;
   
   int b1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point()));
   b1 = (int)(b1/100)*100;
   int b2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,31))/Point()));
   b2 = (int)(b2/100)*100;
   int b3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point()));
   b3 = (int)(b3/100)*100;
   int b4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,43))/Point()));
   b4 = (int)(b4/100)*100;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   v1 * b1 + v2 * b2 + v3 * b3 + v4 * b4);
  }

Código nos EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point()));
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point()));
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point()));
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point()));
   xInputs[3] = (int)(a4/100)*100;
   
   int g1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point()));
   xInputs[4] = (int)(g1/100)*100;
   int g2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,31))/Point()));
   xInputs[5] = (int)(g2/100)*100;
   int g3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point()));
   xInputs[6] = (int)(g3/100)*100;
   int g4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,43))/Point()));
   xInputs[7] = (int)(g4/100)*100;
   
   return(1);

  }

2.5 O padrão é um paralelogramo de quatro valores, estendido por 24 velas. Essa é uma estrutura mais complexa para a transferência de parâmetros. No período H1, equivale a um dia.

Paralelogramo

Abaixo está uma descrição de que valores devemos transmitir:

  1. Do ponto 10 ao ponto 2, no meu caso, adicionamos 800 pips para cinco dígitos;
  2. Do ponto 10 ao ponto 1, subtraímos 800 pips;
  3. Do ponto 9 ao ponto 3, adicionamos 800 pips;
  4. Do ponto 9 ao ponto 4, subtraímos 800 pips;
  5. Valor arredondado do ponto 8 ao ponto 9 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 3);
  6. Valor arredondado do ponto 3 ao ponto 7;
  7. Valor arredondado do ponto 2 ao ponto 6;
  8. Valor arredondado do ponto 1 ao ponto 5;

Código nos EAs no perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,7)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point());
   a4 = (int)(a4/100)*100;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Código nos EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,7)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point());
   xInputs[3] = (int)(a4/100)*100;
   
   return(1);

  }

2.6 O padrão é um paralelogramo de quatro valores, estendido por 48 velas. Maior alcance ao longo do tempo. No período H1, equivale a dois dias.

Paralelogramo

Abaixo está uma descrição de que valores devemos transmitir:

  1. Do ponto 10 ao ponto 2, no meu caso, adicionamos 1200 pips para cinco dígitos. Aumentei o valor em pips, já que o preço pode variar consideravelmente ao longo de dois dias Dessa forma, não vamos comprometer nosso projeto;
  2. Do ponto 10 ao ponto 1, subtraímos 1200 pips;
  3. Do ponto 9 ao ponto 3, adicionamos 1200 pips;
  4. Do ponto 9 ao ponto 4, subtraímos 1200 pips;
  5. Valor arredondado do ponto 8 ao ponto 9 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 3);
  6. Valor arredondado do ponto 3 ao ponto 7;
  7. Valor arredondado do ponto 2 ao ponto 6;
  8. Valor arredondado do ponto 1 ao ponto 5;

Código nos EAs no perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,13)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point());
   a4 = (int)(a4/100)*100;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Código nos EAs baseados na biblioteca DeepNeuralNetwork.mqh:

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,13)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point());
   xInputs[3] = (int)(a4/100)*100;
   
   return(1);

  }

2.7 O padrão é um paralelogramo de quatro valores, estendido por 24 velas. No período H1, equivale a um dia.

Paralelogramo

Abaixo está uma descrição de que valores devemos transmitir:

  1. Do ponto 9, somamos no meu caso 800 pips para cinco dígitos e obtemos o ponto 3;
  2. Subtraímos 800 pips do ponto 9 e obtemos o ponto 4;
  3. Do ponto 12 ao ponto 2, adicionamos 800 pips;
  4. Do ponto 12 ao ponto 1, subtraímos 800 pips;
  5. Valor arredondado do ponto 8 ao ponto 9 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 3);
  6. Valor arredondado do ponto 7 ao ponto 3;
  7. Valor arredondado do ponto 13 ao ponto 4;
  8. Valor arredondado do ponto 6 ao ponto 3;
  9. Valor arredondado do ponto 2 ao ponto 6;
  10. Valor arredondado do ponto 2 ao ponto 10;
  11. Valor arredondado do ponto 12 ao ponto 11 (o ponto 1 é encontrado como a diferença entre os pontos 4 e 1);
  12. Valor arredondado do ponto 1 ao ponto 5;

Código nos EAs no perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   double v1 = y1 - 10.0;
   double v2 = y2 - 10.0;
   double v3 = y3 - 10.0;
   double v4 = y4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,5)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,9)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,13)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())))/Point());
   a4 = (int)(a4/100)*100;

   int b1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   b1 = (int)(b1/100)*100;
   int b2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,17))/Point());
   b2 = (int)(b2/100)*100;
   int b3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,21))/Point());
   b3 = (int)(b3/100)*100;
   int b4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,24)-(800*Point()))/2))/Point()) ;
   b4 = (int)(b4/100)*100;

   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   v1 * b1 + v2 * b2 + v3 * b3 + v4 * b4);
  }

Assim seria apresentado no código para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,5)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,9)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,13)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())))/Point());
   xInputs[3] = (int)(a4/100)*100;

   int g1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   xInputs[4] = (int)(g1/100)*100;
   int g2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)+(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,17))/Point());
   xInputs[5] = (int)(g2/100)*100;
   int g3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-(800*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,21))/Point());
   xInputs[6] = (int)(g3/100)*100;
   int b4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,24)-(800*Point()))/2))/Point()) ;
   xInputs[7] = (int)(g4/100)*100;
   
   return(1);

  }

2.8 O padrão é um paralelogramo de quatro valores, estendido por 48 velas para cobrir mais o histórico. No período H1, equivale a dois dias.

Paralelogramo

Abaixo está uma descrição de que valores devemos transmitir:

  1. Do ponto 9, somamos no meu caso 1200 pips para cinco dígitos e obtemos o ponto 3;
  2. Subtraímos 1200 pips do ponto 9 e obtemos o ponto 4;
  3. Do ponto 12 ao ponto 2, adicionamos 1200 pips;
  4. Do ponto 12 ao ponto 1, subtraímos 1200 pips;
  5. Valor arredondado do ponto 8 ao ponto 9 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 3);
  6. Valor arredondado do ponto 7 ao ponto 3;
  7. Valor arredondado do ponto 13 ao ponto 4;
  8. Valor arredondado do ponto 6 ao ponto 3;
  9. Valor arredondado do ponto 2 ao ponto 6;
  10. Valor arredondado do ponto 2 ao ponto 10;
  11. Valor arredondado do ponto 12 ao ponto 11 (o ponto 1 é encontrado como a diferença entre os pontos 4 e 1);
  12. Valor arredondado do ponto 1 ao ponto 5;

Código nos EAs no perceptron: 

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   double v1 = y1 - 10.0;
   double v2 = y2 - 10.0;
   double v3 = y3 - 10.0;
   double v4 = y4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,9)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,17)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,25)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())))/Point());
   a4 = (int)(a4/100)*100;

   int b1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   b1 = (int)(b1/100)*100;
   int b2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,33))/Point());
   b2 = (int)(b2/100)*100;
   int b3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,41))/Point());
   b3 = (int)(b3/100)*100;
   int b4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,48)-(1200*Point()))/2))/Point()) ;
   b4 = (int)(b4/100)*100;

   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   v1 * b1 + v2 * b2 + v3 * b3 + v4 * b4);
  }

Código para EAs baseados na biblioteca DeepNeuralNetwork.mqh:

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,9)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())))/Point());
   xInputs[0] = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,17)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())))/Point());
   xInputs[0] = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,25)-(iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())))/Point());
   xInputs[0] = (int)(a4/100)*100;

   int g1 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   xInputs[0] = (int)(g1/100)*100;
   int g2 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)+(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,33))/Point());
   xInputs[0] = (int)(g2/100)*100;
   int g3 = (int)(((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-(1200*Point()))-iClose(symbolS1.Name(),PERIOD_CURRENT,41))/Point());
   xInputs[0] = (int)(g3/100)*100;
   int g4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point()))+(iClose(symbolS1.Name(),PERIOD_CURRENT,48)-(1200*Point()))/2))/Point()) ;
   xInputs[0] = (int)(g4/100)*100;
   
   return(1);

  }

2.9 O padrão é um triângulo de quatro valores, estendido por 24 velas. No período H1, equivale a um dia.

Triângulo

Abaixo está uma descrição de que valores devemos transmitir:

  1. Do ponto 4 ao ponto 2, no meu caso, adicionamos 800 pips para cinco dígitos;
  2. Do ponto 4 ao ponto 3, subtraímos 800 pips;
  3. Valor arredondado do ponto 8 ao ponto 4 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  4. Valor arredondado do ponto 3 ao ponto 5;
  5. Valor arredondado do ponto 1 ao ponto 6;
  6. Valor arredondado do ponto 1 ao ponto 7;

Código nos EAs no perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point());
   a4 = (int)(a4/100)*100;

   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Código para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point());
   xInputs[3] = (int)(a4/100)*100;
   
   return(1);

  }

2.10 Padrão de triângulo de quatro valores, cobertura histórica de 48 velas. Dois dias no período H1.

Triângulo

Abaixo está uma descrição de quais valores transmitiremos para o perceptron e a rede neural:

  1. Do ponto 4 ao ponto 2, no meu caso, adicionamos 1200 pips para cinco dígitos;
  2. Do ponto 4 ao ponto 3, subtraímos 1200 pips;
  3. Valor arredondado do ponto 8 ao ponto 4 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  4. Valor arredondado do ponto 3 ao ponto 5;
  5. Valor arredondado do ponto 1 ao ponto 6;
  6. Valor arredondado do ponto 1 ao ponto 7;

Código do padrão nos EAs do perceptron:

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point());
   a4 = (int)(a4/100)*100;

   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Código do padrão para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
  
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point());
   xInputs[3] = (int)(a4/100)*100;
   
   return(1);

  }

2.11 O padrão é um triângulo de oito valores, estendido por 24 velas. A cobertura do histórico para análise é de um dia no período H1.

Triângulo

Abaixo também descreverei quais valores transmitimos:

  1. Do ponto 4 ao ponto 2, no meu caso, adicionamos 800 pips para cinco dígitos;
  2. Do ponto 4 ao ponto 3, subtraímos 800 pips;
  3. Valor arredondado do ponto 8 ao ponto 4 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  4. Valor arredondado do ponto 3 ao ponto 5;
  5. Valor arredondado do ponto 1 ao ponto 6;
  6. Valor arredondado do ponto 1 ao ponto 7;
  7. Valor arredondado do ponto 8 ao ponto 9 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  8. Valor arredondado do ponto 8 ao ponto 10 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  9. Valor arredondado do ponto 8 ao ponto 11 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  10. Valor arredondado do ponto 8 ao ponto 12 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);

 

Código do padrão nos EAs do perceptron: 

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   double v1 = y1 - 10.0;
   double v2 = y2 - 10.0;
   double v3 = y3 - 10.0;
   double v4 = y4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point());
   a4 = (int)(a4/100)*100;
   
   int b1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,4))/Point());
   b1 = (int)(b1/100)*100;
   int b2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,10))/Point());
   b2 = (int)(b2/100)*100;
   int b3 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,16))/Point());
   b3 = (int)(b3/100)*100;
   int b4 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,22))/Point());
   b4 = (int)(b4/100)*100;

   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   v1 * b1 + v2 * b2 + v3 * b3 + v4 * b4);
  }

Código do padrão para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,7))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,24)-iClose(symbolS1.Name(),PERIOD_CURRENT,19))/Point());
   xInputs[3] = (int)(a4/100)*100;
   
   int g1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,4))/Point());
   xInputs[4] = (int)(g1/100)*100;
   int g2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,10))/Point());
   xInputs[5] = (int)(g2/100)*100;
   int g3 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,16))/Point());
   xInputs[6] = (int)(g3/100)*100;
   int g4 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(800*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,24))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,22))/Point());
   xInputs[7] = (int)(g4/100)*100;
   
   return(1);

  }

2.12 O padrão é um triângulo de oito valores, estendido por 48 velas. A cobertura do histórico para análise é de dois dias no período H1.

Triângulo

Abaixo também descreverei quais valores transmitimos:

  1. Do ponto 4 ao ponto 2, no meu caso, adicionamos 1200 pontos para cinco dígitos, aumentamos o valor agregado em 48 velas;
  2. Do ponto 4 ao ponto 3, subtraímos 1200 pips;
  3. Valor arredondado do ponto 8 ao ponto 4 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  4. Valor arredondado do ponto 3 ao ponto 5;
  5. Valor arredondado do ponto 1 ao ponto 6;
  6. Valor arredondado do ponto 1 ao ponto 7;
  7. Valor arredondado do ponto 8 ao ponto 9 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  8. Valor arredondado do ponto 8 ao ponto 10 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  9. Valor arredondado do ponto 8 ao ponto 11 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);
  10. Valor arredondado do ponto 8 ao ponto 12 (o ponto 8 é encontrado como a diferença entre os pontos 2 e 1);

Código do padrão nos EAs do perceptron: 

//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron1() 
  {
   double w1 = x1 - 10.0;
   double w2 = x2 - 10.0;
   double w3 = x3 - 10.0;
   double w4 = x4 - 10.0;
   
   double v1 = y1 - 10.0;
   double v2 = y2 - 10.0;
   double v3 = y3 - 10.0;
   double v4 = y4 - 10.0;
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   a1 = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   a2 = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   a3 = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point());
   a4 = (int)(a4/100)*100;
   
   int b1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,6))/Point());
   b1 = (int)(b1/100)*100;
   int b2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,18))/Point());
   b2 = (int)(b2/100)*100;
   int b3 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,31))/Point());
   b3 = (int)(b3/100)*100;
   int b4 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,43))/Point());
   b4 = (int)(b4/100)*100;

   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   v1 * b1 + v2 * b2 + v3 * b3 + v4 * b4);
  }

Código do padrão de triângulo para EAs baseados na biblioteca DeepNeuralNetwork.mqh: 

//+------------------------------------------------------------------+
//|percentage of each part of the candle respecting total size       |
//+------------------------------------------------------------------+
int CandlePatterns(double &xInputs[])
  {
   
   int a1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,1))/Point());
   xInputs[0] = (int)(a1/100)*100;
   int a2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,13))/Point());
   xInputs[1] = (int)(a2/100)*100;
   int a3 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,25))/Point());
   xInputs[2] = (int)(a3/100)*100;
   int a4 = (int)((iClose(symbolS1.Name(),PERIOD_CURRENT,48)-iClose(symbolS1.Name(),PERIOD_CURRENT,37))/Point());
   xInputs[3] = (int)(a4/100)*100;
   
   int g1 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)+(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,6))/Point());
   xInputs[4] = (int)(g1/100)*100;
   int g2 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,18))/Point());
   xInputs[5] = (int)(g2/100)*100;
   int g3 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,31))/Point());
   xInputs[6] = (int)(g3/100)*100;
   int g4 = (int)((((iClose(symbolS1.Name(),PERIOD_CURRENT,1)-(1200*Point())+iClose(symbolS1.Name(),PERIOD_CURRENT,48))/2)-iClose(symbolS1.Name(),PERIOD_CURRENT,43))/Point());
   xInputs[7] = (int)(g4/100)*100;
   
   return(1);

  }


3. Expert Advisors

Agora, vamos à parte mais interessante, isto é, à otimização e ao teste dos nossos padrões. Deixe-me lembrar que a otimização e o teste dos Expert Advisors, baseados na biblioteca DeepNeuralNetwork.mqh, foram realizados utilizando as ferramentas padrão MQL5, sem o uso da tecnologia de otimização descrita no (Artigo 2). Foi notado também que 20 corridas são um pouco insuficientes para esses Expert Advisors. Eu recomendo que você realize a otimização com um número maior de iterações, o que (estou certo) irá melhorar o resultado. Um grande número de parâmetros para otimizar demanda mais tempo para identificar os melhores resultados. Neste artigo, quero apenas apresentar métodos não convencionais para transmissão de dados em uma rede neural.

Os Expert Advisors, baseados na biblioteca DeepNeuralNetwork.mqh e que usam quatro parâmetros no padrão, aplicam o esquema de rede neural 4-4-3, e com oito parâmetros, o esquema 8-4-3.

Eu tentei nomear cada um dos Expert Advisors de acordo com a sua estratégia e o padrão utilizado para análise. Então, acredito que será difícil se perder. Mas, se houver qualquer dúvida, você sempre pode me contatar no fórum ou por mensagens privadas. 

Em cada Expert Advisor para os testes forward, foram utilizados os primeiros 40 melhores resultados obtidos durante a otimização no modo "Critério máximo complexo". Irei apresentar os resultados no formato de resultados de otimização e, em seguida, os resultados dos testes forward.

Neste artigo, testaremos Expert Advisors baseados no padrão de leque e faremos considerações sobre a "tecnologia" apresentada. Os demais padrões serão, por assim dizer, tarefa de casa para aqueles que se interessarem. Postei a parte técnica na forma de códigos prontos para todos os padrões mencionados acima, então acredito que meus leitores não terão problemas em substituir os códigos dos padrões nos Expert Advisors disponibilizados ao final do artigo para realizarem otimizações e testes.

Para aqueles que leram este artigo, o primeiro desta série, e não entenderam como o teste é realizado, por favor, consultem a (Parte 3). Lá, tudo está descrito em detalhes.


3.1 EAs no perceptron.

EA 4 fan 24 SL TP 24 - trade - quatro parâmetros em 24 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

Como podemos observar, o resultado do teste forward não é encorajador. Houve uma perda suave do depósito ao longo de todo o período histórico. Os resultados do teste mostraram um fator de lucro em um nível alto. Provavelmente, a proporção entre StopLoss e TakeProfit está tendo um impacto.


Take Profit 230 Stop Loss 200:

Otimização


Forward

O fator de lucro mal ultrapassa o valor de 1,8. Ao longo de todo o histórico anual, ocorreram grandes rebaixamentos no depósito. O crescimento do depósito foi mínimo. Podemos dizer que estamos estagnados, sem progresso.


Take Profit 430 Stop Loss 200:

Otimização


Forward

A flutuação do depósito ao longo de todo o período de teste forward, ganhando e perdendo quantidades semelhantes, apresenta resultados muito instáveis. O fator de lucro durante a otimização está na faixa de 2.


EA  perceptron fan 4 SL TP 48 - trade - quatro parâmetros em 48 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

Um crescimento estável do depósito nos primeiros seis meses, seguido por um declínio gradual, provavelmente devido à falta de otimização adicional em um período tão longo. Resultados mais estáveis ​​podem ser obtidos aumentando o tempo nos parâmetros transmitidos. O fator de lucro é significativamente maior do que o resultado em 24 velas. Não há sinais de dependência da proporção de StopLoss para TakeProfit.


Take Profit 230 Stop Loss 200:

Otimização


Forward

Um crescimento estável do depósito nos primeiros cinco meses, seguido por um declínio, talvez devido a uma mudança no mercado em relação às condições selecionadas no perceptron. O gráfico irregular nos primeiros cinco meses ainda indica a instabilidade do sistema.


Take Profit 430 Stop Loss 200:

Otimização


Forward

O resultado mais estável nos testes do perceptron com o padrão de leque. Um crescimento constante nos primeiros seis meses. Em seguida, ocorre um leve declínio devido à falta de reotimização. Uma relação de TakeProfit para StopLoss de mais de duas vezes proporciona um bom resultado, de acordo com a abordagem clássica de negociação, onde o lucro é maior do que a perda. O fator de lucro ao otimizar está na faixa de 1,6, o que considero natural, considerando a proporção de StopLoss para TakeProfit.


 

EA  perceptron fan 8 SL TP 24 - trade - oito parâmetros em 24 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

O gráfico acabou sendo bastante irregular, mas o resultado é fundamentalmente diferente do Expert Advisor com quatro parâmetros e a mesma relação de TakeProfit e StopLoss. Também há um ligeiro declínio após a primeira metade do ano. O fator de lucro médio durante a otimização é de cerca de 6, o que é bastante significativo.


Take Profit 230 Stop Loss 200:

Otimização


Forward

Neste teste forward, temos um fracasso total. Acredito que isso esteja relacionado à proporção de TakeProfit e StopLoss de um para um. A otimização mostrou um fator de lucro em torno de 1,7, mas isso não conseguiu melhorar a situação.


Take Profit 430 Stop Loss 200:

Otimização


Forward

Nesta variante, também temos uma perdida completa, embora inicialmente haja alguma resistência. A otimização mostrou um fator de lucro em torno de 1,8, mas, como na versão anterior, isso não conseguiu melhorar a situação.


EA  perceptron fan 8 SL TP 48 - trade - oito parâmetros em 48 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

O gráfico apresenta uma irregularidade e, levando em consideração a proporção de TakeProfit para StopLoss, resulta em uma perda. A otimização revelou um fator de lucro na faixa de 3,5-4, mas o teste forward resultou em uma perda.


Take Profit 230 Stop Loss 200:

Otimização


Forward

Também observamos uma flutuação no mesmo lugar nesta versão. É muito estranho que o declínio no saldo ocorra logo no início do teste. A otimização revelou um fator de lucro na faixa de 2.


Take Profit 430 Stop Loss 200:

Otimização


Forward

Um começo muito promissor nos primeiros 3 meses, mas aparentemente a falta de nova otimização afetou. A proporção de TakeProfit para StopLoss de dois para um não salvou a situação em um período tão longo. Ao otimizar, o fator de lucro é em média 1,4.


3.2 EAs baseados na biblioteca DeepNeuralNetwork.mqh.

EA 4-4-3 fan 4 SL TP 24 - trade - quatro parâmetros em 24 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

Um fator de lucro de 20, o que é muito alto. No teste forward, obtivemos um resultado positivo, apesar de termos um StopLoss grande. Ainda assim, um maior número de pequenos TakeProfits positivos amplia a situação.


Take Profit 230 Stop Loss 200:

Otimização


Forward

O gráfico de saldo permanece estagnado. A otimização revelou um fator de lucro em torno de 1,7.


Take Profit 430 Stop Loss 200:

Otimização


Forward

O declínio é lento, mas constante. A proporção de TakeProfit para StopLoss não compensa a situação.  A otimização revelou um fator de lucro na faixa de 2.


EA 4-4-3 fan 4 SL TP 48 - trade - quatro parâmetros em 48 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

A transmissão do padrão em 48 velas não apresentou resultados positivos, ao contrário do mesmo padrão em 24 velas. Aparentemente, esse padrão tão estendido não funciona bem com essa proporção de TakeProfit para StopLoss. A otimização revelou um fator de lucro em torno de 14, o que não é insignificante.


Take Profit 230 Stop Loss 200:

Otimização


Forward

Ao realizar a otimização, obtivemos um fator de lucro de 2,5. Como podemos observar, a configuração de TakeProfit em 230 e StopLoss em 200 não funcionou, resultando em um declínio gradual no saldo.


Take Profit 430 Stop Loss 200:

Otimização


Forward

Neste caso, estamos estagnados. Ao longo do ano, o saldo oscila, compensando as perdas uma a uma. Ao realizar a otimização, obtemos um fator de lucro de 2,7.


EA 8-4-3 fan 8 SL TP 24 - trade - oito parâmetros em 24 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

Resultados muito interessantes, com apenas um StopLoss em todo o histórico do teste forward. No entanto, é possível que os resultados sejam aleatórios. Durante a otimização, o fator de lucro atinge valores surpreendentes em torno de 29.


Take Profit 230 Stop Loss 200:

Otimização


Forward

Como pode ser observado na captura de tela, há uma estagnação. Ao otimizar, o fator de lucro fica em torno de 2,7, o que deveria ser suficiente considerando nossa proporção de TakeProfit para StopLoss, mas não foi o caso. É possível notar um pequeno aumento nos primeiros seis meses.


Take Profit 430 Stop Loss 200:

Otimização


Forward

Nos primeiros dois ou três meses, houve um leve aumento, mas posteriormente, aparentemente, houve uma mudança na situação de mercado e o EA começou a perder o depósito. Parece que a otimização contínua ainda é necessária. Ao realizar a otimização, o fator de lucro ficou em torno de 3,9.


EA 8-4-3 fan 8 SL TP 48 - trade - oito parâmetros em 48 velas, padrão de leque:

TakeProfit 60 StopLoss 600:

Otimização


Forward

O comportamento deste Expert Advisor é semelhante ao anterior em um padrão de 24 velas. Há mais negócios não lucrativos. Ao otimizar o fator de lucro para um nível de 26, obtivemos 29 para 24 velas.


Take Profit 230 Stop Loss 200:

Otimização


Forward

Durante a otimização, o fator de lucro atingiu o nível 3. O nível de saldo permaneceu o mesmo. Houve uma alternância entre perdas e lucros.


Take Profit 430 Stop Loss 200:

Otimização


Forward

O aumento do TakeProfit em duas vezes em relação ao StopLoss não resulta em um resultado positivo. Provavelmente, as redes neurais não conseguem prever um TakeProfit tão grande. Durante a otimização, o fator de lucro atingiu o nível 3.


Considerações finais

A partir do trabalho realizado, é possível extrair conclusões tanto positivas quanto negativas. Apresentarei-as na forma de uma pequena lista para não perder o fluxo de pensamento.

  • Quanto à escalabilidade, acabou sendo um sistema muito flexível. É possível aplicar um número ilimitado de modelos e os parâmetros que passamos para eles. Criar novos padrões e observar os resultados, que impactam de forma mais eficaz nos testes forward.
  • Talvez seja necessário experimentar sistemas com vários perceptrons e diferentes padrões neles para determinar o sinal de entrada.
  • O poder computacional claramente não é suficiente. Precisamos de sistemas com não apenas um grande número de núcleos, mas um número imenso. Idealmente, um conjunto de dois processadores com um total de 16 ou mais núcleos.  Como se sabe, o testador de estratégias usa apenas núcleos físicos, não threads. A possibilidade de usar o serviço MQL5 Cloud Network pode aumentar significativamente a produtividade em nossas pesquisas.
  • O número de parâmetros de entrada transmitidos aumenta significativamente a carga no perceptron ou na rede neural. O arredondamento dos valores dos parâmetros de entrada aumentou o número de resultados positivos. Segundo minhas observações, cerca de duas vezes, o que é bastante animador.
  • Antes de escolher um sistema para um desenvolvimento futuro, é necessário verificar mais algumas opções de transmissão de dados para o perceptron e a rede neural, isto é, indicadores que variam em um determinado intervalo e um fenômeno tão interessante como a divergência. É o que, acredito, faremos num futuro próximo.


Lista de arquivos anexados:

  1. DeepNeuralNetwork - biblioteca original:
  2. DeepNeuralNetwork2 - biblioteca modificada para rede neural de estrutura 4-4-3;
  3. DeepNeuralNetwork3 - biblioteca modificada para rede neural de estrutura 8-4-3;
  4. perceptron fan 4 SL TP 24 - opt - EA do perceptron para otimizar um padrão de leque com quatro parâmetros em 24 velas;
  5. perceptron fan 4 SL TP 48 - opt  - EA do perceptron para otimizar um padrão de leque com quatro parâmetros em 48 velas;
  6. perceptron fan 8 SL TP 24 - opt - EA do perceptron para otimizar um padrão de leque para oito parâmetros em 24 velas;
  7. perceptron fan 8 SL TP 48 - opt - EA do perceptron para otimizar um padrão de leque para oito parâmetros em 48 velas;
  8. perceptron fan 4 SL TP 24 - trade (600 60), (200 230), (200 430) - EAs do perceptron otimizados, padrão de leque com quatro parâmetros em 24 velas;
  9. perceptron fan 4 SL TP 48 - trade (600 60), (200 230), (200 430) - EAs do perceptron otimizados, padrão de leque com quatro parâmetros em 48 velas;
  10. perceptron fan 8 SL TP 24 - trade (600 60), (200 230), (200 430) - EAs do perceptron otimizados, padrão de leque com oito parâmetros em 24 velas;
  11. perceptron fan 8 SL TP 48 - trade (600 60), (200 230), (200 430) - EAs do perceptron otimizados, padrão de leque com oito parâmetros em 48 velas;
  12. 4-4-3 fan 4 SL TP 24 - opt -  EA em uma biblioteca para otimizar um padrão de leque com quatro parâmetros em 24 velas;
  13. 4-4-3 fan 4 SL TP 48 - opt -  EA em uma biblioteca para otimizar um padrão de leque com quatro parâmetros em 48 velas;
  14. 8-4-3 fan 4 SL TP 24 - opt -  EA em uma biblioteca para otimizar um padrão de leque com oito parâmetros em 24 velas;
  15. 8-4-3 fan 4 SL TP 48 - opt -  EA em uma biblioteca para otimizar um padrão de leque com oito parâmetros em 48 velas;
  16. 4-4-3 fan 4 SL TP 24 - trade (600 60), (200 230), (200 430) - EAs otimizados na biblioteca, com um padrão de leque de quatro parâmetros em 24 velas;
  17. 4-4-3 fan 4 SL TP 48 - trade (600 60), (200 230), (200 430) - EAs otimizados na biblioteca, com um padrão de leque de quatro parâmetros em 48 velas;
  18. 8-4-3 fan 4 SL TP 24 - trade (600 60), (200 230), (200 430) - EAs otimizados na biblioteca, com um padrão de leque de oito parâmetros em 24 velas;
  19. 8-4-3 fan 4 SL TP 48 - trade (600 60), (200 230), (200 430) - EAs otimizados na biblioteca, com um padrão de leque de oito parâmetros em 48 velas;

Obrigado pela atenção, amigos, e até breve!


Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/12202

Arquivos anexados |
Baixar como ZIP
EA.zip (4191.11 KB)
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Outros artigos do autor

Ir para discussão
Redes neurais de maneira fácil (Parte 36): Modelos relacionais de aprendizado por reforço Redes neurais de maneira fácil (Parte 36): Modelos relacionais de aprendizado por reforço
Nos modelos de aprendizado por reforço discutidos anteriormente, usamos diferentes variantes de redes convolucionais, que são capazes de identificar diferentes corpos nos dados brutos. A principal vantagem das redes convolucionais é sua capacidade de identificar objetos independentemente de sua localização. No entanto, as redes convolucionais nem sempre são capazes de lidar com as diversas deformações e ruídos que os objetos apresentam. Mas esses problemas podem ser resolvidos pelo modelo relacional.
Ciência de Dados e Aprendizado de Máquina (Parte 12): É possível ter sucesso no mercado com redes neurais de autoaprendizagem? Ciência de Dados e Aprendizado de Máquina (Parte 12): É possível ter sucesso no mercado com redes neurais de autoaprendizagem?
Certamente muitas pessoas estão cansadas ​​​​de tentar constantemente prever o mercado de ações. Você gostaria de ter uma bola de cristal que o ajudasse a tomar melhores decisões de investimento? As redes neurais autoaprendentes podem ser a solução para isso. Neste artigo, vamos ver se esses algoritmos poderosos podem ajudar a surfar na onda e ser mais espertos que o mercado de ações. Ao analisar grandes volumes de dados e identificar padrões, as redes neurais autoaprendentes podem fazer previsões que geralmente são mais precisas do que as previsões dos traders. Vamos descobrir se essas tecnologias avançadas podem ser utilizadas para tomar decisões de investimento mais inteligentes e obter mais lucros.
Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 16): Um novo sistema de classes Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 16): Um novo sistema de classes
Precisamos nos organizar melhor. O código está crescendo e se não o organizarmos agora, será impossível fazer isto depois. Então agora vamos dividir para conquistar. O fato de que o MQL5, nos permite usar classes, nos ajudará nesta tarefa. Mas para fazer isto é preciso que você tenha algum conhecimento sobre algumas coisas envolvidas nas classes. E talvez a que mais deixe, aspirantes e iniciantes perdidos seja a herança. Então neste artigo, irei de forma prática e simples como fazer uso de tais mecanismos.
Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 15): Nascimento do SIMULADOR (V) - RANDOM WALK Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 15): Nascimento do SIMULADOR (V) - RANDOM WALK
Neste artigo iremos finalizar a fase, onde estamos desenvolvendo o simulador para o nosso sistema. O principal proposito aqui será ajustar o algoritmo visto no artigo anterior. Tal algoritmo tem como finalidade criar o movimento de RANDOM WALK. Por conta disto, o entendimento do conteúdo dos artigos anteriores, é primordial para acompanhar o que será explicado aqui. Se você não acompanhou o desenvolvimento do simulador, aconselho você a ver esta sequência desde o inicio. Caso contrário, poderá ficar perdido no que será explicado aqui.