Discusión sobre el artículo "Sistemas de Trading Adaptables y su Uso en el Terminal de Cliente MetaTrader 5" - página 3

Nuevo comentario
 
Quantum:

Estimado Forexistence,

>>Estimado

Usted ha respondido a su pregunta :)

>> Sí, tal vez en parte yo mismo he respondido a mi pregunta, y sólo quiero una confirmación o diferentes opiniones.

Usted tiene razón, hay dos maneras si desea modificar las condiciones de negociación, por un lado podemos añadir nuevas condiciones a la estrategia CStrategyMA (pero vamos a obtener la nueva estrategia, diferente de la inicial), la otra forma es crear una nueva clase (por ejemplo, CStrategyMA34) y añadir condiciones adicionales de compra / venta allí.

Pero, por supuesto, debe incluir el archivo con su nueva estrategia y añadir estas nuevas estrategias a la función Expert_OnInit de la clase CAdaptiveStrategy:

La segunda forma es mejor, puede agregar muchas estrategias y sus variaciones.

No es necesario eliminar las instancias de la clase CStrategyMA (si las tiene), no miraremos en sus sandboxes en sus resultados serán malos.

El mercado nos ayudará a determinar la mejor estrategia de la lista de estrategias, incluidas en m_all_strategies.

>> Ok entendido el punto como me imaginaba.

Pero la pregunta, ahora, es otra.. Estoy trabajando para "inputize" la EA para el objetivo de trabajar con optimizaciones.

Así que en ejemplo me refiero a trozos de códigos como este:

for(int i=0; i<RSIcicle; i++)
     {
      CStrategyRSI *t_StrategyRSI;
      t_StrategyRSI=new CStrategyRSI;
      if(t_StrategyRSI==NULL)
        {
         delete m_all_strategies;
         Print("Error of creation of object of the CStrategyRSI type");
         return(-1);
        }

      

       ////////////////////////// PLEASE LOOK AT THIS FOLLOWING PIECE OF CODE ///////////////////////
   /establecer periodo para cada estrategia
    int period=Trsi+Drsi*i;
    
    ENUM_TIMEFRAMES RSItempoframe=RSItempoframe_in; // SET TIMEFRAME (enum), INPUT, FOR STRATEGY 
    ENUM_APPLIED_PRICE RSIappprice=RSIappprice_in;  // SET APPPLIED PRICE (enum), INPUT, FOR STRATEGY
    
    int RSIvarA_root=RSIvarA_in;
    int RSIvarB_root=RSIvarB_in;
    
      // inicialización de la estrategia
      t_StrategyRSI.Initialization(period,true,RSItempoframe,RSIappprice,RSIvarA_root,RSIvarB_root);
      /////////////////////////////////////////////////////////////////////////////////////////////


      // establecer los detalles de la estrategia
      t_StrategyRSI.SetStrategyInfo(_Symbol,"[RSI_"+IntegerToString(period)+"]",period,"Relative Strenght Index "+IntegerToString(period));
      
      if(t_StrategyRSISet_Stops_ ==true) {
      t_StrategyRSI.Set_Stops(tSMSSone,tSMSStwo); //3500,1000);
      }

donde (declaraciones) : 

//+------------------------------------------------------------------+
//|                                            CAdaptiveStrategy.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"

#include <Arrays\ArrayObj.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <CStrategyMA.mqh>
#include <CStrategyMAinv.mqh>
#include <CStrategyStoch.mqh>

#include <CStrategyRSI.mqh>   // ESTRATEGIA AÑADIDA

/*
......
*/

input int Trsi=0, Drsi=10, RSIcicle=10;

input ENUM_TIMEFRAMES RSItempoframe_in= PERIOD_CURRENT;
input ENUM_APPLIED_PRICE RSIappprice_in= PRICE_CLOSE;

input int RSIvarA_in=60, RSIvarB_in=40;




input int tSMSSone=3500, tSMSStwo=1000;


input bool t_StrategyRSISet_Stops_=false;

/*
...
*/

//+------------------------------------------------------------------+
//| Class CAdaptiveStrategy                                          |

/*
...
*/

y donde las variables:

RSItempoframe, RSIappprice, RSIvarA_root, RSIvarB_root

trabajan en colaboración con

//+------------------------------------------------------------------+
//|                                                  CStrategyMA.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#include <CSampleStrategy.mqh>

input int mval=0, mval1=1, mval2=2, mval3=3, mval4=4, mvalVar=0, mvalFix=0,

          mvalVar2=0, mvalFix2=0;
          

//+------------------------------------------------------------------+
//| Class CStrategyMA for implementation of virtual trading          |
//| by the moving average strategy                                   |
//+------------------------------------------------------------------+
class CStrategyRSI : public CSampleStrategy
  {
protected:
   int               m_handle;     // asa del indicador de media móvil (iMA)
   int               m_period;     // período del indicador Media Móvil
   double            m_values[];   // matriz para almacenar el valor del indicador





   int               RSIvarA, RSIvarB; 
   
   ENUM_TIMEFRAMES   m_timeframe;
   ENUM_APPLIED_PRICE m_appprice;



   
public:
   // inicialización de la estrategia // Aviso entradas añadidas


   int               Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
                                    ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);


   // desinicialización de la estrategia
   int               Deinitialization();
   // comprobación de las condiciones comerciales y apertura de posiciones virtuales
   bool              CheckTradeConditions();
  };
//+------------------------------------------------------------------+
//| Method of initialization of the strategy                         |
//+------------------------------------------------------------------+



int CStrategyRSI::Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
                                 ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root)


  {
   //set period for the RSI     (was //set period for the moving average)
   m_period=period;
      
   m_timeframe=RSItempoframe;
   m_appprice=RSIappprice;
   
   RSIvarA=RSIvarA_root;
   RSIvarB=RSIvarB_root;

/*
...
*/

//crear asa del indicador 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

//+------------------------------------------------------------------+
//| checking the trade conditions and opening the virtual positions  |
//+------------------------------------------------------------------+
bool CStrategyRSI::CheckTradeConditions()
  {
   RecalcPositionProperties(m_position);
  // doble p_close;

/*
...
*/
   
     if(CopyRates(_Symbol,m_timeframe,0,3,m_rates)<0)

{
      Alert("Error of copying history data - error:",GetLastError(),"!!");
      return(false);
     }
// Copia el precio de cierre actual de la barra anterior (esta es la barra 1)
  // p_close=m_rates[1].close;  // close price of the previous bar          

   if(CopyBuffer(m_handle,0,0,3,m_values)<0)
     {
      Alert("Error of copying buffers of the Moving Average indicator - error number:",GetLastError());
      return(false);
     }

/*
...
*/

// Condición de compra 1: RSI sube
   bool buy_condition_1=(m_values[mval]>m_values[mval1]) && (m_values[mval1]>m_values[mval2]);  // NOTIFICAR variable de enteros en el [] del array

// Condición de compra 2: el precio de cierre anterior es superior a la MA
 //  bool buy_condition_2=(p_close>m_values[1]);


     bool buy_condition_2=(m_values[mval+mvalVar+mvalFix]>RSIvarA);

/*
... etc.
*/

Mi pregunta es

¿Es oportuno modificar el código, con el fin de tener la variable de entrada en la estrategia classfile (incluir archivo es decir CStrategyRSI.mqh) nivel, o con la hiearachy adecuada / conexiones / árboles en la otra clase / incluye nivel (CAdaptiveStrategy.mqh) ?

En otras palabras, para afectar el sistema central de la idea de EA, con la adición de algunos parámetros de entrada para las pruebas de optimizaciones,

debo hacer algo como esto: (variables de entrada en CAdaptiveStrategy.mqh)

/*
...
*/

class CStrategyRSI : public CSampleStrategy
  {
protected:
   int               m_handle;     // handle of the Moving Average (iMA) indicator
   int               m_period;     // period of the Moving Average indicator
   double            m_values[];   // array for storing the value of indicator
   int               RSIvarA, RSIvarB;
   
   ENUM_TIMEFRAMES   m_timeframe;
   ENUM_APPLIED_PRICE m_appprice;
   
public:
   // initialization of strategy
   int               Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
                                    ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);

/*
...
*/ 

//set period for the RSI     (was //set period for the moving average)
   m_period=period;
      
   m_timeframe=RSItempoframe;
   m_appprice=RSIappprice;
   
   RSIvarA=RSIvarA_root;
   RSIvarB=RSIvarB_root;

/*
...
*/

//crear asa del indicador 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

o algún otro como este: (variables de entrada en CSampleRSI.mqh)

/*
...
*/

input   int               RSIvarA_root, RSIvarB_root;
   
input  ENUM_TIMEFRAMES  RSItempoframe=PERIOD_M5;
input   ENUM_APPLIED_PRICE RSIappprice=PRICE_CLOSE;
   

class CStrategyRSI : public CSampleStrategy
  {
protected:
   int               m_handle;     // asa del indicador de media móvil (iMA)
   int               m_period;     // período del indicador Media Móvil
   double            m_values[];   // matriz para almacenar el valor del indicador

  ENUM_TIMEFRAMES   m_timeframe;
  ENUM_APPLIED_PRICE m_appprice;

int               RSIvarA, RSIvarB;

public:
   // inicialización de la estrategia
   int               Initialization(int period,bool virtual_trade_flag);  // OBSERVE EL CÓDIGO ORIGINAL

/*
...
*/ 

//set period for the RSI     (was //set period for the moving average)
   m_period=period;
      
   m_timeframe=RSItempoframe;
   m_appprice=RSIappprice;
   
   RSIvarA=RSIvarA_root;
   RSIvarB=RSIvarB_root;

/*
...
*/

//crear asa del indicador 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

En otras palabras, las variables de entrada deben usarse en el archivo de inclusión de la estrategia, antes de la declaración de la clase (ejemplo2, sólo esto aquí arriba) o las variables de entrada deben

derivar del ciclo "for" en la estrategia CAdaptive, y debe tener en cuenta todas las clases initializazion y parámetros de entrada? (me refiero a este primer ejemplo (justo encima de este código de arriba) :)

public:
// inicialización de la estrategia
int Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);

De forma diferente afectará al núcleo del sistema, si se utilizan variables de entrada en el archivo CStrategyRSI.mqh o en el CAdaptiveStrategy.mqh?

Supongo que, si sólo una cuestión de prueba, puedo utilizar las variables de entrada en el CStrategyRSI.mqh, si en cambio quiero tanto la prueba y también

afectar el sistema central de la idea EA (el sistema de adaptación y simulador de comercio, el comerciante virtual incluir) debo declarar

variables de entrada no en la estrategia de incluir, pero en el archivo de inclusión de adaptación, con todas las conexiones adecuadas y la llamada

de entrada / salida de la inizialization y la declaración de clase / funciones?

¿Verdad?

Espero que hayas entendido mi punto.

Tnkx

 
forexistence:

....Pero la pregunta, ahora, es otra.. Estoy trabajando para "inputize" la EA para el objetivo de trabajar con optimizations....

Si desea encontrar los mejores parámetros de la estrategia utilizando la opción de optimización en el Probador de Estrategias, es mejor volver a escribir la EA con alguna estrategia en particular y jugar con ella.

El concepto del EA adaptativo y su estructura no permite optimizar sus parámetros en el Probador de Estrategias directamente, porque no hay ninguna estrategia en particular y parámetros para optimizar.

Cuando utilizamos el EA adaptativo en el trading o lo probamos en el Probador de Estrategias tenemos un sistema de trading como un conjunto de señales de las diferentes estrategias. En otras palabras, el Probador no puede acceder a los sandboxes virtuales que hemos creado y no sabe nada de ellos.

Si desea utilizar los parámetros de entrada para configurar los parámetros de las estrategias de negociación a utilizar, es mejor utilizar los archivos, que le permitirá configurar los parámetros y la lista de estrategias de negociación.

 
Quantum:

Si quieres encontrar los mejores parámetros de la estrategia usando la opción de optimización en el Probador de Estrategias, es mejor reescribir el EA con alguna estrategia en particular y jugar con ella.

>> Vale, lo he entendido. No va a ser una tarea fácil ..

El concepto del EA adaptativo y su estructura no permite optimizar sus parámetros en el Probador de Estrategias directamente, porque no hay ninguna estrategia en particular ni parámetros que optimizar.

>> Sí. El EA está idealizado para trabajar conparámetros aún optimizados para las estrategias. Lo que he entendido es que utiliza diferentes estrategias en base a cómo/qué responde el mercado (o viceversa en otro punto de vista..)

Cuando usamos el EA adaptativo en el trading o lo probamos en el Probador de Estrategias tenemos un sistema de trading como un conjunto de señales de las diferentes estrategias. Es decir, el Probador no puede acceder a los sandbox virtuales que hemos creado y no sabe nada de ellos.

>> Entendido este concepto, pero no del todo.

Entiendo que no tiene sentido interactuar el tester con sandboxes virtuales, no tiene sentido lógico de trading.

Mi único objetivo era tener el EA modificado, con el fin de utilizarlo con un addon: el objetivo de utilizar este EA también para optimizar los parámetros, sin reescribir otro EA, o reescribir todas las estrategias, o probar cada estrategia individualmente. Mi idea era sólo para "comodidad" a la posibilidad de optimizar los parametes, dentro de la misma EA, pero esta optimización no está destinado a trabajar con el comercio virtual / sistema adaptativo. Es sólo una cuestión de tener la posibilidad de optimizar los parámetros de las estrategias, utilizando la misma ventana de entrada EA, y no para escribir otro cada EA para cada estrategia, obtener los parámetros de optimizar, y ponerlos como valores fijos en el sistema de estrategia adaptativa. Espero que hayas entendido mi punto.

Si desea utilizar los parámetros de entrada para configurar los parámetros de las estrategias de negociación a utilizar, es mejor utilizar los archivos, que le permitirá configurar los parámetros y la lista de estrategias de negociación.

>> ¿De qué ficheros estás hablando? ( Si quieres usar los parámetros de entrada para configurar los parámetros de las estrategias de trading a usar, es mejor usar los ficheros )

¿Te refieres a utilizar CStrategyXXX.mqh o al hecho de escribir otro EA individual para cada estrategia, optimizarlo, y copiar los parámetros como valores fijos en CStrategyXXX.mqh?

 

Are you talking about to use CStrategyXXX.mqh or the fact to write another individual EA for each strategy, optimize it, and copy the parameters as fixed values in CStrategyXXX.mqh?

Me refiero a que el contenedor de la estrategia puede ser llenado de acuerdo a algunas configuraciones del EA adaptativo.

Por ejemplo, en el Adaptive_Expert.Expert_OnInit() puede cargar un archivo con la configuración del EA adaptativo:

MA;3
MA;15
MA;25
Estoc;3;12;20
Estoc;3;15;30

Estrategia1;Parámetro1;Parámetro2;
Estrategia2;Parámetro1;Parámetro2;

Al analizar cada línea reconoce la estrategia que necesita incluir y la añade con los parámetros correspondientes especificados. Es una de las formas de configurar el EA adaptativo sin compilaciones. Por simplicidad, no lo he considerado en el artículo.

Entiendo que no tienen sentido para interactuar el probador con cajas de arena virtuales, sin sentido lógico de comercio.

Mi único objetivo era tener el EA modificado, con el fin de utilizarlo con un addon: el objetivo de utilizar este EA también para optimizar los parámetros, sin reescribir otro EA, o reescribir todas las estrategias, o probar cada estrategia individualmente. Mi idea era sólo para "comodidad" a la posibilidad de optimizar los parametes, dentro de la misma EA, pero esta optimización no está destinado a trabajar con el comercio virtual / sistema adaptativo. Es sólo una cuestión de tener la posibilidad de optimizar los parámetros de las estrategias, utilizando la misma ventana de entrada EA, y no para escribir otro cada EA para cada estrategia, obtener los parámetros de optimizar, y ponerlos como valores fijos en el sistema de estrategia adaptativa. Espero que hayas entendido mi punto.

Hay una manera de ver las cajas de arena. Se puede hacer indirectamente usando el Probador de Estrategias.

Supongamos que queremos reproducir los resultados, presentados en la fig. 2 del artículo.

Necesitamos la versión de depuración del EA adaptable adaptive-systems-mql5-sources-debug-en.zip (que informan de las cajas de arena) El siguiente, compilar y abrir Adaptive_Expert_Sample en Strategy tester, seleccione EURUSD H1 01.01.2010 a 20.08.2010 y empezar a probar. Los sandboxes y los resultados de la estrategia adaptativa se guardarán en tester\files\equity_res.txt De esta forma es muy fácil reproducir todas las cifras.

El análisis de los valores/balances de las operaciones virtuales le permitirá simplificar la optimización.

 

Hola a todos,

Gracias por este gran artículo, ahora sólo estoy trabajando en un EA adaptativo.

Sin embargo, no estoy seguro de dónde incluir una función de trailing stop en este tipo de EA.

Creo que dicha función podría añadirse en la parte CAdaptiveStrategy.mqh.

¿Podríais ayudarme? ¿Tal vez ustedes ya han desarrollado una función de este tipo?

Muchas gracias de antemano.

Un cordial saludo,

Patrick

 
¿Alguien tiene una versión de Adaptive Trading que funcione con los expertos basados en la clase OO Expert?
 
MQL5 nos abre enormes oportunidades, que aún no muchos miembros de la comunidad de operadores saben apreciar, y menos aún utilizar.
 
Gracias por el gran artículo, he estado considerando cómo implementar un sistema adaptativo, este fue un enfoque que he ideado, pero no he tenido el tiempo para trabajar fuera todavía. Ha considerado el uso de cualquiera de los construidos en backtesting características en conjunción con los datos en vivo?
 

No puedo reproducir los resultados del artículo.

Descargué los archivos fuente, los compilé y los ejecuté en el mismo marco temporal (EURUSD H1, 04/01/2010 - 20/08/2010) y obtengo un resultado diferente.

Utilicé los archivos de depuración y comprobé los resultados de las operaciones virtuales... los gráficos de acciones virtuales son idénticos, sin embargo, las operaciones reales no coinciden.

Sin un archivo de registro de las operaciones reales es difícil averiguar por qué mis operaciones no coinciden con las del artículo.

¿Alguna idea de por qué no coinciden?

 
Muy buen artículo, La distracción vienen de la gente tratando de reproducir los resultados en lugar de tomar e integrar las posibilidades funcionales propuestas. Ahora la probabilidad de crear un totalmente funcional y rentable automatizado y semiautomatizado de comercio EA se realiza. Probando Indicadores a gran escala, recopilando los resultados y extrayendo los datos estadísticos de los indicadores sobre las estadísticas conformacionales de dichos datos y permitiendo al EA elegir la mejor estrategia de trading a implementar. Nunca se había combinado el análisis Fundamental y Técnico en un EA hasta ahora con el Auxiliar del Lenguaje MQL5. Mirando hacia el futuro veo la realización de EA's en todos los Mercados uniéndose para predecir las fluctuaciones del mercado.
1234
Nuevo comentario