Descargar MetaTrader 5

Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots (continuación)

6 enero 2016, 09:51
Nikolay Kositsin
0
266

Introducción

La optimización de sistemas de trading es un tema ampliamente discutido en la literatura, de modo que no tiene mucho sentido reescribirlo en este espacio porque uno puede encontrar fácilmente información abundante sobre el mismo en Internet. Así que solamente vamos a analizar los detalles de algunas ideas fundamentales con el objetivo de descubrir la lógica subyacente, y también optimizaremos nuestros sistemas automáticos con los resultados obtenidos.

Supongo que ya sabe cómo cargar un Asesor Experto en el Probador de Estrategias, y que puede optimizarlo con los datos históricos hasta obtener resultados increíbles en las pruebas de backtesting. Llegados pues a este punto surge la siguiente pregunta. ¿Cómo se relaciona el resultado de un sistema automático con su comportamiento, sobre todo cuando el resultado obtenido es excelente, pero se consigue cuando se ajustan los datos históricos al sistema?

Esta pregunta es muy importante. Lo cierto es que las primeras optimizaciones exitosas realizadas por desarrolladores principiantes de EAs, suelen inducir un uso irreflexivo de los sistemas comerciales. En efecto, el principiante puede hacerse una idea equivocada del trading real, lo que derivará en consecuencias perjudiciales. Los programadores inexpertos de Asesores Expertos corren el riesgo de perder su dinero, o bien el dinero de aquellos que utilizan sus programas. Así que empezaré mi artículo tratando este tema.


Pruebas de optimización de resultados (backtesting), pero sin fanatismo

Generalmente, las primeras experiencias de optimización de EA invitan a querer construir estrategias que buscan el máximo beneficio, con descensos mínimos. El programador sin experiencia esperará que su sistema se comporte de forma óptima con cualquier parámetro de entrada, no solo en el periodo de optimización, sino también en el futuro. Esto se puede representar esquemáticamente de esta manera:


Esta es la lógica empleada por la mayoría de programadores de EA tras su primer contacto con el Probador de Estrategias de trading. Pero nada más lejos de la realidad. Lamentablemente no podemos predecir el futuro y definir la eficiencia de un sistema aplicando esta lógica. Por otro lado, es muy tedioso probar una determinada estrategia en una cuenta demo, en tiempo real, simulando el mercado real, y almacenar los resultados de las operaciones.

Claro que si alguien tiene la suficiente paciencia como para comprobar los resultados durante años, ¡entonces no hay ningún problema! Pero como después de un tiempo los sistemas de trading pueden volverse inutilizables, sería decepcionante malgastar tanto tiempo y ancho de banda en conexiones a Internet. Por otra parte, este enfoque no permite probar muchas estrategias comerciales. Como mucho una o dos. Y por último, probar estrategias así impide que los creadores de robots puedan estimar sus resultados de forma crítica.

Aunque en tales situaciones es difícil afrontar la realidad desde un punto de vista psicológico, y admitir que la estrategia resultante es una completa pérdida de tiempo y esfuerzo. Obviamente, derrochar esfuerzo y tiempo no sirve para crear asesores expertos rentables.

En consecuencia el único camino pasa por modelar el futuro a partir de los datos históricos. En realidad es muy sencillo. Tan solo hay que desplazar a la izquierda los límites de tiempo del esquema anterior. En cuyo caso, después de ejecutar las pruebas habrá tiempo suficiente para estimar los resultados aplicados a los datos recientes, más cercanos al momento presente que los datos de la optimización.


En muchos casos, como el descrito anteriormente, este enfoque permite estimar la eficacia real de las estrategias, al utilizar los resultados de optimización en determinados Asesores Expertos con parámetros optimizados. Esquemáticamente el significado de dichos análisis de estrategias de optimización se presenta de la siguiente forma:



Supongo que el diagrama es lo suficientemente claro. Por ejemplo, tomemos como periodo de análisis el año 2007. En el primer periodo la optimización será del 01.01.2007 al 31.03.2007, y el periodo de prueba irá del 01.04.2007 al 31.05.2007. Tras realizar las pruebas y registrar los resultados, desplazamos un mes hacia adelante la optimización y los períodos de prueba. Ahora el período de optimización es del 01.02.2007 al 30.04.2007, y el periodo de prueba comprende entre el 01.05.2007 y el 30.06.2007. Y así sucesivamente. Como resultado obtenemos una tabla que registra los resultados de cada optimización, por ejemplo:


Parámetro de prueba final/Ejecución 01 02 03 04 05 06 07 08 09 10 11 12
Beneficio neto











Beneficio total











Pérdida total











Rentabilidad











Disminución absoluta











Disminución relativa











Operaciones totales












Por supuesto, después de ejecutar las optimizaciones hay que rellenar las celdas de la tabla. Analizar la tabla y procesar la información que contiene es sencillo; saque sus propias conclusiones a partir de este planteamiento. Supongo que este análisis del comportamiento del Asesor Experto, con los datos históricos disponibles, sirve para estimar correctamente los resultados de optimización del EA, y evita que uno se haga falsas expectativas. En comparación con las pruebas realizadas en una cuenta demo, ¡el tiempo ahorrado es fabuloso!

Seguro que los desarrolladores principiantes de asesores expertos entenderán sin problemas cómo funciona la técnica de backtesting, aunque esta investigación también requiere su tiempo y esfuerzo. No se disguste si obtiene resultados pobres en sus pruebas; las pérdidas virtuales son siempre preferibles a ejecutar en vivo estrategias perdedoras que parecían rentables.

Tenga esto en cuenta. Cabe señalar que seleccionar el máximo capital con la disminución mínima no es la única estrategia de optimización. Esta explicación es solo para introducir el procedimiento de backtesting. Los esfuerzos de backtesting suelen centrarse en la optimización. En efecto, probar las estrategias requiere muy poco tiempo, y conviene probar varias a la vez para producir material estadístico, para sacar conclusiones. Por lo tanto la tabla de resultados de las pruebas será más grande.


Estrategia de trading del oscilador

Tomando como base los osciladores pueden construirse un montón de estrategias diferentes. En este artículo voy a describir un sistema que consiste en entrar y salir del mercado en las zonas de sobrecompra y sobreventa:



La mayoría de osciladores varía de un determinado mínimo hasta un cierto máximo, teniendo cada oscilador sus propios valores. Los niveles UpLevel y DownLevel se colocan a cierta distancia de los extremos

En dicho sistema se produce una señal de compra si el oscilador sale de la zona de no tendencia y entra en la zona de sobrecompra:

La señal de venta ocurre cuando el oscilador abandona la zona de no tendencia, entrando en la zona de sobreventa.

Además de estas señales, que son las principales, el sistema tiene unas señales adicionales de corrección que aparecen cuando el oscilador sale de las zonas de sobreventa y sobrecompra, entrando en la zona de no tendencia.

La señal de compra se produce cuando el oscilador sale de la zona de sobreventa y entra en la zona de no tendencia, produciéndose así la corrección de una tendencia bajista:

La señal de venta sucede cuando abandona el área de sobrecompra y entra en la zona de no tendencia (corrección de una tendencia alcista):


Código del Asesor Experto que implementa el sistema de trading del oscilador

Así, tenemos cuatro algoritmos de entrada al mercado. Si observamos detenidamente las dos variantes de los algoritmos para posiciones largas, concluiremos que son absolutamente idénticas. Solo difieren en la posición de un nivel de ruptura, lo que es totalmente irrelevante desde el punto de vista de la escritura del código del programa. En las posiciones cortas sucede lo mismo. A continuación adjunto mi variante que implementa el sistema comercial del oscilador:
//+==================================================================+
//|                                                        Exp_3.mq4 |
//|                             Copyright © 2007,   Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+==================================================================+
#property copyright "Copyright © 2007, Nikolay Kositsin"
#property link "farria@mail.redcom.ru"
//----+ +--------------------------------------------------------------------------+
//---- PARÁMETROS DE ENTRADA DEL EA PARA LAS POSICIONES DE COMPRA 
extern bool   Test_Up1 = true;//filtro de dirección de cálculo
extern int    Timeframe_Up1 = 240;
extern double Money_Management_Up1 = 0.1;
extern double IndLevel_Up1 = 0.8; // nivel de ruptura del indicador
extern int    JLength_Up1 = 8;  // profundidad del suavizado JJMA de entrada de precio
extern int    XLength_Up1 = 8;  // profundidad del suavizado JurX del indicador obtenido 
extern int    Phase_Up1 = 100; // parámetro que varía en el rango -100 ... +100, 
                              // influencia en la calidad de los procesos temporales de suavizado
extern int    IPC_Up1 = 0;/* Selección de los precios donde se calcula el indicador
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 
8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High,  
13-Heiken Ashi Open, 14-Heiken Ashi Close.) */
extern int    STOPLOSS_Up1 = 50;  // stoploss
extern int    TAKEPROFIT_Up1 = 100; // takeprofit
extern int    TRAILINGSTOP_Up1 = 0; // trailing stop
extern bool   ClosePos_Up1 = true; // cierre de posición forzado permitido
//----+ +--------------------------------------------------------------------------+
///---- PARÁMETROS DE ENTRADA DEL EA PARA LAS POSICIONES DE COMPRA 
extern bool   Test_Up2 = true;//filtro de dirección de cálculo
extern int    Timeframe_Up2 = 240;
extern double Money_Management_Up2 = 0.1;
extern double IndLevel_Up2 = -0.8; // nivel de ruptura del indicador
extern int    JLength_Up2 = 8;  // profundidad del suavizado JJMA de entrada de precio
extern int    XLength_Up2 = 8;  // profundidad del suavizado JurX del indicador obtenido
extern int    Phase_Up2 = 100; // parámetro que varía en el rango -100 ... +100, 
                              //influencia en la calidad de los procesos temporales de suavizado
extern int    IPC_Up2 = 0;/* Selección de los precios donde se calcula el indicador 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 
8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High,  
13-Heiken Ashi Open, 14-Heiken Ashi Close.) */
extern int    STOPLOSS_Up2 = 50;  // stoploss
extern int    TAKEPROFIT_Up2 = 100; // takeprofit
extern int    TRAILINGSTOP_Up2 = 0; // trailing stop
extern bool   ClosePos_Up2 = true; // cierre de posición forzado permitido
//----+ +--------------------------------------------------------------------------+
//---- PARÁMETROS DE ENTRADA DEL EA PARA LAS POSICIONES DE VENTA 
extern bool   Test_Dn1 = true;// filtro de dirección de cálculo
extern int    Timeframe_Dn1 = 240;
extern double Money_Management_Dn1 = 0.1;
extern double IndLevel_Dn1 = 0.8; // nivel de ruptura del indicador
extern int    JLength_Dn1 = 8;  // profundidad del suavizado JJMA de entrada de precio
extern int    XLength_Dn1 = 8;  // profundidad del suavizado JurX del indicador obtenido 
extern int    Phase_Dn1 = 100; // parámetro que varía en el rango -100 ... +100, 
                              //influencia en la calidad de los procesos temporales de suavizado
extern int    IPC_Dn1 = 0;/* Selección de los precios donde se calcula el indicador 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 
8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High,  
13-Heiken Ashi Open, 14-Heiken Ashi Close.) */
extern int    STOPLOSS_Dn1 = 50;  // stoploss
extern int    TAKEPROFIT_Dn1 = 100; // takeprofit
extern int    TRAILINGSTOP_Dn1 = 0; // trailing stop
extern bool   ClosePos_Dn1 = true; // cierre de posición forzado permitido
//----+ +--------------------------------------------------------------------------+
//---- PARÁMETROS DE ENTRADA DEL EA PARA LAS POSICIONES DE VENTA
extern bool   Test_Dn2 = true;// filtro de dirección de cálculo
extern int    Timeframe_Dn2 = 240;
extern double Money_Management_Dn2 = 0.1;
extern double IndLevel_Dn2 = -0.8; // nivel de ruptura del indicador
extern int    JLength_Dn2 = 8;  // profundidad del suavizado JJMA de entrada de precio
extern int    XLength_Dn2 = 8;  // profundidad del suavizado JurX del indicador obtenido 
extern int    Phase_Dn2 = 100; // parámetro que varía en el rango -100 ... +100, 
                              //influencia en la calidad de los procesos temporales de suavizado
extern int    IPC_Dn2 = 0;/* Selección de los precios donde se calcula el indicador 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 
8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High,  
13-Heiken Ashi Open, 14-Heiken Ashi Close.) */
extern int    STOPLOSS_Dn2 = 50;  // stoploss
extern int    TAKEPROFIT_Dn2 = 100; // takeprofit
extern int    TRAILINGSTOP_Dn2 = 0; // trailing stop
extern bool   ClosePos_Dn2 = true; // cierre de posición forzado permitido
//----+ +--------------------------------------------------------------------------+
//---- Variables enteras para el cálculo mínimo de las barras
int MinBar_Up1, MinBar_Dn1;
int MinBar_Up2, MinBar_Dn2;
//+==================================================================+
//| Funciones TimeframeCheck()                                       |
//+==================================================================+
void TimeframeCheck(string Name, int Timeframe)
  {
//----+
   //---- Comprobación de la exactitud del valor de la variable Timeframe
   if (Timeframe != 1)
    if (Timeframe != 5)
     if (Timeframe != 15)
      if (Timeframe != 30)
       if (Timeframe != 60)
        if (Timeframe != 240)
         if (Timeframe != 1440)
           Print(StringConcatenate("Parámetro ",Name,
                     " no puede ", "ser igual a ", Timeframe, "!!!"));    
//----+ 
  }
//+==================================================================+
//| Funciones personalizadas del Asesor Experto                      |
//+==================================================================+
#include <Lite_EXPERT1.mqh>
//+==================================================================+
//| Función de inicialización del Asesor Experto                     |
//+==================================================================+
int init()
  {
//---- Comprobación de la exactitud del valor de la variable Timeframe_Up1
   TimeframeCheck("Timeframe_Up1", Timeframe_Up1);                             
//---- Comprobación de la exactitud del valor de la variable Timeframe_Up2 
   TimeframeCheck("Timeframe_Up2", Timeframe_Up2);                              
//---- Comprobación de la exactitud del valor de la variable Timeframe_Dn1  
   TimeframeCheck("Timeframe_Dn1", Timeframe_Dn1);  
//---- Comprobación de la exactitud del valor de la variable Timeframe_Dn2  
   TimeframeCheck("Timeframe_Dn2", Timeframe_Dn2);  
//---- Inicialización de variables
   MinBar_Up1 = 3 + 3 * XLength_Up1 + 30;
   MinBar_Up2 = 3 + 3 * XLength_Up2 + 30;
   MinBar_Dn1 = 3 + 3 * XLength_Dn1 + 30;
   MinBar_Dn2 = 3 + 3 * XLength_Dn2 + 30;                                     
//---- fin de la inicialización
   return(0);
  }
//+==================================================================+
//| función de desinicialización del experto                         |
//+==================================================================+  
int deinit()
  {
//----+
   
    //---- Fin de la desinicialización del EA
    return(0);
//----+ 
  }
//+==================================================================+
//| Función de iteración del Asesor Experto                          |
//+==================================================================+
int start()
  {
   //----+ Declaración de variables locales
   double Osc1, Osc2;
   //----+ Declaración de variables estáticas
   //----+ +---------------------------------------------------------------+
   static int LastBars_Up1, LastBars_Dn1;
   static bool BUY_Sign1, BUY_Stop1, SELL_Sign1, SELL_Stop1;
   //----+ +---------------------------------------------------------------+
   static int LastBars_Up2, LastBars_Dn2;
   static bool BUY_Sign2, BUY_Stop2, SELL_Sign2, SELL_Stop2;
   //----+ +---------------------------------------------------------------+
   //----++ CÓDIGO DE LAS POSICIONES LARGAS 1
   if (Test_Up1) 
    {
      int IBARS_Up1 = iBars(NULL, Timeframe_Up1);
      
      if (IBARS_Up1 >= MinBar_Up1)
       {
         if (LastBars_Up1 != IBARS_Up1)
          {
           //----+ Inicialización de variables 
           BUY_Sign1 = false;
           BUY_Stop1 = false;
           LastBars_Up1 = IBARS_Up1; 
           
           //----+ CÁLCULO DE LOS VALORES DEL INDICADOR Y SUBIDA A LOS BÚFERES        
           Osc1 = iCustom(NULL, Timeframe_Up1, 
                 "JCCIX", JLength_Up1, XLength_Up1,
                                Phase_Up1, IPC_Up1, 0, 1);
                                
           Osc2 = iCustom(NULL, Timeframe_Up1, 
                 "JCCIX", JLength_Up1, XLength_Up1,
                                Phase_Up1, IPC_Up1, 0, 2);
           
           //----+ DEFINICIÓN DE SEÑALES DE TRADING                                           
           if (Osc2 < IndLevel_Up1)
             if (Osc1 > IndLevel_Up1)
                          BUY_Sign1 = true;
                          
           if (Osc1 < IndLevel_Up1)
                          BUY_Stop1 = true;                                           
          }
          //----+ EJECUCIÓN DE OPERACIONES
          if (!OpenBuyOrder1(BUY_Sign1, 1, Money_Management_Up1, 
                                          STOPLOSS_Up1, TAKEPROFIT_Up1))
                                                                 return(-1);
          if (ClosePos_Up1)
                if (!CloseOrder1(BUY_Stop1, 1))
                                        return(-1);
                                        
          if (!Make_TreilingStop(1, TRAILINGSTOP_Up1))
                                                  return(-1);
        }
     }
   //----+ +---------------------------------------------------------------+
   //----++ CÓDIGO DE LAS POSICIONES LARGAS 2
   if (Test_Up2) 
    {
      int IBARS_Up2 = iBars(NULL, Timeframe_Up2);
      
      if (IBARS_Up2 >= MinBar_Up2)
       {
         if (LastBars_Up2 != IBARS_Up2)
          {
           //----+ Inicialización de variables 
           BUY_Sign2 = false;
           BUY_Stop2 = false;
           LastBars_Up2 = IBARS_Up2; 
           
           //----+ CÁLCULO DE LOS VALORES DEL INDICADOR Y SUBIDA A LOS BÚFERES        
           Osc1 = iCustom(NULL, Timeframe_Up2, 
                 "JCCIX", JLength_Up2, XLength_Up2,
                                Phase_Up2, IPC_Up2, 0, 1);
                                
           Osc2 = iCustom(NULL, Timeframe_Up2, 
                 "JCCIX", JLength_Up2, XLength_Up2,
                                Phase_Up2, IPC_Up2, 0, 2);
           
           //----+ DEFINICIÓN DE SEÑALES DE TRADING                                           
           if (Osc2 < IndLevel_Up2)
             if (Osc1 > IndLevel_Up2)
                          BUY_Sign2 = true;
                          
           if (Osc1 < IndLevel_Up2)
                          BUY_Stop2 = true;                                           
          }
          //----+ EJECUCIÓN DE OPERACIONES
          if (!OpenBuyOrder1(BUY_Sign2, 2, Money_Management_Up2, 
                                          STOPLOSS_Up2, TAKEPROFIT_Up2))
                                                                 return(-1);
          if (ClosePos_Up2)
                if (!CloseOrder1(BUY_Stop2, 2))
                                        return(-1);
                                        
          if (!Make_TreilingStop(2, TRAILINGSTOP_Up2))
                                                  return(-1);
        }
     }
   //----+ +---------------------------------------------------------------+ 
   //----++ CÓDIGO DE LAS OPERACIONES CORTAS 1
   if (Test_Dn1) 
    {
      int IBARS_Dn1 = iBars(NULL, Timeframe_Dn1);
      
      if (IBARS_Dn1 >= MinBar_Dn1)
       {
         if (LastBars_Dn1 != IBARS_Dn1)
          {
           //----+ Inicialización de variables 
           SELL_Sign1 = false;
           SELL_Stop1 = false;
           LastBars_Dn1 = IBARS_Dn1; 
           
           //----+ CÁLCULO DE LOS VALORES DEL INDICADOR Y SUBIDA A LOS BÚFERES        
           Osc1 = iCustom(NULL, Timeframe_Dn1, 
                 "JCCIX", JLength_Dn1, XLength_Dn1,
                                Phase_Dn1, IPC_Dn1, 0, 1);
                                
           Osc2 = iCustom(NULL, Timeframe_Dn1, 
                 "JCCIX", JLength_Dn1, XLength_Dn1,
                                Phase_Dn1, IPC_Dn1, 0, 2);
           
           //----+ DEFINICIÓN DE SEÑALES DE TRADING                                           
           if (Osc2 > IndLevel_Dn1)
             if (Osc1 < IndLevel_Dn1)
                          SELL_Sign1 = true;
                          
           if (Osc1 > IndLevel_Dn1)
                          SELL_Stop1 = true;                                           
          }
          //----+ EJECUCIÓN DE OPERACIONES
          if (!OpenSellOrder1(SELL_Sign1, 3, Money_Management_Dn1, 
                                          STOPLOSS_Dn1, TAKEPROFIT_Dn1))
                                                                 return(-1);
          if (ClosePos_Dn1)
                if (!CloseOrder1(SELL_Stop1, 3))
                                        return(-1);
                                        
          if (!Make_TreilingStop(3, TRAILINGSTOP_Dn1))
                                                  return(-1);
        }
     }
   //----+ +---------------------------------------------------------------+
   //----++ CÓDIGO DE LAS OPERACIONES CORTAS 2
   if (Test_Dn2) 
    {
      int IBARS_Dn2 = iBars(NULL, Timeframe_Dn2);
      
      if (IBARS_Dn2 >= MinBar_Dn2)
       {
         if (LastBars_Dn2 != IBARS_Dn2)
          {
           //----+ Inicialización de variables 
           SELL_Sign2 = false;
           SELL_Stop2 = false;
           LastBars_Dn2 = IBARS_Dn2; 
           
           //----+ CÁLCULO DE LOS VALORES DEL INDICADOR Y SUBIDA A LOS BÚFERES        
           Osc1 = iCustom(NULL, Timeframe_Dn2, 
                 "JCCIX", JLength_Dn2, XLength_Dn2,
                                Phase_Dn2, IPC_Dn2, 0, 1);
                                
           Osc2 = iCustom(NULL, Timeframe_Dn2, 
                 "JCCIX", JLength_Dn2, XLength_Dn2,
                                Phase_Dn2, IPC_Dn2, 0, 2);
           
           //----+ DEFINICIÓN DE SEÑALES DE TRADING                                           
           if (Osc2 > IndLevel_Dn2)
             if (Osc1 < IndLevel_Dn2)
                          SELL_Sign2 = true;
                          
           if (Osc1 > IndLevel_Dn2)
                          SELL_Stop2 = true;                                           
          }
          //----+ EJECUCIÓN DE OPERACIONES
          if (!OpenSellOrder1(SELL_Sign2, 4, Money_Management_Dn2, 
                                          STOPLOSS_Dn2, TAKEPROFIT_Dn2))
                                                                 return(-1);
          if (ClosePos_Dn2)
                if (!CloseOrder1(SELL_Stop2, 4))
                                        return(-1);
                                        
           if (!Make_TreilingStop(4, TRAILINGSTOP_Dn2))
                                                  return(-1);
        }
     }
   //----+ +---------------------------------------------------------------+ 
//----+ 
    
    return(0);
  }
//+------------------------------------------------------------------+

Este código es dos veces más extenso que el presentado en el artículo anterior. Por cierto, imagine qué largo sería el código de este EA si implementara el código del programa competo, en lugar de realizar llamadas a las funciones de gestión de órdenes. Cabe señalar que este Asesor Experto tiene nuevos parámetros de entrada: IndLevel_Up1, IndLevel_Up2, IndLevel_Dn1, IndLevel_Dn2. IndLevel_Up1 y IndLevel_Up2 definen los valores de Uplevel y DownLevel en los dos algoritmos de las posiciones largas, mientras que IndLevel_Dn1 y IndLevel_Dn2 definen los valores de DownLevel y Uplevel en los dos algoritmos de las posiciones cortas.


El valor de estos niveles puede variar de -1.0 a +1.0 durante la optimización del EA. Si desea sustituir el oscilador JCCIX por otro oscilador, tenga en cuenta que los valores máximo y mínimo de estos niveles puede ser diferente. El indicador fuente JCCIX es análogo al indicador CCI, donde el algoritmo de suavizado con medias móviles se sustituye por el JMA y el suavizado ultralineal. El Asesor Experto utiliza Trailing Stops cuyos valores se definen en los parámetros de entrada del EA, por ejemplo: TRAILINGSTOP_Up1, TRAILINGSTOP_Up2, TRAILINGSTOP_Dn1, TRAILINGSTOP_Dn2. Por todo lo demás, este EA es completamente análogo al descrito en el artículo anterior.


Cambiando la entrada inmediata al mercado por órdenes pendientes

En muchos casos, dentro del contexto de los EAs equivalentes al descrito anteriormente, el cambio de entrada inmediata al mercado en órdenes pendientes permite entrar al mercado de forma más precisa, y adquirir un beneficio mayor, con una probabilidad menor de llegar al Stop Loss. El archivo Lite_EXPERT1.mqh contiene un grupo de funciones que lleva a cabo fácilmente la sustitución anterior.

Solo hay que sustituir las funciones OpenBuyOrder1() y OpenSellOrder1() por OpenBuyLimitOrder1() y OpenSellLimitOrder1(), respectivamente. Durante la sustitución de las funciones hay que inicializar nuevas variables de entrada: LEVEL y Expiration. Por ejemplo, podemos construir una estrategia de trading donde la variable LEVEL se define con los parámetros de entrada del EA. La fecha de cancelación de la orden pendiente puede configurarse como la hora del próximo cambio de la barra actual.

No volveré a repetir el mismo código en esta sección. El código cambiado del EA anterior se adjunta en este artículo (archivo Exp_4.mq4). Para ilustrar el uso de las órdenes pendientes he descrito este sistema basado en el oscilador OSMA:

// Compruebe que la carpeta Metatrader\EXPERTS\indicators contiene 
// el indicador 5c_OsMA.mq4 para que el EA pueda realizar las operaciones
//+==================================================================+
//|                                                        Exp_5.mq4 |
//|                             Copyright © 2008,   Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+==================================================================+
#property copyright "Copyright © 2008, Nikolay Kositsin"
#property link "farria@mail.redcom.ru"
//----+ +--------------------------------------------------------------------------+
//---- PARÁMETROS DE ENTRADA PARA LAS OPERACIONES DE COMPRA 
extern bool   Test_Up = true;// filtro de la dirección de cálculo
extern int    Timeframe_Up = 240;
extern double Money_Management_Up = 0.1;
extern double IndLevel_Up = 0; // nivel de ruptura del indicador
extern int    FastEMA_Up = 12;  // periodo de la EMA rápida
extern int    SlowEMA_Up = 26;  // periodo de la EMA lenta
extern int    SignalSMA_Up = 9;  // periodo de la señal SMA
extern int    STOPLOSS_Up = 50;  // stoploss
extern int    TAKEPROFIT_Up = 100; // takeprofit
extern int    TRAILINGSTOP_Up = 0; // trailing stop
extern int    PriceLevel_Up =40; // diferencia entre el precio actual y
                                         // el precio de disparo de la orden pendiente
extern bool   ClosePos_Up = true; // cierre forzado de la posición permitido
//----+ +--------------------------------------------------------------------------+
//---- PARÁMETROS DE ENTRADA DEL EA PARA LAS POSICIONES DE VENTA 
extern bool   Test_Dn = true;// filtro de la dirección de cálculo
extern int    Timeframe_Dn = 240;
extern double Money_Management_Dn = 0.1;
extern double IndLevel_Dn = 0; // nivel de ruptura del indicador
extern int    FastEMA_Dn = 12;  // periodo de la EMA rápida
extern int    SlowEMA_Dn = 26;  // periodo de la EMA lenta
extern int    SignalSMA_Dn = 9;  // periodo de la señal SMA
extern int    STOPLOSS_Dn = 50;  // stoploss
extern int    TAKEPROFIT_Dn = 100; // takeprofit
extern int    TRAILINGSTOP_Dn = 0; // trailing stop
extern int    PriceLevel_Dn = 40; // diferencia entre el precio actual y 
                                         // el precio de disparo de la orden pendiente
extern bool   ClosePos_Dn = true; // cierre forzado de la posición permitido
//----+ +--------------------------------------------------------------------------+
//---- Variables enteras para el cálculo mínimo de las barras
int MinBar_Up, MinBar_Dn;
//+==================================================================+
//| Funciones TimeframeCheck()                                       |
//+==================================================================+
void TimeframeCheck(string Name, int Timeframe)
  {
//----+
   //---- Comprobación de la exactitud del valor de la variable Timeframe
   if (Timeframe != 1)
    if (Timeframe != 5)
     if (Timeframe != 15)
      if (Timeframe != 30)
       if (Timeframe != 60)
        if (Timeframe != 240)
         if (Timeframe != 1440)
           Print(StringConcatenate("Parámetro ",Name,
                     " no puede ", "ser igual a ", Timeframe, "!!!"));    
//----+ 
  }
//+==================================================================+
//| Funciones personalizadas del Asesor Experto                      |
//+==================================================================+
#include <Lite_EXPERT1.mqh>
//+==================================================================+
//| Función de inicialización del Asesor Experto                     |
//+==================================================================+
int init()
  {
//---- Comprobación de la exactitud del valor de la variable Timeframe_Up 
   TimeframeCheck("Timeframe_Up", Timeframe_Up);                                                          
//---- Comprobación de la exactitud del valor de la variable Timeframe_Dn  
   TimeframeCheck("Timeframe_Dn", Timeframe_Dn);  
//---- Inicialización de variables
   MinBar_Up  = 3 + MathMax(FastEMA_Up, SlowEMA_Up) + SignalSMA_Up;
   MinBar_Dn  = 3 + MathMax(FastEMA_Dn, SlowEMA_Dn) + SignalSMA_Dn;                               
//---- fin de la inicialización
   return(0);
  }
//+==================================================================+
//| función de desinicialización del experto                         |
//+==================================================================+  
int deinit()
  {
//----+
   
    //---- Fin de la desinicialización del EA
    return(0);
//----+ 
  }
//+==================================================================+
//| Función de iteración del Asesor Experto                          |
//+==================================================================+
int start()
  {
   //----+ Declaración de variables locales
   double Osc1, Osc2;
   //----+ Declaración de variables estáticas
   //----+ +---------------------------------------------------------------+
   static datetime StopTime_Up, StopTime_Dn; 
   static int LastBars_Up, LastBars_Dn;
   static bool BUY_Sign1, BUY_Stop1, SELL_Sign1, SELL_Stop1;
   //----+ +---------------------------------------------------------------+
   //----++ CÓDIGO DE LAS POSICIONES LARGAS 1
   if (Test_Up) 
    {
      int IBARS_Up = iBars(NULL, Timeframe_Up);
      
      if (IBARS_Up >= MinBar_Up)
       {
         if (LastBars_Up != IBARS_Up)
          {
           //----+ Inicialización de variables 
           BUY_Sign1 = false;
           BUY_Stop1 = false;
           LastBars_Up = IBARS_Up;
           StopTime_Up = iTime(NULL, Timeframe_Up, 0)
                                            + 60 * Timeframe_Up;
           
           //----+ CÁLCULO DE LOS VALORES DEL INDICADOR Y SUBIDA A LOS BÚFERES        
           Osc1 = iCustom(NULL, Timeframe_Up, 
                         "5c_OsMA", FastEMA_Up, SlowEMA_Up,
                                               SignalSMA_Up, 5, 1);
                                
           Osc2 = iCustom(NULL, Timeframe_Up, 
                         "5c_OsMA", FastEMA_Up, SlowEMA_Up,
                                               SignalSMA_Up, 5, 2);
           
           //----+ DEFINICIÓN DE SEÑALES DE TRADING                                           
           if (Osc2 < IndLevel_Up)
             if (Osc1 > IndLevel_Up)
                          BUY_Sign1 = true;
                          
           if (Osc1 < IndLevel_Up)
                          BUY_Stop1 = true;                                           
          }
          //----+ EJECUCIÓN DE SEÑALES
          if (!OpenBuyLimitOrder1(BUY_Sign1, 1, 
              Money_Management_Up, STOPLOSS_Up, TAKEPROFIT_Up,
                                            PriceLevel_Up, StopTime_Up))
                                                                 return(-1);
          if (ClosePos_Up)
                if (!CloseOrder1(BUY_Stop1, 1))
                                        return(-1);
                                        
          if (!Make_TreilingStop(1, TRAILINGSTOP_Up))
                                                  return(-1);
        }
     }
   //----+ +---------------------------------------------------------------+
   //----++ CÓDIGO DE LAS POSICIONES CORTAS 1
   if (Test_Dn) 
    {
      int IBARS_Dn = iBars(NULL, Timeframe_Dn);
      
      if (IBARS_Dn >= MinBar_Dn)
       {
         if (LastBars_Dn != IBARS_Dn)
          {
           //----+ Inicialización de variables 
           SELL_Sign1 = false;
           SELL_Stop1 = false;
           LastBars_Dn = IBARS_Dn;
           StopTime_Dn = iTime(NULL, Timeframe_Dn, 0) 
                                            + 60 * Timeframe_Dn; 
           
           //----+ CÁLCULO DE LOS VALORES DEL INDICADOR Y SUBIDA A LOS BÚFERES        
           Osc1 = iCustom(NULL, Timeframe_Dn, 
                         "5c_OsMA", FastEMA_Dn, SlowEMA_Dn,
                                               SignalSMA_Dn, 5, 1);
                                
           Osc2 = iCustom(NULL, Timeframe_Dn, 
                         "5c_OsMA", FastEMA_Dn, SlowEMA_Dn,
                                               SignalSMA_Dn, 5, 2);
           
           //----+ DEFINICIÓN DE SEÑALES DE TRADING                                           
           if (Osc2 > IndLevel_Dn)
             if (Osc1 < IndLevel_Dn)
                          SELL_Sign1 = true;
                          
           if (Osc1 > IndLevel_Dn)
                          SELL_Stop1 = true;                                           
          }
          //----+ EJECUCIÓN DE SEÑALES
          if (!OpenSellLimitOrder1(SELL_Sign1, 2, 
              Money_Management_Dn, STOPLOSS_Dn, TAKEPROFIT_Dn,
                                            PriceLevel_Dn, StopTime_Dn))
                                                                 return(-1);
          if (ClosePos_Dn)
                if (!CloseOrder1(SELL_Stop1, 2))
                                        return(-1);
                                        
          if (!Make_TreilingStop(2, TRAILINGSTOP_Dn))
                                                  return(-1);
        }
     }
   //----+ +---------------------------------------------------------------+
//----+ 
    
    return(0);
  }
//+------------------------------------------------------------------+

En lugar de dos niveles de ruptura, UpLevel y DownLevel, se utiliza un nivel. Por esta razón el EA solo contiene dos algoritmos para manejar las posiciones. Generalmente, en un sistema de trading conectado con OsMA este nivel se selecciona con un valor igual a cero; sin embargo he decidido dejarlo en variables externas del EA, para que pueda actualizarse. O dicho de otra forma, tenga en cuenta que el indicador OSMA no tiene ningún rango de valores definido por un máximo y por un mínimo, donde el indicador puede cambiar; en consecuencia el nivel de ruptura no está limitado por dichos valores. Aunque generalmente es igual a cero, como he indicado antes. Para definir la hora de cancelación de las órdenes pendientes se utilizan las variables estáticas StopTime_Up y StopTime_Dn, en el cambio de las barras se inicializan con la hora de la próxima barra.


Conclusión

Ya para terminar, me gustaría añadir que los sistemas comerciales basados en osciladores dan muchas señales falsas acerca de la tendencia actual del mercado. Esos EAs operan mejor en períodos de mercado plano, o también pueden utilizarse para abrir posiciones solo por tendencia.

Por lo que respecta al backtesting, aprovecho esta ocasión para indicar una vez mas que lo mejor que pueden hacer los programadores noveles para conseguir más experiencia al principio es, probablemente, estimar correctamente los resultados de optimización. No hay problema con los EAs que muestran resultados excepcionales cuando se ajuntan al historial. Sin embargo, entender cómo hay que ajustar los asesores expertos para evitar las situaciones donde el mercado se aleja de los parámetros optimizados, es más complicado.

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

Archivos adjuntos |
EXPERTS.zip (7.48 KB)
INCLUDE.zip (24.26 KB)
indicators.zip (5.59 KB)
TESTER.zip (5.28 KB)
MetaEditor: plantillas como punto de apoyo MetaEditor: plantillas como punto de apoyo

Posiblemente a muchos de nuestros lectores les sorprenderá que es posible preparar la escritura de un EA solo una vez, y a continuación utilizar el robot tantas veces como se desee.

Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots

Este artículo trata sobre la implementación de algoritmos de sistemas de trading sencillos. De modo que será de gran utilidad para los traders principiantes, así como para aquellas personas que se inician en la programación de EAs.

Análisis comparativo de 30 indicadores y osciladores Análisis comparativo de 30 indicadores y osciladores

El presente artículo describe el funcionamiento de un Asesor Experto que realiza el análisis comparativo de 30 indicadores y osciladores. El objetivo es compilar un paquete de índices eficaz para hacer trading.

Un ayudante para el trader basado en un análisis MACD ampliado Un ayudante para el trader basado en un análisis MACD ampliado

El script 'Trader's Assistant' (ayudante del trader), que sirve para tomar decisiones en la apertura de operaciones, se basa en un análisis ampliado del estado de MACD en las tres últimas barras de cualquier marco temporal. También se puede utilizar en backtesting.