Experimentos con redes neuronales (Parte 1): Recordando la geometría

Introducción

Buenas tardes, estimados usuarios de la comunidad MQL5. En este artículo, querría compartir varios experimentos con redes neuronales.  Después de leer una gran cantidad de información disponible sobre MQL5, he llegado a la conclusión de que hay teoría más que suficiente. Tenemos a nuestra disposición muy buenos artículos, bibliotecas y códigos fuente. Sin embargo, a mi juicio, esta información no conduce a una conclusión lógica: un sistema comercial rentable. Esto es lo que intentaremos solucionar hoy juntos.

Debo advertir de inmediato que no soy un experto en este campo, ni mucho menos un escritor o un periodista, pero haré todo lo posible para expresar mis pensamientos de una forma accesible, por así decirlo, para compartir mi experiencia.

El material está diseñado esencialmente para principiantes como yo.

Al menos, lo entiendo así. Las bases

Casi en todas partes se argumenta que las redes neuronales son buenas para reconocer patrones, y que un criterio muy importante son los datos que transferimos a la red neuronal para el entrenamiento. Quizá lo mejor sea comenzar por aquí. Usaremos la geometría, es decir, transferiremos formas geométricas a la red neuronal. Para empezar, tomaremos un perceptrón normal, cuyo ejemplo encontramos aquí (MTC Combo - asesor para MetaTrader 4). Mientras lo ponía a prueba, decidí abandonar los osciladores y usar una MA. Las pruebas con osciladores no dieron buenos resultados. Probablemente, ya sabrá que cuando el precio sube y el oscilador baja, se produce la llamada divergencia. Los indicadores de MA están más cerca del precio en sí.

Figuras y líneas

Vamos a tomar como base dos indicadores de media móvil con los parámetros 1 y 24, y aplicar el método Simple a Close. Es decir, la idea consiste en trasladar a la red neuronal no solo la posición actual de los indicadores, sino también el estado en el que se encontraban antes del estado actual. En muchos ejemplos que he visto, el precio se transmite directamente a la red neuronal, lo cual considero absolutamente erróneo. 

Vamos a transmitir todos los valores en puntos, cosa también muy importante: estos valores tienen un cierto rango que no pueden rebasar. No tiene sentido simplemente transmitir el precio a la red neuronal, el precio puede variar en diferentes rangos durante 10 años, por ejemplo. Además, no hay que olvidar que podemos usar una cantidad diferente de lecturas de los indicadores en la construcción de figuras. Las figuras pueden ser complejas o simples. A continuación, mostramos ejemplos de posibles variantes. Por supuesto, el lector podrá crear la suya propia.

 Figura 1: líneas simples

 Distancias en puntos en la vela cerrada 1, 4, 7 y 10 entre MA 1 y MA 24.

double perceptron1() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In2[1])/Point();
   double a2 = (ind_In1[4]-ind_In2[4])/Point();
   double a3 = (ind_In1[7]-ind_In2[7])/Point();
   double a4 = (ind_In1[10]-ind_In2[10])/Point();
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Figura 2: líneas simples

Distancias en puntos entre la vela cerrada 1-4, 4-7 y 7-10 de MA 1.

double perceptron2() 
  {
   double w1 = y1 - 100.0;
   double w2 = y2 - 100.0;
   double w3 = y3 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[4])/Point();
   double a2 = (ind_In1[4]-ind_In1[7])/Point();
   double a3 = (ind_In1[7]-ind_In1[10])/Point();
   
   return (w1 * a1 + w2 * a2 + w3 * a3);
  }

Figura 3: líneas simples

Distancias en puntos entre la vela cerrada 1-4, 4-7 y 7-10 del indicador MA 24.

double perceptron3() 
  {
   double w1 = z1 - 100.0;
   double w2 = z2 - 100.0;
   double w3 = z3 - 100.0;
   
   double a1 = (ind_In2[1]-ind_In2[4])/Point();
   double a2 = (ind_In2[4]-ind_In2[7])/Point();
   double a3 = (ind_In2[7]-ind_In2[10])/Point();
   
   return (w1 * a1 + w2 * a2 + w3 * a3);
  }

Figura 4: mariposa (envoltorio)

Distancias en puntos entre la vela cerrada 1-10 de MA 1. Y la distancia en puntos entre la vela cerrada 1-10 de MA 24.  Distancia en puntos entre la vela 1 de MA 1 y la vela 10 de MA 24. La distancia en puntos entre la vela 1 de MA 24 y la vela 10 de MA 1. El resultado es una mariposa. Como resultado, se obtiene una mariposa.

double perceptron4() 
  {
   double w1 = f1 - 100.0;
   double w2 = f2 - 100.0;
   double w3 = f3 - 100.0;
   double w4 = f4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[10])/Point();
   double a2 = (ind_In2[1]-ind_In2[10])/Point();
   double a3 = (ind_In1[1]-ind_In2[10])/Point();
   double a4 = (ind_In2[1]-ind_In1[10])/Point();
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Figura 5: cuadrilátero

Las distancias en puntos entre la vela cerrada 1-1, 10-10 entre los indicadores. Y la distancia en puntos entre 1-10 del indicador MA 1 y la distancia en puntos entre 1-10 del indicador MA 24. El resultado será un cuadrilátero.

double perceptron5() 
  {
   double w1 = c1 - 100.0;
   double w2 = c2 - 100.0;
   double w3 = c3 - 100.0;
   double w4 = c4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[10])/Point();
   double a2 = (ind_In2[1]-ind_In2[10])/Point();
   double a3 = (ind_In1[1]-ind_In2[1])/Point();
   double a4 = (ind_In1[10]-ind_In2[10])/Point();
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Figura 6: compleja

Aquí combinaremos todas las figuras anteriores en una compleja.

double perceptron6() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;  
   
   double w5 = y1 - 100.0;
   double w6 = y2 - 100.0;
   double w7 = y3 - 100.0;
   
   double w8 = z1 - 100.0;
   double w9 = z2 - 100.0;
   double w10 = z3 - 100.0;
  
   double w11 = f1 - 100.0;
   double w12 = f2 - 100.0;
   double w13 = f3 - 100.0;
   double w14 = f4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In2[1])/Point();
   double a2 = (ind_In1[4]-ind_In2[4])/Point();
   double a3 = (ind_In1[7]-ind_In2[7])/Point();
   double a4 = (ind_In1[10]-ind_In2[10])/Point();  
   
   double a5 = (ind_In1[1]-ind_In1[4])/Point();
   double a6 = (ind_In1[4]-ind_In1[7])/Point();
   double a7 = (ind_In1[7]-ind_In1[10])/Point();
   
   double a8 = (ind_In2[1]-ind_In2[4])/Point();
   double a9 = (ind_In2[4]-ind_In2[7])/Point();
   double a10 = (ind_In2[7]-ind_In2[10])/Point();
   
   double a11 = (ind_In1[1]-ind_In1[10])/Point();
   double a12 = (ind_In2[1]-ind_In2[10])/Point();
   double a13 = (ind_In1[1]-ind_In2[10])/Point();
   double a14 = (ind_In2[1]-ind_In1[10])/Point(); 
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4   +   w5 * a5 + w6 * a6 + w7 * a7   +   w8 * a8 + w9 * a9 + w10 * a10   +   w11 * a11 + w12 * a12 + w13 * a13 + w14 * a14);
  }

Ángulos

Vamos a analizar otro método muy interesante para transferir datos de precios a un perceptrón. A saber, los ángulos de inclinación de los indicadores. Estos datos tampoco podrán ir más allá de un cierto rango, lo cual resulta bastante adecuado a la hora de transferir una determinada plantilla, al igual que en el caso anterior con las figuras y las líneas. 

Me he encontrado con muchos métodos para determinar ángulos, pero muchos de ellos dependen de la escala del gráfico de precios, la cual no resulta adecuada para nosotros. La solución consiste en calcular no el ángulo, sino la tangente del ángulo, usando para ello la relación entre el número de puntos y el número de barras. La tangente del ángulo tg(α) es la relación entre el cateto opuesto a y el cateto adyacente b.

También podemos usar un número diferente de indicadores, procesar estructuras complejas y utilizar un número distinto de velas japonesas para el análisis. En las capturas de pantalla, los ángulos de inclinación se muestran como líneas no fijas. Veamos algunos ejemplos.

Perceptront1. 3 ángulos de inclinación del indicador MA 1

Inclinación del indicador MA 1 entre las velas 1-4, entre las velas 1-7, entre las velas 1-10. 

double perceptront1() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[4])/4;
   double a2 = (ind_In1[1]-ind_In1[7])/7;
   double a3 = (ind_In1[1]-ind_In1[10])/10;

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

Perceptront2. 4 ángulos de inclinación de los indicadores MA 1 y MA 24

La inclinación del indicador MA 1 entre las velas 1-5, entre las velas 1-10.  La inclinación del indicador MA 24 entre las velas 1-5, entre las velas 1-10.

double perceptront2() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[5])/5;
   double a2 = (ind_In1[1]-ind_In1[10])/10;
   double a3 = (ind_In2[1]-ind_In2[5])/5;
   double a4 = (ind_In2[1]-ind_In2[10])/10;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Perceptront3. 4 ángulos de los indicadores MA 1 y MA 24 (diseño más o menos complejo, para el ejemplo)

Los ángulos están ligados por la inclinación entre los dos indicadores, MA 1 y MA 24.

double perceptront3() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[10])/10;
   double a2 = (ind_In2[1]-ind_In1[4])/4;
   double a3 = (ind_In2[1]-ind_In1[7])/7;
   double a4 = (ind_In2[1]-ind_In1[10])/10;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Perceptront4. 4 ángulos de los indicadores MA 1 y MA 24 (diseño más o menos complejo, para el ejemplo)

Los ángulos están ligados por la inclinación entre los dos indicadores, MA 1 y MA 24.

double perceptront4() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   
   double a1 = (ind_In1[1]-ind_In1[10])/10;
   double a2 = (ind_In2[1]-ind_In1[10])/10;
   double a3 = (ind_In1[1]-ind_In1[10])/10;
   double a4 = (ind_In2[1]-ind_In2[10])/10;
   
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }

Estrategia

Con fines didácticos, he decidido usar una estrategia opuesta a la tendencia, indicando explícitamente en el código a continuación. Para la venta, el indicador MA 1 en la primera vela estará por encima del indicador MA 24. Para la compra, todo será lo opuesto. Partiendo de mis observaciones, esto es necesario para separar claramente las ventas y las compras. Puede hacer lo contrario: usar la tendencia.

También podrá utilizar otros indicadores o sus valores, como el indicador TEMA. Resulta casi imposible predecir el precio de un movimiento de 400 puntos con cinco dígitos, nadie sabe a dónde irá el mercado. Por lo tanto, para realizar la prueba, he establecido un stop loss fijo de 600 puntos y un take profit de 60 puntos con cinco dígitos. Para no sobrecargar el artículo con líneas innecesarias y que usted no se pierda su sentido, podrá descargar asesores listos para usar en los archivos adjuntos. Veamos los resultados.

//SELL++++++++++++++++++++++++++++++++++++++++++++++++

if ((CalculatePositions(symbolS1.Name(), Magic, POSITION_TYPE_SELL, EAComment)==0) && (ind_In1[1]>ind_In2[1]) && (perceptron1()<0) &&(SpreadS1<=MaxSpread)){//v1
  OpenSell(symbolS1.Name(), LotsXSell, TakeProfit, StopLoss, EAComment);
}

//BUY++++++++++++++++++++++++++++++++++++++++++++++++

if ((CalculatePositions(symbolS1.Name(), Magic, POSITION_TYPE_BUY, EAComment)==0) && (ind_In1[1]<ind_In2[1]) && (perceptron1()>0) && (SpreadS1<=MaxSpread)){//v1
  OpenBuy(symbolS1.Name(), LotsXBuy, TakeProfit, StopLoss, EAComment);
}

Optimización, prueba y recursos

La optimización de las redes neuronales, como ya sabemos, requiere grandes recursos informáticos. Por lo tanto, al usar el simulador de estrategias para estos fines, le recomiendo el modo (Solo precios de apertura) con una indicación explícita de los precios de cierre en el propio código, de lo contrario, esta no será una tarea factible, dada la modestia de nuestras capacidades. Pero incluso con estos modos de optimización, le recomiendo el servicio (Cloud Network). El objetivo de la optimización es encontrar con la ayuda de nuestros perceptrones ciertos patrones que nos ayuden a obtener beneficios. En nuestro caso, la aparición de tales patrones, es decir, el número de transacciones rentables, debería ser un orden de magnitud mayor que las no rentables. Todo dependerá de la proporción de StopLoss respecto a TakeProfit.

De cara al futuro, diré que he realizado 10 optimizaciones de cada asesor continuamente. Lo que ocurre es que hay muchos valores de optimización, lo cual provoca resultados de alrededor de 10 000-15 000 por pasada en el modo (Algoritmo genético). En consecuencia, cuantas más pasadas realicemos, más posibilidades tendremos de encontrar los valores deseados de los coeficientes de peso. Este problema deberá resolverse usando MQL5. Realmente, no quiero renunciar al simulador de estrategias.

El paso de 5 valores de optimización (en contraste con el artículo anterior, donde el paso era de 1), no fue elegido por casualidad. Durante los experimentos, noté que esto provoca resultados más dispersos en los pesos del perceptrón, lo cual tiene un mejor efecto en los resultados.

Optimización del asesor 1 perceptron 1 figure. Con una figura de líneas sencillas. (Un perceptrón con una figura).

• Fecha de optimización: de 2010.05.31 a 2021.05.31.
• Modalidades (Solo precios de apertura), (Algoritmo genético), (Máxima rentabilidad) .
• Depósito inicial 10000.
• TakeProfit = 60, StopLoss = 600.
• Periodo H1.
• Lote fijo 0.01.
• Parámetros optimizados x1, x2, x3, x4: coeficientes de peso del perceptrón. Optimizado por valores de 0 a 200, en incrementos de 5.

 

Resultados de la optimización y pruebas forward.

Como puede ver, los resultados son horribles. El mejor resultado es 0,87. Carece de sentido hacer pruebas directas. Seguimos.

Optimizamos el asesor 1 perceptron 4 figure. (Un perceptrón con cuatro figuras).

• Fecha de optimización: de 2010.05.31 a 2021.05.31.
• Modalidades (Solo precios de apertura), (Algoritmo genético), (Máxima rentabilidad) .
• Depósito inicial 10000.
• TakeProfit = 60, StopLoss = 600.
• Periodo H1.
• Lote fijo 0.01.
• Parámetros optimizados x1, x2, x3, x4, y1, y2, y3, z1, z2, z3, f1, f2, f3, f4: coeficientes de peso del perceptrón. Optimizado por valores de 0 a 200, en incrementos de 5.

 

Resultados de la optimización y pruebas forward.

El resultado es muy parecido al anterior. El mejor resultado es 0,94.

Optimizamos el asesor 4 perceptron 4 figure. (Cuatro perceptrones con cuatro figuras diferentes).

 El código principal tiene el aspecto siguiente:

//SELL++++++++++++++++++++++++++++++++++++++++++++++++

if ((CalculatePositions(symbolS1.Name(), Magic, POSITION_TYPE_SELL, EAComment)==0) && (ind_In1[1]>ind_In2[1]) && (perceptron1()<0) && (perceptron2()<0) && (perceptron3()<0) && (perceptron4()<0) && (SpreadS1<=MaxSpread)){//v1
  OpenSell(symbolS1.Name(), LotsXSell, TakeProfit, StopLoss, EAComment);
}

//BUY++++++++++++++++++++++++++++++++++++++++++++++++

if ((CalculatePositions(symbolS1.Name(), Magic, POSITION_TYPE_BUY, EAComment)==0) && (ind_In1[1]<ind_In2[1]) && (perceptron1()>0) && (perceptron2()>0) && (perceptron3()>0) && (perceptron4()>0) && (SpreadS1<=MaxSpread)){//v1
  OpenBuy(symbolS1.Name(), LotsXBuy, TakeProfit, StopLoss, EAComment);
}

• Fecha de optimización: de 2010.05.31 a 2021.05.31.
• Modos (Solo precios de apertura), (Algoritmo genético), (Criterio complejo máximo) .
• Depósito inicial 10000.
• TakeProfit = 200, StopLoss = 200.
• Periodo H1.
• Lote fijo 0.01.
• Parámetros optimizados x1, x2, x3, x4, y1, y2, y3, z1, z2, z3, f1, f2, f3, f4: coeficientes de peso del perceptrón. Optimizado por valores de 0 a 200, en incrementos de 5.

Resultados de optimización y pruebas forward.

Fecha de la prueba forward: del 2021.05.31 al 2022.05.31. De los resultados, debemos elegir aquel en el que el mayor factor de beneficio con el criterio complejo máximo sea superior a 40-50.

• Fecha de optimización: de 2010.05.31 a 2021.05.31.
• Modalidades (Solo precios de apertura), (Algoritmo genético), (Máxima rentabilidad).
• Depósito inicial: 10 000.
• Take Profit = 60, Stop Loss = 600
• Periodo H1.
• Lote fijo 0.01.
• Parámetros optimizados x1, x2, x3, x4, y1, y2, y3, z1, z2, z3, f1, f2, f3, f4: coeficientes de peso del perceptrón. Optimizado por valores de 0 a 200, en incrementos de 5.

 

Resultados de la optimización y pruebas forward.

Hemos obtenido el resultado. El mejor es 32. Vamos a cambiar la fecha de 2021.05.31 a 2022.05.31 y realizar pruebas forward. De los resultados, debemos elegir aquel en el que el mayor factor de beneficio con el menor número de transacciones sea superior a 10-20.

Vamos a optimizar la tangente del asesor 4 perceptron 4 tangent. (Cuatro perceptrones con cuatro ángulos diferentes).

• Fecha de optimización: de 2010.05.31 a 2021.05.31.
• Modos (Solo precios de apertura), (Algoritmo genético), (Criterio complejo máximo).
• Depósito inicial 10000.
• TakeProfit = 200, StopLoss = 200.
• Periodo H1.
• Lote fijo 0.01.
• Parámetros optimizados x1, x2, x3, x4, y1, y2, y3, z1, z2, z3, f1, f2, f3, f4: coeficientes de peso del perceptrón. Optimizado por valores de 0 a 200, en incrementos de 5.

Resultados de la optimización y las pruebas forward.

Fecha de la prueba forward: del 2021.05.31 al 2022.05.31. De los resultados, debemos elegir aquel en el que el mayor factor de beneficio con el criterio complejo máximo sea superior a 20-40.

• Fecha de optimización: de 2010.05.31 a 2021.05.31.
• Modalidades (Solo precios de apertura), (Algoritmo genético), (Máxima rentabilidad).
• Depósito inicial: 10 000.
• TakeProfit = 60, StopLoss = 600.
• Periodo H1.
• Lote fijo 0.01.
• Parámetros optimizados x1, x2, x3, x4, y1, y2, y3, z1, z2, z3, f1, f2, f3, f4: coeficientes de peso del perceptrón. Optimizado por valores de 0 a 200, en incrementos de 5.

 

Resultados de la optimización y pruebas forward.

Hemos obtenido el resultado. El mejor es 32. Le dejaré las pruebas forward como tarea para casa. Creo que le resultará más interesante. Además, debemos señalar que se ha incrementado el número de transacciones en relación con el factor beneficio.

 Durante mis experimentos, han surgido varios problemas que necesitan ser resueltos. A saber:

• Primero. Debido a que la optimización de tal cantidad de parámetros resulta complicada, debemos trasladar estos parámetros dentro del código del asesor. Es decir, los parámetros de los coeficientes de peso.
• Segundo. Debemos crear una determinada base de datos para todos los parámetros optimizados y utilizar estos en el asesor experto para comerciar simultáneamente. Creo que será posible utilizar archivos como .CSV.

Conclusión

Realmente espero que mis experimentos abran los ojos del lector a nuevos descubrimientos, que lo ayuden a reflexionar y, finalmente, a alcanzar el éxito. Al inicio del artículo, nos marcamos la meta de obtener una estrategia rentable lista para usar. En parte, lo hemos logrado al obtener buenos resultados en las pruebas forward. Pero, ¿qué hacemos con lo que ha resultado? Todavía queda mucho trabajo por delante. Deberemos pasar a sistemas más complejos, sin olvidar la experiencia adquirida. También deberemos aprovechar nuestras habilidades en un sentido más amplio. Sobre esto y mucho más, hablaremos en la segunda parte de nuestros experimentos. Será interesante. No se lo pierda.