MetaTrader 5 / Sistemas comerciales
English Русский 中文 Deutsch 日本語 Português
preview
Experimentos con redes neuronales (Parte 4): Patrones

Experimentos con redes neuronales (Parte 4): Patrones

MetaTrader 5 — Sistemas comerciales | 29 junio 2023, 09:31
363 0
Roman Poshtar
Roman Poshtar

Introducción

Buenas tardes, estimados usuarios de la comunidad MQL5. Querría compartir mis conocimientos con ustedes más a menudo, pero como podrán imaginar, una actividad así requiere tiempo y recursos informáticos que, en mi caso, resultan insuficientes en comparación con las tareas que tengo entre manos.

En los artículos anteriores (Parte 1, Parte 2, Parte 3), experimentamos con formas y ángulos de inclinación cuyo valor transmitíamos al perceptrón y a una red neuronal basada en DeepNeuralNetwork.mqh.  También experimentamos con métodos de optimización en el simulador de estrategias. Hablando con franqueza, no estaba del todo satisfecho con los resultados de las redes neuronales basadas en DeepNeuralNetwork.mqh y el lento rendimiento del astuto algoritmo de optimización que describí en la parte 3. Los resultados en el perceptrón simple fueron mejores que los de la red neuronal. Posiblemente estemos alimentando la red neuronal con datos inadecuados para este tipo de tareas, cuyo rango de variación podría no llevarnos a un resultado estable.  Además, en los comentarios de los artículos anteriores he visto críticas sobre la relación entre Take Profit y Stop Loss. Bueno, tendremos en cuenta todos los deseos en los próximos experimentos.

Durante mis investigaciones, me encontré con un interesante algoritmo de seguimiento de patrones en nuestro foro favorito de MQL5. Su esencia consistía en convertir el precio en un determinado patrón para determinar la entrada en una posición y no tenía nada que ver con el uso de redes neuronales.

He bautizado esta "tecnología" con el nombre de "patrón". No sé si está bien o mal, pero me ha parecido la palabra más adecuada.

Otra tarea importante en los experimentos actuales es el seguimiento del impacto de la cantidad de datos transmitidos y la profundidad de la historia de la que sacamos esos datos, así como revelar patrones, ya sean los mejores patrones más cortos o más largos, y utilizar más o menos parámetros para la transmisión.

Ahora mismo estoy escribiendo esta introducción y, francamente, no sé en qué acabaremos. La verdad es que quería repasarlo todo con ustedes, mis estimados lectores: la idea está ahí y hemos planteado la tarea, así que es hora de ponerse en marcha. Como es ya tradición, solo utilizaremos las herramientas de MetaTrader 5, sin software de terceros. Lo más probable es que este artículo resulte similar a unas instrucciones paso a paso: yo, por mi parte, intentaré explicar todo de la forma más clara y sencilla posible.

Tenemos mucho trabajo por hacer: ¡manos a la obra!


1. Pareja de divisas. Rango de optimización y pruebas forward. Ajustes

Aquí ofreceremos todos los parámetros para la optimización y las pruebas forward, para no repetirnos más en el texto:

  • Mercado Fórex;
  • Pareja de divisas EURUSD;
  • Periodo H1;
  • Plantillas: Abanico, Paralelogramo, Triángulo;
  • Stop Loss y Take Profit para las modificaciones correspondientes 600 y 60, 200 y 230 para el equilibrio, teniendo en cuenta el spread; añadimos 30 pips por encima de cinco dígitos al Take Profit, 200 y 430 Take Profit dos veces mayor que el Stop Loss, 30 pips por encima de cinco dígitos al Take Profit para el equilibrio.
  • Optimización y modo de prueba "Solo precios de apertura" y "Máximo del criterio complejo". Es muy importante usar el modo "Máximo del criterio complejo", ya que ha mostrado resultados más estables y rentables en comparación con "Rentabilidad Máxima";
  • Rango de optimización 3 años. Del 2019.02.18 al 2022.02.18. 3 años no es ningún criterio. Puede probar más o menos por su cuenta;
  • Rango de prueba forward de 1 año. Del 2022.02.18 al 2023.02.18. Comprobamos todo basándonos en el algoritmo descrito en el artículo (Experimentos con redes neuronales (Parte 3): Uso práctico). Es decir, el comercio simultáneo de varios de los mejores resultados de optimización;
  • Ahora vamos a realizar la optimización 20 veces. Asimismo, aumentaremos dos veces en comparación con las pruebas anteriores y veremos los resultados. 
  • En todas las pruebas forward hemos utilizado simultáneamente 40 resultados de optimización. El valor se multiplica por 2 con respecto a las pruebas anteriores de los artículos;
  • Optimización de asesores expertos con perceptrón «Rápida (algoritmo genético)»;
  • Optimización de asesores en la biblioteca DeepNeuralNetwork.mqh "Rápida (algoritmo genético)". Debido a la lenta optimización del algoritmo analizado en la Parte 2, hemos decidido optimizar utilizando directamente las herramientas de MetaTrader 5;
  • Depósito inicial de 10000 unidades;
  • Apalancamiento 1:500.

Casi olvido contarle cómo ejecuto la optimización 20, 40 o más veces en el modo de optimización "Rápida (algoritmo genético)". Para ello, usaremos un pequeño programa autoclicker escrito en Delphi. No puedo publicarlo aquí, pero lo enviaré a quien lo necesite por mensaje privado si me manda su correo electrónico. Esto funciona así:

  1. Introducimos el número deseado de optimizaciones.
  2. Situamos el cursor del ratón sobre el botón «Iniciar» del simulador de estrategias.
  3. Nos ocupamos de nuestra tarea.

La optimización finalizará tras los ciclos indicados y el programa se cerrará. El autoclicker reaccionará al cambio de color del botón «Iniciar». A continuación mostramos una captura de pantalla del programa. 

Autoclicker


2. Patrones

Un patrón es un tipo de construcción similar a los "patrones flotantes". Sus valores cambian constantemente según la situación del mercado, pero cada uno de ellos se encuentra dentro de un rango determinado, que es lo que necesitamos para nuestros experimentos. Así que, como ya sabemos, los datos que enviamos a la red neuronal deberán encontrarse dentro de un rango determinado. El valor en el patrón se redondea a números enteros para simplificar y facilitar la comprensión por parte del perceptrón y la red neuronal. Esto posibilitará la aparición de más situaciones para las condiciones desencadenantes y una carga menor para el perceptrón y la red neuronal. En la siguiente captura de pantalla, podemos ver el primero de los patrones que se me ocurrió. Lo llamé «abanico», creo que el parecido es obvio. En este artículo no usaremos indicadores, trabajaremos con velas.

A continuación mostramos ejemplos utilizando el escalado en la historia, de modo que podamos analizar historias más cortas o más profundas.

El uso de un número igual de velas en los patrones es opcional, lo cual ofrece margen adicional para pensar en la relevancia de los valores de precio anteriores, en nuestro caso, los precios de cierre de las velas.

Debemos entender que en los ejemplos que utilizan la biblioteca DeepNeuralNetwork.mqh para 24 velas utilizamos diferentes bibliotecas que he descrito en artículos anteriores con diferentes ajustes de entrada. En concreto, 4 y 8 parámetros a la entrada de la red neuronal. Pero usted no tiene de que preocuparse: en el archivo adjunto he añadido los asesores y bibliotecas que necesita.

2.1 Patrón de abanico de cuatro valores extendido en 24 velas. En el periodo H1 equivale a un día. 

Abanico 4 24

Vamos a describir lo transmitiremos al perceptrón y a la red neuronal para que se entienda mejor:

  1. La distancia redondeada en puntos del punto 1 al punto 2;
  2. La distancia redondeada en puntos del punto 1 al punto 3;
  3. La distancia redondeada en puntos del punto 1 al punto 4;
  4. La distancia redondeada en puntos del punto 1 al punto 5;

Y cómo se vería en código para asesores basados en un perceptrón: 

//+------------------------------------------------------------------+
//|  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);
  }

Y cómo se vería esto en código para asesores en la 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 Patrón de abanico de ocho valores extendidos en 24 velas. En el periodo H1 equivale a un día.

Patrón 8 24

 

 

Esto es lo que transmitiremos al perceptrón y a la red neuronal para una mejor comprensión:

  1. La distancia redondeada en puntos del punto 1 al punto 2;
  2. La distancia redondeada en puntos del punto 1 al punto 3;
  3. La distancia redondeada en puntos del punto 1 al punto 4;
  4. La distancia redondeada en puntos del punto 1 al punto 5;
  5. Distancia redondeada en puntos del punto 1 al punto 6;
  6. Distancia redondeada en puntos del punto 1 al punto 7;
  7. Distancia redondeada en puntos del punto 1 al punto 8;
  8. Distancia redondeada en puntos del punto 1 al punto 9;

Y cómo se vería en código para asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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);
  }

Y cómo se vería esto en código para asesores en la 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 Patrón de abanico de cuatro valores extendido en 48 velas. En un periodo H1 equivale a dos días.

Abanico 48

Bien, vamos a escribir qué es qué para entender todo mejor:

  1. La distancia redondeada en puntos del punto 1 al punto 2;
  2. La distancia redondeada en puntos del punto 1 al punto 3;
  3. La distancia redondeada en puntos del punto 1 al punto 4;
  4. La distancia redondeada en puntos del punto 1 al punto 5;

Y cómo se vería en código para asesores basados en un perceptrón. Vemos el ejemplo anterior, extendido en el tiempo 2 días:

//+------------------------------------------------------------------+
//|  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);
  }

Y cómo se vería esto en código en nuestra biblioteca DeepNeuralNetwork.mqh . Vemos el ejemplo anterior, extendido en el tiempo 2 días: 

//+------------------------------------------------------------------+
//|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 Patrón de abanico de ocho valores extendidos en 48 velas. En un periodo H1 equivale a dos días.

Abanico 8 48

Para una mayor comprensión, aquí tenemos qué transmitimos al perceptrón y la red neuronal; los puntos de referencia se han desplazado por un número igual de velas:

  1. La distancia redondeada en puntos del punto 1 al punto 2;
  2. La distancia redondeada en puntos del punto 1 al punto 3;
  3. La distancia redondeada en puntos del punto 1 al punto 4;
  4. La distancia redondeada en puntos del punto 1 al punto 5;
  5. Distancia redondeada en puntos del punto 1 al punto 6;
  6. Distancia redondeada en puntos del punto 1 al punto 7;
  7. Distancia redondeada en puntos del punto 1 al punto 8;
  8. Distancia redondeada en puntos del punto 1 al punto 9;

Código en los asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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 en los asesores en la 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 Patrón de paralelogramo de cuatro valores extendidos en 24 velas. Un diseño más complejo para la transmisión de los parámetros. En el periodo H1 equivale a un día.

Paralelogramo

A continuación describiremos los valores que se deben transmitir:

  1. Del punto 10 al punto 2, añadimos 800 puntos para cinco dígitos, en nuestro caso;
  2. Del punto 10 al punto 1, restamos 800 puntos;
  3. Del punto 9 al punto 3, sumamos 800 puntos;
  4. Del punto 9 al punto 4, restamos 800 puntos;
  5. El valor redondeado del punto 8 al punto 9 (el punto 8 se calcula como la diferencia entre los puntos 2 y 3);
  6. El valor redondeado del punto 3 al punto 7;
  7. El valor redondeado del punto 2 al punto 6;
  8. El valor redondeado del punto 1 al punto 5;

Código en los asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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 en los asesores en la 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 Patrón de paralelogramo de cuatro valores extendidos en 48 velas. Mayor cobertura a lo largo del tiempo. En un periodo H1 equivale a dos días.

Paralelogramo

A continuación describiremos los valores que se deben transmitir:

  1. Del punto 10 al punto 2, en nuestro caso, sumamos 1200 puntos para cinco dígitos. Hemos aumentado el valor en pips, ya que el precio puede cambiar por un amplio margen en dos días. De este modo, no distorsionaremos nuestro diseño;
  2. Del punto 10 al punto 1, restamos 1200 puntos;
  3. Del punto 9 al punto 3, sumamos 1200 puntos;
  4. Del punto 9 al punto 4, restamos 1200 puntos;
  5. El valor redondeado del punto 8 al punto 9 (el punto 8 se calcula como la diferencia entre los puntos 2 y 3);
  6. El valor redondeado del punto 3 al punto 7;
  7. El valor redondeado del punto 2 al punto 6;
  8. El valor redondeado del punto 1 al punto 5;

Código en los asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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 en los asesores en la 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 Plantilla de paralelogramo de ocho valores extendidos en 24 velas. En el periodo H1 equivale a un día.

Paralelogramo

A continuación describiremos los valores que se deben transmitir:

  1. Del punto 9, en nuestro caso, sumamos 800 puntos para cinco dígitos, obtenemos el punto 3;
  2. Del punto 9, restamos 800 puntos para obtener el punto 4;
  3. Del punto 12 al punto 2, sumamos 800 puntos;
  4. Del punto 12 al punto 1, restamos 800 puntos;
  5. El valor redondeado del punto 8 al punto 9 (el punto 8 se calcula como la diferencia entre los puntos 2 y 3);
  6. El valor redondeado del punto 7 al punto 3;
  7. El valor redondeado del punto 13 al punto 4;
  8. El valor redondeado del punto 6 al punto 3;
  9. El valor redondeado del punto 2 al punto 6;
  10. El valor redondeado del punto 2 al punto 10;
  11. El valor redondeado del punto 12 al punto 11 (el punto 1 se calcula como la diferencia entre los puntos 4 y 1);
  12. El valor redondeado del punto 1 al punto 5;

Código en los asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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);
  }

Y cómo se vería esto en código para los asesores en la 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 Plantilla de paralelogramo de ocho valores, extendida en 48 velas para una mayor cobertura de la historia. En un periodo H1 equivale a dos días.

Paralelogramo

A continuación describiremos los valores que se deben transmitir:

  1. Desde el punto 9, en nuestro caso, sumamos 1200 puntos para cinco dígitos, obtenemos el punto 3;
  2. Del punto 9, restamos 1200 puntos, y obtenemos el punto 4;
  3. Del punto 12 al punto 2, sumamos 1200 puntos;
  4. Del punto 12 al punto 1, restamos 1200 puntos;
  5. El valor redondeado del punto 8 al punto 9 (el punto 8 se calcula como la diferencia entre los puntos 2 y 3);
  6. El valor redondeado del punto 7 al punto 3;
  7. El valor redondeado del punto 13 al punto 4;
  8. El valor redondeado del punto 6 al punto 3;
  9. El valor redondeado del punto 2 al punto 6;
  10. El valor redondeado del punto 2 al punto 10;
  11. El valor redondeado del punto 12 al punto 11 (el punto 1 se calcula como la diferencia entre los puntos 4 y 1);
  12. El valor redondeado del punto 1 al punto 5;

Código en los asesores basados en un perceptrón: 

//+------------------------------------------------------------------+
//|  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 asesores en la 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 Plantilla triangular de cuatro valores, extendida en 24 velas. En el periodo H1 equivale a un día.

Triángulo

A continuación describiremos los valores que se deben transmitir:

  1. Del punto 4 al punto 2, sumamos 800 puntos para cinco dígitos, en nuestro caso;
  2. Del punto 4 al punto 3, restamos 800 puntos;
  3. El valor redondeado del punto 8 al punto 4 (el punto 8 se calcula como diferencia entre los puntos 2 y 1);
  4. El valor redondeado del punto 3 al punto 5;
  5. El valor redondeado del punto 1 al punto 6;
  6. El valor redondeado del punto 1 al punto 7;

Código en los asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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 asesores en la 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 Patrón triangular de cuatro valores, con una cobertura histórica de 48 velas. Dos días en el periodo H1.

Triángulo

A continuación describiremos los valores que se transmiten al perceptrón y a la red neuronal:

  1. Del punto 4 al punto 2, en nuestro caso, sumamos 1200 puntos para cinco dígitos;
  2. Del punto 4 al punto 3, restamos 1200 puntos;
  3. El valor redondeado del punto 8 al punto 4 (el punto 8 se calcula como diferencia entre los puntos 2 y 1);
  4. El valor redondeado del punto 3 al punto 5;
  5. El valor redondeado del punto 1 al punto 6;
  6. El valor redondeado del punto 1 al punto 7;

Código del patrón en los asesores basados en un perceptrón:

//+------------------------------------------------------------------+
//|  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);
  }

Plantilla de código para asesores en la 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 Plantilla triangular de ocho valores, extendida en 24 velas. La cobertura histórica para el análisis será de un día en el marco temporal H1.

Triángulo

A continuación también describiremos qué valores transmitimos:

  1. Del punto 4 al punto 2, sumamos 800 puntos para cinco dígitos, en nuestro caso;
  2. Del punto 4 al punto 3, restamos 800 puntos;
  3. El valor redondeado del punto 8 al punto 4 (el punto 8 se calcula como diferencia entre los puntos 2 y 1);
  4. El valor redondeado del punto 3 al punto 5;
  5. El valor redondeado del punto 1 al punto 6;
  6. El valor redondeado del punto 1 al punto 7;
  7. El valor redondeado del punto 8 al punto 9 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);
  8. El valor redondeado del punto 8 al punto 10 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);
  9. El valor redondeado del punto 8 al punto 11 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);
  10. El valor redondeado del punto 8 al punto 12 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);

 

Código del patrón en los asesores basados en un perceptrón: 

//+------------------------------------------------------------------+
//|  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);
  }

Plantilla de código para asesores en la 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 Plantilla triangular de ocho valores extendida en 48 velas. La cobertura histórica para el análisis será de dos días en el marco temporal H1.

Triángulo

A continuación también describiremos qué valores transmitimos:

  1. Del punto 4 al punto 2, añadimos en nuestro caso 1200 pips para cinco dígitos, el valor añadido aumenta en 48 velas;
  2. Del punto 4 al punto 3, restamos 1200 puntos;
  3. El valor redondeado del punto 8 al punto 4 (el punto 8 se calcula como diferencia entre los puntos 2 y 1);
  4. El valor redondeado del punto 3 al punto 5;
  5. El valor redondeado del punto 1 al punto 6;
  6. El valor redondeado del punto 1 al punto 7;
  7. El valor redondeado del punto 8 al punto 9 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);
  8. El valor redondeado del punto 8 al punto 10 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);
  9. El valor redondeado del punto 8 al punto 11 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);
  10. El valor redondeado del punto 8 al punto 12 (el punto 8 se calcula como la diferencia entre los puntos 2 y 1);

Código del patrón en los asesores basados en un perceptrón: 

//+------------------------------------------------------------------+
//|  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 de patrón triangular para los asesores en la 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. Asesores

Así pues, vamos a pasar a la parte divertida: optimizar y probar nuestros patrones. Permítanme recordarles que la optimización y las pruebas de los asesores expertos utilizando la biblioteca DeepNeuralNetwork.mqh se han realizado con los medios estándar de MQL5 sin utilizar la tecnología de optimización descrita en elArtículo 2. También hemos notado que 20 pasadas son pocas para estos asesores. Le recomiendo que realice usted mismo la optimización con más iteraciones, quizá (estoy seguro) mejore el resultado. El gran número de parámetros que hay que optimizar requiere más tiempo para identificar los mejores resultados. En este artículo solo quiero mostrar algunos métodos no estándar de transmisión de datos en una red neuronal.

Los asesores de DeepNeuralNetwork.mqh con cuatro parámetros en el patrón utilizan un esquema de red neuronal 4-4-3, y con ocho parámetros, el esquema 8-4-3.

Hemos intentado nombrar cada asesor según su estrategia y el patrón utilizado para el análisis. Así que creo que resultará difícil perderse. En todo caso, siempre podrá contactar conmigo en el foro o por mensaje privado. 

En cada asesor experto, hemos utilizado para las pruebas forward los primeros 40 mejores resultados obtenidos durante la optimización en el modo "Máximo del criterio complejo". Publicaremos los resultados en el formato de resultados de optimización y más abajo mostraremos los resultados de las pruebas forward.

En este artículo probaremos asesores basados en el patrón de abanico y sacaremos conclusiones sobre la "tecnología" presentada; los otros patrones serán, por así decirlo, tareas adicionales para aquellos que estén interesados. Ya hemos expuesto antes la parte técnica en forma de códigos ya preparados para todas las plantillas, por lo que los lectores no tendrán ningún problema en sustituir los códigos de las plantillas en los asesores expertos publicados al final del artículo y llevar a cabo la optimización y las pruebas.

Para los que lean este artículo por primera vez en la serie y no entiendan cómo se hacen las pruebas, les invito a leer la Parte 3, donde todo se explica con detalle.


3.1 Asesores basados en un perceptrón.

Asesor perceptron fan 4 SL TP 24 - trade - cuatro parámetros en 24 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

Como podemos ver, el resultado de las pruebas forward no es agradable, pues tiene lugar una pérdida paulatina del depósito a lo largo de toda la historia. El factor de beneficio de los resultados de las pruebas es elevado, probablemente se vea afectado por la relación entre Stop Loss y Take Profit.


Take Profit 230 Stop Loss 200:

Optimización


Forward

El factor de beneficio apenas supera el 1,8. Hay grandes reducciones del depósito a lo largo de todo el año. El crecimiento del depósito es mínimo. Se podría decir que estamos haciendo aguas.


Take Profit 430 Stop Loss 200:

Optimización


Forward

Los depósitos se tambalean en toda la gama de pruebas forward, por mucho que hayamos ganado y perdido, los resultados son muy inestables. El factor de beneficio para la optimización es de alrededor de 2.


Asesor perceptron fan 4 SL TP 48 - trade- cuatro parámetros en 48 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

El crecimiento del depósito durante los seis primeros meses es estable, y después se da algún tipo de descenso, creo que debido a la falta de optimización adicional durante un periodo de tiempo tan largo. Los resultados son más estables gracias al aumento del tiempo en los parámetros transmitidos. El factor de beneficio es significativamente superior al resultado en 24 velas. No existen señales de vinculación respecto a la relación entre Stop Loss y Take Profit.


Take Profit 230 Stop Loss 200:

Optimización


Forward

Se da un crecimiento estable del depósito durante los cinco primeros meses, y luego vemos un descenso, quizá el mercado haya cambiado, a diferencia de las condiciones del perceptrón. El calendario errático de los cinco primeros meses sugiere que el sistema es inestable.


Take Profit 430 Stop Loss 200:

Optimización


Forward

Este es el resultado más consistente en las pruebas de perceptrón con el patrón de abanico. Tenemos un crecimiento constante durante los seis primeros meses. A continuación, se produce un ligero descenso debido a la falta de sobreoptimización. El Take Profit, más de dos veces superior al Stop Loss, ofrece un buen resultado en de acuerdo con el enfoque clásico del trading, el beneficio es mayor que el stop. El factor de beneficio durante la optimización está en 1,6, lo cual me parece lógico dada la relación entre el Stop Loss y el Take Profit.


 

Asesor perceptron fan 8 SL TP 24 - trade- ocho parámetros en 24 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

El gráfico es bastante irregular, pero el resultado es radicalmente diferente del asesor con cuatro parámetros con el mismo Take Profit y Stop Loss. También observamos cierto descenso tras el primer semestre. El factor de beneficio medio de la optimización ronda el 6, es decir, bastante elevado.


Take Profit 230 Stop Loss 200:

Optimización


Forward

En esta prueba forward, obtenemos un fallo completo. Creo que tiene que ver con la relación entre Take Profit y Stop Loss de uno a uno. La optimización ha mostrado un factor de beneficio de alrededor de 1,7, pero esto no ha salvado la situación.


Take Profit 430 Stop Loss 200:

Optimización


Forward

En esta variante, también conseguimos una pérdida completa del depósito, aunque al principio hay cierta resistencia. La optimización ha mostrado un factor de beneficio de alrededor de 1,8, pero, al igual que sucede con la opción anterior, esto no ha salvado la situación.


Asesor perceptron fan 8 SL TP 48 - trade - ocho parámetros en 48 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

Es un gráfico irregular, teniendo en cuenta la relación entre Take Profit y Stop Loss, obtenemos pérdidas. La optimización ha mostrado un factor de beneficio de entre 3,5 y 4, pero la prueba forward muestra pérdidas.


Take Profit 230 Stop Loss 200:

Optimización


Forward

También observamos fluctuaciones en esta variante. Resulta muy extraño que la caída del balance se produzca justo al principio de la prueba. La optimización ha mostrado un factor de beneficio de alrededor de 2.


Take Profit 430 Stop Loss 200:

Optimización


Forward

Alrededor de los 3 primeros meses, funciona muy bien, más tarde, la falta de una nueva optimización, en apariencia, tiene cierta influencia. La relación entre Take Profit y Stop Loss de dos a uno no ha salvado la situación durante un periodo tan largo. Al realizar la optimización, el factor de beneficio es, por término medio, de 1,4.


3.2 Asesores basados en la biblioteca DeepNeuralNetwork.mqh.

Asesor 4-4-3 fan 4 SL TP 24 - trade - cuatro parámetros en 24 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

El factor de beneficio es de 20, cosa bastante notable. En la prueba forward obtenemos un resultado positivo, pero tenemos grandes Stop Loss. Aun así, un mayor número de pequeños Take Profits positivos salva la situación.


Take Profit 230 Stop Loss 200:

Optimización


Forward

El gráfico del balance se estanca. La optimización ha mostrado un factor de beneficio de alrededor de 1,7.


Take Profit 430 Stop Loss 200:

Optimización


Forward

El declive es lento pero constante. La relación entre Take Profit y Stop Loss no salva la situación.  La optimización ha mostrado un factor de beneficio de alrededor de 2.


Asesor 4-4-3 fan 4 SL TP 48 - trade- cuatro parámetros en 48 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

La transmisión del patrón en 48 velas no ha mostrado un resultado positivo, a diferencia del mismo patrón en 24 velas. Aparentemente, un patrón tan extendido en el tiempo no funciona bien con esta relación entre Take Profit y Stop Loss. La optimización ha mostrado un factor de beneficio de alrededor de 14, lo cual no es insignificante.


Take Profit 230 Stop Loss 200:

Optimización


Forward

La optimización da como resultado un factor de beneficio de 2,5. Como podemos ver, Take Profit 230 Stop Loss 200 no funciona, obtenemos una lenta disminución en el balance.


Take Profit 430 Stop Loss 200:

Optimización


Forward

En este caso, estamos estancados. A lo largo del año, el balance baja y sube, compensando las pérdidas en una proporción de uno a uno. La optimización da como resultado un factor de beneficio de 2,7.


Asesor 8-4-3 fan 8 SL TP 24 - trade - ocho parámetros en 24 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

Los resultados son muy interesantes, solo un Stop Loss en todo la historia de pruebas forward. Aun así, los resultados quizá sean casuales. Al optimizar, el factor de beneficio es de 29.


Take Profit 230 Stop Loss 200:

Optimización


Forward

Como podemos ver en la captura de pantalla, se ha quedado estancado. Con la optimización, el factor de beneficio es de 2,7, lo cual debería haber sido suficiente con nuestra relación entre Take Profit y Stop Loss, pero no ha sido así. Podemos ver cierto repunte en los primeros seis meses.


Take Profit 430 Stop Loss 200:

Optimización


Forward

Durante los dos o tres primeros meses se produjo un ligero aumento, pero luego, al parecer, la situación del mercado cambió y el asesor empezó a perder el depósito. Después de todo, parece que la optimización constante es algo necesario. Una vez optimizado, el factor de beneficio se sitúa en 3,9.


Asesor 8-4-3 fan 8 SL TP 48 - trade - ocho parámetros en 48 velas, patrón de abanico:

Take Profit 60 Stop Loss 600:

Optimización


Forward

El comportamiento de este asesor es similar al anterior en un patrón de 24 velas. Hay más transacciones perdedoras. Optimizando el factor de beneficio a un nivel de 26, hemos obtenido 29 por 24 velas.


Take Profit 230 Stop Loss 200:

Optimización


Forward

Al optimizar, el factor de beneficio se sitúa en el nivel 3. El nivel de balance permanece en el mismo lugar. Las pérdidas se alternan con los beneficios.


Take Profit 430 Stop Loss 200:

Optimización


Forward

Aumentar Take Profit dos veces por encima del Stop Loss no produce un resultado positivo. Probablemente, la red neuronal no sea capaz de predecir un Take Profit tan grande. Al optimizar, el factor de beneficio se sitúa en el nivel 3.


Conclusión

Del trabajo realizado podemos extraer conclusiones, tanto positivas como negativas. Las expondré en forma de lista breve, para no perder el hilo.

  • En términos de escalabilidad, el sistema resulta muy flexible. Podemos aplicar un número ilimitado de patrones y parámetros transmitidos a los mismos. Idear nuevos patrones y observar los resultados tiene un mejor efecto en las pruebas forward.
  • Puede que siga siendo necesario probar sistemas con varios perceptrones y diferentes patrones en ellos para determinar la señal de entrada,
  • la capacidad informática es claramente insuficiente. Necesitamos sistemas no solo con un gran número de núcleos, sino con un número enorme. Lo ideal sería un conjunto de doble procesador con un total de 16 núcleos o más.  Como ya sabemos, el simulador de estrategias solo utiliza núcleos físicos, no hilos. La posibilidad de utilizar el servicio Cloud Network puede mejorar significativamente la productividad en nuestras búsquedas.
  • El número de parámetros de entrada transmitidos aumenta considerablemente la carga del perceptrón o red neuronal. El redondeo de los valores de los parámetros de entrada ha aumentado el número de resultados positivos. Según mis observaciones, resulta de aproximadamente el doble, lo cual es una alegría para la vista.
  • Antes de optar por un sistema para su posterior desarrollo, hay un par de opciones más para comprobar las formas de transmisión de datos al perceptrón y a la red neuronal, a saber, indicadores que se mueven dentro de un determinado rango, además de un fenómeno tan interesante como la divergencia, cosa que, probablemente, haremos en un futuro próximo.


La lista de archivos adjuntos:

  1. DeepNeuralNetwork- biblioteca original:
  2. DeepNeuralNetwork2 - biblioteca de redes neuronales modificada para la estructura 4-4-3;
  3. DeepNeuralNetwork3 - biblioteca modificada para la estructura de red neuronal 8-4-3;
  4. perceptron fan 4 SL TP 24 - opt - asesor experto basado en un perceptrón para optimizar el patrón de abanico con cuatro parámetros en 24 velas;
  5. perceptron fan 4 SL TP 48 - opt - asesor experto basado en un perceptrón para optimizar el patrón de abanico con cuatro parámetros en 48 velas;
  6. perceptron fan 8 SL TP 24 - opt - asesor experto basado en un perceptrón para optimizar el patrón de abanico para ocho parámetros en 24 velas;
  7. perceptron fan 8 SL TP 48 - opt - asesor experto basado en un perceptrón para optimizar el patrón de abanico para ocho parámetros en 48 velas;
  8. perceptron fan 4 SL TP 24 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en un perceptrón, patrón de abanico con cuatro parámetros en 24 velas;
  9. perceptron fan 4 SL TP 48 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en un perceptrón, patrón de abanico con cuatro parámetros en 48 velas;
  10. perceptron fan 8 SL TP 24 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en un perceptrón, patrón de abanico para ocho parámetros en 24 velas;
  11. perceptron fan 8 SL TP 48 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en un perceptrón, patrón de abanico para ocho parámetros en 48 velas;
  12. 4-4-3 fan 4 SL TP 24 - opt - asesor experto basado en la biblioteca para optimizar un patrón de abanico con cuatro parámetros en 24 velas;
  13. 4-4-3 fan 4 SL TP 48 - opt - asesor experto basado en la biblioteca para optimizar un patrón de abanico con cuatro parámetros en 48 velas;
  14. 8-4-3 fan 4 SL TP 24 - opt - asesor experto basado en la biblioteca para optimizar un patrón de abanico para ocho parámetros en 24 velas;
  15. 8-4-3 fan 4 SL TP 48 - opt - asesor experto basado en la biblioteca para optimizar un patrón de abanico para ocho parámetros en 48 velas;
  16. 4-4-3 fan 4 SL TP 24 - (600 60), (200 230), (200 430) - asesores expertos optimizados basados en la biblioteca, patrón de abanico con cuatro parámetros en 24 velas;
  17. 4-4-3 fan 4 SL TP 48 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en la biblioteca, patrón de abanico con cuatro parámetros en 48 velas;
  18. 8-4-3 fan 4 SL TP 24 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en la biblioteca, patrón de abanico para ocho parámetros en 24 velas;
  19. 8-4-3 fan 4 SL TP 48 - trade (600 60), (200 230), (200 430) - asesores expertos optimizados basados en la biblioteca, patrón de abanico para ocho parámetros en 48 velas;

Gracias por su atención, amigos, ¡y hasta pronto!


Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/12202

Archivos adjuntos |
Descargar ZIP
EA.zip (4191.11 KB)
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores
Aprendizaje automático y Data Science (Parte 12): ¿Es posible tener éxito en el mercado usando redes neuronales de autoaprendizaje? Aprendizaje automático y Data Science (Parte 12): ¿Es posible tener éxito en el mercado usando redes neuronales de autoaprendizaje?
Probablemente mucha gente esté cansada de intentar predecir el mercado bursátil constantemente. ¿No le gustaría tener una bola de cristal que le ayudara a tomar decisiones de inversión más informadas? Las redes neuronales de autoaprendizaje podrían ser su solución. En este artículo, analizaremos si estos potentes algoritmos pueden ayudarnos a "subirnos a la ola" y ser más astutos que el mercado bursátil. Mediante el análisis de grandes cantidades de datos y la identificación de patrones, las redes neuronales de autoaprendizaje pueden hacer predicciones que a menudo resultan más precisas que las realizadas por los tráders. Veamos si estas tecnologías de vanguardia pueden usarse para tomar decisiones de inversión inteligentes y ganar más.
Redes neuronales: así de sencillo (Parte 36): Modelos relacionales de aprendizaje por refuerzo (Relational Reinforcement Learning) Redes neuronales: así de sencillo (Parte 36): Modelos relacionales de aprendizaje por refuerzo (Relational Reinforcement Learning)
En los modelos de aprendizaje por refuerzo analizados anteriormente, usamos varias opciones de redes convolucionales que pueden identificar varios objetos en los datos originales. La principal ventaja de las redes convolucionales es su capacidad de identificar objetos independientemente de la ubicación de estos. Al mismo tiempo, las redes convolucionales no siempre son capaces de hacer frente a diversas deformaciones de los objetos y al ruido. Pero estos problemas pueden resolverse usando el modelo relacional.
Aprendizaje automático y Data Science (Parte 13): Analizamos el mercado financiero usando el análisis de componentes principales (ACP) Aprendizaje automático y Data Science (Parte 13): Analizamos el mercado financiero usando el análisis de componentes principales (ACP)
Hoy intentaremos mejorar cualitativamente el análisis de los mercados financieros utilizando el Análisis de Componentes Principales (ACP). Asimismo, aprenderemos cómo este método puede ayudarnos a identificar patrones ocultos en los datos, detectar tendencias ocultas del mercado y optimizar las estrategias de inversión. En este artículo veremos cómo el método de ACP aporta una nueva perspectiva al análisis de datos financieros complejos, ayudándonos a ver ideas que hemos pasado por alto con los enfoques tradicionales. ¿La aplicación del método ACP en estos mercados financieros ofrece una ventaja competitiva y ayuda a ir un paso por delante?
Algoritmos de optimización de la población: Algoritmo del mono (Monkey algorithm, MA) Algoritmos de optimización de la población: Algoritmo del mono (Monkey algorithm, MA)
En este artículo analizaremos el algoritmo de optimización "Algoritmo del Mono" (MA). La capacidad de estos ágiles animales para superar obstáculos complicados y alcanzar las copas de los árboles más inaccesibles fue la base de la idea del algoritmo MA.