Discussão do artigo "Sistemas de negociação adaptativos e seu uso no terminal do cliente do MetaTrader 5" - página 3

Novo comentário
 
Quantum:

Prezado Forexistence,

>>Dear

Você respondeu à sua pergunta :)

>>Sim, talvez eu mesmo tenha respondido parcialmente à minha pergunta e só queira uma confirmação ou opiniões diferentes.

Você está certo, existem duas maneiras de modificar as condições de negociação: de um lado, podemos adicionar novas condições à estratégia CStrategyMA (mas obteremos a nova estratégia, diferente da inicial); a outra maneira é criar uma nova classe (por exemplo, CStrategyMA34) e adicionar condições adicionais de compra/venda.

Mas, é claro, você deve incluir o arquivo com sua nova estratégia e adicionar essas novas estratégias à função Expert_OnInit da classe CAdaptiveStrategy:

A segunda maneira é melhor, pois você pode adicionar muitas estratégias e suas variações.

Não é necessário remover as instâncias da classe CStrategyMA (se houver), pois não analisaremos suas caixas de areia e seus resultados serão ruins.

O mercado nos ajudará a determinar a melhor estratégia na lista de estratégias, incluída em m_all_strategies.

>> Ok, entendi o ponto como eu imaginava.

Mas a questão, agora, é outra... Estou trabalhando para "internalizar" o EA com o objetivo de trabalhar com otimizações.

Por exemplo, estou me referindo a trechos 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 ///////////////////////
   //definir período para cada estratégia
    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;
    
      // inicialização da estratégia
      t_StrategyRSI.Initialization(period,true,RSItempoframe,RSIappprice,RSIvarA_root,RSIvarB_root);
      /////////////////////////////////////////////////////////////////////////////////////////////


      // definir detalhes da estratégia
      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);
      }

where (declarações) : 

//+------------------------------------------------------------------+
//|                                            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>   // ESTRATÉGIA ADICIONADA

/*
......
*/

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                                          |

/*
...
*/

e onde variáveis:

RSItempoframe, RSIappprice, RSIvarA_root, RSIvarB_root

trabalham em colaboração com

//+------------------------------------------------------------------+
//|                                                  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;     // handle do indicador de média móvel (iMA)
   int               m_period;     // período do indicador de média móvel
   double            m_values[];   // matriz para armazenar o valor do indicador





   int               RSIvarA, RSIvarB; 
   
   ENUM_TIMEFRAMES   m_timeframe;
   ENUM_APPLIED_PRICE m_appprice;



   
public:
   // inicialização da estratégia // Aviso de entradas adicionadas


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


   // desinicialização da estratégia
   int               Deinitialization();
   // verificação das condições de negociação e abertura de posições virtuais
   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;

/*
...
*/

//criar o identificador do 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);
  // double p_close;

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

{
      Alert("Error of copying history data - error:",GetLastError(),"!!");
      return(false);
     }
// Copiar o preço de fechamento atual da barra anterior (essa é a 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);
     }

/*
...
*/

// Condição de compra 1: RSI sobe
   bool buy_condition_1=(m_values[mval]>m_values[mval1]) && (m_values[mval1]>m_values[mval2]);  // NOTICE integers variable no [] da matriz

// Condição de compra 2: o preço de fechamento anterior é maior que a MA
 //  bool buy_condition_2=(p_close>m_values[1]);


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

/*
... etc.
*/

Minha pergunta é a seguinte:

É oportuno modificar o código para ter uma variável de entrada no nível do arquivo de classe da estratégia (arquivo de inclusão, ou seja, CStrategyRSI.mqh) ou com a hierarquia/conexões/árvores adequadas no nível de outra classe/inclusão (CAdaptiveStrategy.mqh)?

Em outras palavras, para afetar o sistema central da ideia do EA, com a adição de alguns parâmetros de entrada para testes de otimização,

eu deveria fazer algo assim: (variáveis de entrada em 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;

/*
...
*/

//criar o identificador do indicador 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

ou algo parecido com isto: (variáveis de entrada em 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;     // handle do indicador de média móvel (iMA)
   int               m_period;     // período do indicador de média móvel
   double            m_values[];   // matriz para armazenar o valor do indicador

  ENUM_TIMEFRAMES   m_timeframe;
  ENUM_APPLIED_PRICE m_appprice;

int               RSIvarA, RSIvarB;

public:
   // inicialização da estratégia
   int               Initialization(int period,bool virtual_trade_flag);  // OBSERVE O 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;

/*
...
*/

//criar o identificador do indicador 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

Em outras palavras, as variáveis de entrada devem ser usadas no arquivo de inclusão da estratégia, antes da declaração da classe (exemplo 2, apenas isso aqui acima) ou as variáveis de entrada devem

derivar do ciclo "for" na estratégia CAdaptive e devem levar em consideração a inicialização de todas as classes e os parâmetros de entrada? (quero dizer, para este primeiro exemplo (logo acima deste código acima) :)

public:
// inicialização da estratégia
int Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);

Como a diferença afetará o núcleo do sistema, se estiver usando variáveis de entrada no arquivo CStrategyRSI.mqh ou no CAdaptiveStrategy.mqh?

Suponho que, se for apenas uma questão de teste, eu possa usar variáveis de entrada no CStrategyRSI.mqh; se, em vez disso, eu quiser testar e também

afetar o sistema central da ideia do EA (o sistema adaptativo e o simulador de negociação, o trader virtual incluído), devo declarar

as variáveis de entrada não no include da estratégia, mas no arquivo include do Adaptive, com todas as conexões e chamadas adequadas

de entrada/saída da inicialização e declaração de classe/funções?

Certo?

Espero que você tenha entendido meu ponto.

Tnkx

 
forexistence:

....Mas a questão, agora, é outra... Estou trabalhando para "inputizar" o EA com o objetivo de trabalhar com otimizações....

Se você quiser encontrar os melhores parâmetros da estratégia usando a opção de otimização no Strategy Tester, é melhor reescrever o EA com alguma estratégia específica e trabalhar com ela.

O conceito do EA adaptativo e sua estrutura não permitem otimizar seus parâmetros diretamente no Strategy Tester, porque não há nenhuma estratégia e parâmetros específicos para otimizar.

Quando usamos o EA adaptativo na negociação ou o testamos no Strategy Tester, temos um sistema de negociação como um conjunto de sinais de diferentes estratégias. Em outras palavras, o testador não pode acessar as sandboxes virtuais que criamos e não sabe nada sobre elas.

Se você quiser usar os parâmetros de entrada para configurar os parâmetros das estratégias de negociação a serem usadas, é melhor usar os arquivos, pois isso permitirá que você configure os parâmetros e a lista de estratégias de negociação.

 
Quantum:

Se você quiser encontrar os melhores parâmetros da estratégia usando a opção de otimização no Strategy Tester, é melhor reescrever o EA com alguma estratégia específica e brincar com ela.

>> Ok, entendi o ponto. Não será uma tarefa fácil...

O conceito do EA adaptativo e sua estrutura não permitem otimizar seus parâmetros diretamente no Strategy Tester, porque não há nenhuma estratégia e parâmetros específicos para otimizar.

>> Sim. O EA é idealizado para trabalhar comparâmetros ainda otimizados para as estratégias. O que eu entendi é que ele utiliza estratégias diferentes com base em como/quais o mercado responde (ou vice-versa em outro ponto de vista...)

Quando usamos o EA adaptativo na negociação ou o testamos no Strategy Tester, temos um sistema de negociação como um conjunto de sinais das diferentes estratégias. Em outras palavras, o testador não pode acessar as sandboxes virtuais que criamos e não sabe nada sobre elas.

>> Entendi esse conceito, mas não completamente.

Entendo que não faz sentido interagir com o testador com sandboxes virtuais, pois não há sentido lógico comercial.

Meu único objetivo era modificar o EA para usá-lo com um addon: o objetivo de usar esse EA também para otimizar os parâmetros, sem reescrever outro EA, ou reescrever todas as estratégias, ou testar cada estratégia individualmente. Minha ideia era apenas "confortar" a possibilidade de otimizar os parâmetros, dentro do mesmo EA, mas essa otimização não se destina a funcionar com o comércio virtual/sistema adaptativo. É apenas uma questão de ter a possibilidade de otimizar os parâmetros das estratégias, usando a mesma janela de entrada do EA, e não de escrever outro EA para cada estratégia, obter os parâmetros otimizados e colocá-los como valores fixos no Adaptive Strategy System. Espero que você tenha entendido o que quero dizer.

Se você quiser usar os parâmetros de entrada para configurar os parâmetros das estratégias de negociação a serem usadas, é melhor usar os arquivos, pois isso permitirá que você configure os parâmetros e a lista de estratégias de negociação.

>> De quais arquivos você está falando? ( Se você quiser usar os parâmetros de entrada para configurar os parâmetros das estratégias de negociação a serem usadas, é melhor usar os arquivos )

Você está se referindo ao uso do CStrategyXXX.mqh ou ao fato de escrever outro EA individual para cada estratégia, otimizá-lo e copiar os parâmetros como valores fixos no 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?

Quero dizer que o contêiner da estratégia pode ser preenchido de acordo com algumas configurações do EA adaptável.

Por exemplo, no Adaptive_Expert.Expert_OnInit(), ele pode carregar um arquivo com as configurações do EA adaptável:

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

Strategy1;Param1;Param2;
Strategy2;Param1;Param2;

Ao analisar cada linha, ele reconhece a estratégia necessária para incluir e adicioná-la com os parâmetros correspondentes especificados. Essa é uma das maneiras de configurar o EA adaptável sem compilações. Por uma questão de simplicidade, não o considerei no artigo.

Entendo que não faz sentido interagir com o testador com sandboxes virtuais, pois não há lógica comercial.

Meu único objetivo era modificar o EA para usá-lo com um addon: o objetivo de usar esse EA também para otimizar parâmetros, sem reescrever outro EA, ou reescrever todas as estratégias, ou testar cada estratégia individualmente. Minha ideia era apenas "confortar" a possibilidade de otimizar os parâmetros, dentro do mesmo EA, mas essa otimização não se destina a funcionar com o comércio virtual/sistema adaptativo. É apenas uma questão de ter a possibilidade de otimizar os parâmetros das estratégias, usando a mesma janela de entrada do EA, e não de escrever outro EA para cada estratégia, obter os parâmetros otimizados e colocá-los como valores fixos no Adaptive Strategy System. Espero que você tenha entendido meu ponto.

Há uma maneira de analisar as sandboxes. Isso pode ser feito indiretamente usando o Strategy Tester.

Suponha que queiramos reproduzir os resultados apresentados na fig. 2 do artigo.

Precisamos da versão de depuração do EA adaptativo adaptive-systems-mql5-sources-debug-en.zip (ele relata os sandboxes). Em seguida, compile e abra Adaptive_Expert_Sample no Strategy tester, selecione EURUSD H1 01.01.2010 a 20.08.2010 e inicie o teste. As sandboxes e os resultados da estratégia adaptativa serão salvos em tester\files\equity_res.txt. Dessa forma, é muito fácil reproduzir todos os números.

A análise das ações/balanços de negociação virtual permitirá que você simplifique a otimização.

 

Olá a todos,

Obrigado por esse excelente artigo. Agora estou trabalhando apenas em um EA adaptável.

No entanto, não tenho certeza de onde incluir uma função de trailing stop nesse tipo de EA.

Acho que essa função poderia ser adicionada na parte CAdaptiveStrategy.mqh.

Algum de vocês poderia me ajudar? Talvez vocês já tenham desenvolvido essa função?

Desde já, muito obrigado!

Com os melhores cumprimentos,

Patrick

 
Alguém tem uma versão do Adaptive Trading que funcione com os especialistas com base na classe OO Expert?
 
A MQL5 abre grandes oportunidades para nós - poucos membros da comunidade comercial ainda podem apreciá-las, e menos ainda podem usá-las.
 
Obrigado pelo excelente artigo. Estou pensando em como implementar um sistema adaptativo, e essa foi uma abordagem que pensei, mas ainda não tive tempo de trabalhar. Você já pensou em usar algum dos recursos de backtesting incorporados em conjunto com os dados ao vivo?
 

Não consigo reproduzir os resultados do artigo.

Baixei os arquivos de origem, compilei e executei no mesmo período de tempo (EURUSD H1, 01/04/2010 - 20/08/2010) e obtive um resultado diferente.

Usei os arquivos de depuração e verifiquei os resultados das negociações virtuais... os gráficos de patrimônio virtual são idênticos, mas as negociações reais não correspondem.

Sem um arquivo de registro das negociações reais, é difícil descobrir por que minhas negociações não coincidem com as do artigo.

Alguma ideia de por que não correspondem?

 
O artigo é muito bom. A distração vem do fato de as pessoas tentarem reproduzir os resultados, em vez de tirar proveito e integrar as possibilidades funcionais propostas. Agora, a probabilidade de criar um EA de negociação automatizado e semiautomatizado totalmente funcional e lucrativo é concretizada. Testes de indicadores em larga escala, compilação dos resultados e extração de dados estatísticos de indicadores, além de estatísticas conformacionais dos referidos dados, permitindo que o EA escolha a melhor estratégia de negociação a ser implementada. Nunca a análise fundamentalista e técnica foi combinada em um EA até agora com o auxiliar da linguagem MQL5. Olhando para o futuro, vejo a realização de EAs em todos os mercados se unindo para prever as flutuações do mercado.
1234
Novo comentário