Trading automatizado atípico

Leonid Borsky | 30 marzo, 2016

Introducción

Trading eficaz y cómodo con la plataforma MT4 sin análisis detallado del mercado: ¿es posible? ¿Se puede llevar a cabo un trading así?

Supongo que sí.

¡Especialmente en términos de trading automatizado! MQL4 permite hacerlo. El sistema de trading automatizado descrito a continuación se caracteriza por una buena repetibilidad. E incluso quienes estén empezando a familiarizarse con la escritura de Asesores expertos pueden ejecutarlo.

El sistema en sí es un reflejo del mundo exterior. La vida que se desarrolla de forma harmoniosa y dicta sus leyes. Cuando somos niños, observamos la siguiente escena: hormigas cargando una paja de un lado a otro y metiéndola en un hormiguero. Y cada hormiga tira del palo hacia su lado. Sin embargo, ¡al final la paja acaba yendo hacia el hormiguero! ¿Un secreto de la naturaleza? Intentemos simular la situación en una plataforma de trading.

Trading automatizado atípico

Suponga que tenemos un sistema de trading automatizado de tipo rentable. El sistema tiene los siguientes requisitos:

  1. Las señales de entrada son prácticamente aleatoria.
  2. El sistema está constantemente en el mercado, es decir, funciona con posiciones dirigidas por contadores en lugar de paradas: es importante.
  3. Utilizando varios parámetros estáticos, ubicados en la entrada, se optimiza el sistema para conseguir una rentabilidad máxima con una reducción razonable.

Este sistema dará, prácticamente, un beneficio anual de +3 000 puntos, incluso sin el bloque de Gestión monetaria. Tras esto, habilitamos el sistema en modo invertido. En otras palabras, ahora puede funcionar de la siguiente manera:

  1. Si estuviéramos comprando en modo directo, ahora estaríamos vendiendo, y viceversa. Tras eso, optimizamos el sistema una vez más utilizando parámetros estáticos. Y al salir de la versión invertida, obtenemos el máximo beneficio con una reducción razonable. No debería causar ningún problema porque el sistema de trading automatizado está construido originalmente en entradas aleatorias.
  2. A continuación, iniciamos las dos versiones simultáneamente: en la versión directa y en la invertida. El funcionamiento simultáneo de las dos versiones es un momento clave muy importante del sistema de trading que hemos descrito.

Veamos qué tenemos.

Al iniciar simultáneamente los dos sistemas (directo e invertido), obtenemos un beneficio doble. Sin embargo, os sistemas funcionas en modo contador, es decir, opuestos el uno al otro de forma deliberada, no al azar. Además, se ha reducido el total de pérdidas: la reducción relativa actual. Y, ¿por qué los sistemas funcionan de forma deliberada y no al azar?

La razón es que, por los otros parámetros estáticos que ya están en los trades tres-cuatro, el sistema invertido hará el trading con algún cambio en la hora y el precio, si se comparación el sistema directo. Además, la entrada del algoritmo en el modo invertido es la misma.

Pero el beneficio total aumentará progresivamente. Creo que es obvio, siempre que los dos sistemas (directo e invertido) se optimicen para un funcionamiento rentable. Es más, las pérdidas actuales de una de las versiones, estarán prácticamente cubiertas por el beneficio actual de la otra versión. Como consecuencia, conseguiremos el máximo beneficio y la reducción mínima.

Una de los inconvenientes es el aumento del margen requerido. Pero, ¿se le puede llamar a esto inconveniente? En realidad hay dos sistemas de trading funcionando independientemente: directo e invertido. Y, naturalmente, el margen requerido será el doble. Y en cuanto a los riesgos, se reducirán lo suficiente. Esta es la idea principal: no aumentar los beneficios, pero dejar al mínimo las reducciones. Pero una cosa causa la otra. Y, una vez más, el beneficio total aumentará progresivamente en un trading como este. Como consecuencia, se puede habilitar el bloque de Gestión monetaria.

La página web MQL4.community contiene una amplia gama de diferentes Asesores expertos, incluso los que tienen los requisitos anotados arriba. Es el propio mercado el que nos hace crear nuevas tareas y encontrar soluciones diferentes y atípicas. También se pueden encontrar posibilidades para una búsqueda futura.

Para la realización de esta idea y de los experimentos que la siguieron, se utilizó un Asesor experto de "Inteligencia artificial" de Yury Reshetov como base, drescrito anteriormente en el mismo punto (vea el artículo "Cómo encontrar un sistema de trading rentable" de Y. Reshetov). Se utilizó con algunos arreglos y suplementos. En particular, incluye una opción de llamada a otro indicador básico para la operación de Perceptron. También tiene algunas condiciones adicionales para la apertura y futuro seguimiento de las posiciones.

Aquí hay algunos resultados del experimento, obtenidos durante la prueba del par GBPUSD en el periodo de tiempo H1. El depósito de inicio es 10 000 unidades. Historial de 2,5 años: desde enero de 2005 hasta mayo de 2007.

La versión directa tenía 250 trades en este periodo. La invertida tenía 360 trades. El número de trades es diferente porque el nivel de stoploss durante la optimización era diferente para cada versión. El beneficio neto en ambos casos es de +10 000, aproximadamente. Durante el funcionamiento con un lote 0.1, y sin habilitar el bloque de Gestión monetaria, los trades rentables y no rentables están en un ratio de 3:2 en ambas versiones.

Aquí están los ejemplos de los gráficos de balance/equidad de las versiones directa e invertida en el historial:

Como puede ver, en la mayoría de los casos, los trades no rentables de la versión directa están cubiertos por trades rentables en la versión invertida. Y viceversa: las pérdidas de la versión invertida están cubiertos por los beneficios de la versión directa.

Además, cuando un gráfico está plano, el otro tiene tendencia positiva. Al final se obtiene el beneficio máximo con los mínimos riesgos, es decir, con la reducción mínima. No causará ningún problema reunir el historial de todos los trades en Excel y dibujar el gráfico resultante que muestre la idea descrita.

El siguiente paso es habilitar el bloque de Gestión monetaria. Se puede esperar que, al habilitar este bloque durante un trading así, mejorará significativamente los resultados finales en términos de beneficios, reducciones y comodidad del trading. En las versiones directas e invertidas, incluí una llamada a la biblioteca de cálculo de lotes "b-lots". Se incluye fácilmente en el código fuente y funciona bastante bien. https://www.mql5.com/es/code/8048

Durante la prueba, utilicé un método proporcionado de cálculo de lotes (LotsWayChoice=2), que proporcionan la reducción mínima razonable con unos beneficios relativamente buenos (Ryan Jones, "El juego de trading: jugar con los números para ganar millones"). Los resultados son bastante buenos si se comparan con otros métodos de cálculo de lotes que a menudo muestran grandes beneficios con grandes reducciones.

Volvamos al mismo historial, de enero de 2005 a mayo de 2007. Los resultados de la prueba con los mismos parámetros de antes:

Versión invertida:

Versión directa:

Aquí están los gráficos de balance:

Estos gráficos también muestran muy bien cómo los beneficios de la versión invertida cubre las pérdidas actuales. Creo que es evidente el por qué usar un trading como este.

Uso práctico

Como ejemplo y para futuros experimentos, aquí hay un código de una versión invertida que funciona al contrario de la versión directa de la variante del Asesor experto "IA" de Y. Reshetov. Hay una versión directa con su descripción en: https://www.mql5.com/ru/code/10289

Además de esto, el archivo adjunto contiene el indicador Perceptron (el autor: NoName, de Ukrania, Kremenchug), que permite controlar visualmente el trabajo actual del Asesor experto (directo e invertido), y conoce de antemano en qué dirección se abrirá una nueva posición. Aquí se establecen los valores de los coeficientes de peso X1-X4 del indicador Perceptron iguales a los valores del Asesor experto correspondiente. Aquí un ejemplo de la versión invertida:

Para aquellos que acaban de empezar a trabajar con MQL4, intenté ofrecer el máximo de comentarios posible sobre el funcionamiento del AE. Las salidas del perceptron en el funcionamiento de esta versión invertida se muestran en el gráfico, en la esquina superior izquierda. 

//+------------------------------------------------------------------+
//|                                 ArtificialIntelligenceRevers.mq4 |
//|                               Copyright й 2006, Yury V. Reshetov |
//|                                Modifed by   Leonid553            |
//|                                  http://www.tradersforum.net.ru/ | 
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright й 2006, Yury V. Reshetov ICQ:282715499"
#property link      "http://reshetov.xnet.uz/"
//---- input parameters
extern int    x1 = 88;
extern int    x2 = 172;
extern int    x3 = 39;
extern int    x4 = 172;
// StopLoss level
extern double sl = 50;
extern double lots = 0.1;
extern int    MagicNumber = 808;
static int prevtime = 0;
static int spread = 3;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
     Comment(perceptron());   
// Wait for the formation of a new candlestick
// If a new candlestick appears, check for the possibility of a trade 
   if(Time[0] == prevtime) return(0);
   prevtime = Time[0];
//----
   if(IsTradeAllowed()) 
     {
       spread = MarketInfo(Symbol(), MODE_SPREAD);
     } 
   else 
     {
       prevtime = Time[1];
       return(0);
     }
   int ticket = -1;
   // check for opened position
   int total = OrdersTotal();   
   for(int i = 0; i < total; i++) 
     {
       OrderSelect(i, SELECT_BY_POS, MODE_TRADES); 
       // check for symbol & magic number
       if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) 
         {
           int prevticket = OrderTicket();
           // long position is opened
           if(OrderType() == OP_BUY) 
              // if a long position is opened and ...
             {
               // check profit 
               // the current profit is larger than the value of =(stoploss + spread) and ...
               if(Bid > (OrderStopLoss() + (sl * 2  + spread) * Point)) 
                 {               
                   if(perceptron() > 0) 
                     { 
                       // perceptron is more than zero, then turn to Sell
                       // reverse
                       ticket = OrderSend(Symbol(), OP_SELL, lots * 2, Bid, 3, 
                         Ask + sl * Point, 0, "AI", MagicNumber, 
                                          0, Red); 
                       Sleep(30000);
                       if(ticket < 0) 
                         {
                           prevtime = Time[1];
                         } 
                       else 
                         {
                           OrderCloseBy(ticket, prevticket, Blue);   
                         }
                     } 
                   else 
//if perceptron is less than zero, trail the stoploss to the distance =sl 
//from the current price                 
  { 
                       // trailing stop
                       if(!OrderModify(OrderTicket(), OrderOpenPrice(), 
                          Bid - sl * Point, 0, 0, Blue)) 
                         {
                           Sleep(30000);
                           prevtime = Time[1];
                         }
                     }
                 }  
               // short position is opened
             } 
           else 
             {
               // if a short position is opened and ...
               // check profit 
              if(Ask < (OrderStopLoss() - (sl * 2 + spread) * Point)) 
                 {
                  // the current profit is larger than the value of =(stoploss + spread) and ...
                   if(perceptron() < 0) 
                     { 
                       // perceptron is less than zero, then turn to Buy
                       // reverse
                       ticket = OrderSend(Symbol(), OP_BUY, lots * 2, Ask, 3, 
                           Bid - sl * Point, 0, "AI", MagicNumber,
                                          0, Blue); 
                       Sleep(30000);
                       if(ticket < 0) 
                         {
                           prevtime = Time[1];
                         } 
                       else 
                         {
                           OrderCloseBy(ticket, prevticket, Blue);   
                         }
                     } 
                   else 
//if perceptron is more than zero, trail the stoploss to the distance =sl 
//from the current price
                   { 
                       // trailing stop
                       if(!OrderModify(OrderTicket(), OrderOpenPrice(), 
                          Ask + sl * Point, 0, 0, Blue)) 
                         {
                           Sleep(30000);
                           prevtime = Time[1];
                         }  
                     }
                 }  
             }
           // exit
           return(0);
         }
     }
//********************************************************************
   // check for long or short position possibility
   // initial entrance to the market:
 
   if(perceptron() < 0) 
     { 
       // if the perceptron is less than zero, open a long position :
       // long
       ticket = OrderSend(Symbol(), OP_BUY, lots, Ask, 3, Bid - sl * Point, 0, 
                      "AI", MagicNumber, 0, Blue); 
       if(ticket < 0) 
         {
           Sleep(30000);
           prevtime = Time[1];
         }
     } 
   else 
     // if the perceptron is more than zero, open a short position:
     { 
       // short
       ticket = OrderSend(Symbol(), OP_SELL, lots, Bid, 3, Ask + sl * Point, 0, 
                      "AI", MagicNumber, 0, Red); 
       if(ticket < 0) 
         {
           Sleep(30000);
           prevtime = Time[1];
         }
     }
//--- exit
   return(0);
  }
//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   double a1 = iAC(Symbol(), 0, 0);
   double a2 = iAC(Symbol(), 0, 7);
   double a3 = iAC(Symbol(), 0, 14);
   double a4 = iAC(Symbol(), 0, 21);
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }
//+------------------------------------------------------------------+}

Sin embargo, hay que tener en cuenta que el objetivo principal de la táctica de trading que se ha descrito no está en este Asesor experto en particular. Sino que, al contrario, está en la cooperación de las versiones directas e invertidas de cualquier Asesor experto apropiado, como se explicó al principio del artículo. Y aquí están las diferentes variables posibles: puede tener varias versiones invertidas: creadas y optimizadas con diferentes criterios, de acuerdo con el algoritmo inicial de la versión directa. Hay muchas opciones.

Para seguir trabajando con esta idea, proporcionaré apoyo de dibujo y líneas de resistencia. O adjunto el indicador MA o cualquier otro indicador adecuado para el gráfico de balance. En este caso, según las señales del indicador, se podía manejar de algún modo la prohibición de trades en cada versión. Creo que es programable.

Pero es sólo un prospecto.


Conclusión

Se pueden presuponer las protestas de los escépticos: ¿Y si las dos veriones empiezan a funcionar con pérdidas?

Bueno, esto puede ocurrir en casos muy raros y excepcionales. Pero no más que eso: "nada es perfecto en este mundo" Sin embargo, en entradas prácticamente accidentales, ambas versiones funcionan a las señales de un indicador y en direcciones contadas: ¡una contra la otra!

Al combinar ambas versiones en un Asesor experto, se obtendrá una herramienta eficiente para una gestión futura de un portfolio de trading. Y para experimentos futuros.