Criar critérios personalizados de otimização de Expert Advisors

Introdução

O terminal do cliente MetaTrader 5 oferece uma ampla gama de possibilidades de otimização dos parâmetros de Expert Advisor. Além dos critérios de otimização inclusos no provador de estratégia, os desenvolvedores têm a possibilidade de criar os seus próprios critérios. Isto leva a um número quase ilimitado de possibilidades de teste e otimização dos Expert Advisors. Este artigo descreve formas práticas, tanto simples como complexas, de criação desses critérios.

1. Revisão de recursos do provador de estratégia

Este assunto foi discutido diversas vezes, então apenas apresentarei uma lista de artigos com as suas breves descrições. Recomendo que você se familiarize com os seguintes materiais antes de ler este artigo.

• "Princípios básicos dos testes no MetaTrader 5". Abrange em detalhes todos os aspectos técnicos do teste de um Expert Advisor - os modos de geração de ticks, trabalhando com preços abertos e barras M1. Descreve o uso de indicadores durante o teste, emulação de variáveis de ambiente e tratamento de eventos padrão. Além disso, apresenta os princípios básicos do teste de moedas múltiplas.
• "Guia de teste e otimização de Expert Advisors em MQL5". Abrange as questões de teste e otimização de parâmetros de entrada de um Expert Advisor. Descreve o processo de ajuste de parâmetros, interpretação de resultados de teste e seleção dos melhores parâmetros.
• "Utilizar a função TesterWithdrawal() para modelar as retiradas de lucro". Descreve o uso da função TesterWithdrawal para modelar as retiradas de dinheiro de uma conta no provador de estratégia. Ademais, demonstra como esta função afeta o algoritmo de cálculo de reduções de participação no provador de estratégia.
  

E, certamente, você primeiro precisa se familiarizar com a documentação fornecida com o terminal do cliente.

2. Critérios de otimização integrados ao provador de estratégia

Se você observar a documentação, encontrará a seguinte descrição: Critério de otimização é um determinado fator, cujos valores definem a qualidade de um conjunto de parâmetros testado. Quanto maior o valor do critério de otimização, melhor é considerado o resultado do teste do conjunto de parâmetros.

Aqui devemos fazer uma importante observação: um critério de otimização apenas pode ser utilizado no modo de otimização de algoritmo genético. é evidente que, ao se considerar todas as possíveis combinações de valores de parâmetro, não pode haver qualquer fator de escolha de parâmetros ótimos de um Expert Advisor. Por outro lado, podemos salvar os resultados do teste e processá-los para encontrar uma combinação ótima de parâmetros.

Conforme consta na documentação, o provador de estratégia inclui os seguintes critérios de otimização para serem utilizados com o algoritmo genético:

• Balance max - o maior falor do balanço;
• Balance + max Profit Factor - o maior valor do produto do balanço e fator de lucro;
• Balance + max Expected Payoff - o maior do produto do balanço e o lucro esperado;
• Balance + min Drawdown - neste caso, são considerados o valor do balanço e o nível de redução: (100% - Redução)*Balanço;
• Balance + max Recovery Factor - o produto do balanço de do fator de recuperação;
• Balance + max Sharpe Ratio - o valor do produto do balanço e do índice de Sharpe;
• Custom max - critério personalizado de otimização. Aqui, o critério de otimização é o valor da função OnTester() no Expert Advisor. Este parâmetro permite o uso de qualquer valor personalizado para a otimização do Expert Advisor.

Um critério de otimização pode ser selecionado na aba Configurações do provador de estratégia, conforme apresentado na Figura 1:

Figura 1. Selecionar critério de otimização para o Expert Advisor

O último critério da lista, Custom max, é o que mais nos interessa e seu uso é o assunto deste artigo.

3. Criação de critérios de otimização personalizados

Primeiramente, deve-se dar ao usuário a possibilidade de combinar livremente os parâmetros (não limitados aos apresentados na Figura 1, mas personalizados) que são calculados pelo provador de estratégia após cada execução de um Expert Advisor.

Por exemplo, a seguinte variante é interessante: Balance max + min Drawdown + Trades Number - quanto maior o número de negociações, mais confiável é o resultado. Ou a seguinte - Balance max + min Drawdown + max Profit Factor. é evidente que há muitas outras combinações interessantes que não estão inclusas nas configurações do provador de estratégia.

Vamos chamar essas combinações de critérios de critérios simples de otimização.

Mas esses critérios não são suficientes para fazer uma estimativa confiável de um sistema de negociação. Se partirmos da perspectiva do conceito de negociação - obter lucro correndo o menor risco - podemos presumir o seguinte critério: podemos otimizar os parâmetros para obter a curva de balanço mais suave com desvio mínimo de resultados de negociações separadas da linha reta.

Vamos chamar este critério de critério de otimização por curva de balanço.

O próximo critério de otimização que vamos usar é o coeficiente de segurança de um sistema de negociação. Este coeficiente foi descrito no artigo "Estar em fase". Ele caracteriza a correspondência de um sistema de negociação ao mercado; isto é o que devemos encontrar durante a otimização de parâmetros. Vamos chamá-lo de critério de otimização por coeficiente de segurança de um sistema de negociação (CSTS).

Além disso, vamos tornar possível a combinação livre dos critérios descritos.

4. A função OnTester()

Antes de escrever as partes do código, vamos dar uma olhada na organização do uso de critérios personalizados da otimização de EA no provador de estratégia.

A função OnTester() predefinida é destinada à criação de critérios de otimização personalizados. Ela é chamada automaticamente ao final de cada passagem de teste de um Expert Advisor dentro de um período de tempo especificado. Esta função é chamada imediatamente antes da chamada da função OnDeinit().

Mais uma vez, fique atento que, para o uso da função OnTester(), você deve habilitar o modo de otimização Rápida - algorítimo genético básico conforme apresentado na Figura 1.

Esta função tem o formato double de valor retornado, que é usado para a otimização no provador de estratégia.

Observe a documentação outra vez:

Na otimização genética, a classificação decrescente é aplicada aos resultados de uma geração. Ou seja, do ponto de vista do critério de otimização, os melhores resultados são aqueles de maior valor. Neste tipo de classificação, os piores valores são posicionados ao final e posteriormente descartados, de forma que não participam da formação da próxima geração.

Assim, ao criar um critério personalizado de otimização, precisamos obter um valor integral que será utilizado para a estimativa de negociação do Expert Advisor. Quanto maior o valor, melhor será a negociação do Expert Advisor.

5. Escrever um Expert Advisor experimental

Agora é hora de criar um Expert Advisor para otimizarmos no provador de estratégia. Neste caso, os principais requisitos são que ele seja simples e rápido para não perdermos tempo para o procedimento de rotina de otimização. Além disso, é desejável que o Expert Advisor não seja muito deficitário.

Vamos adotar como experimental o Expert Advisor descrito no artigo "Diversas maneiras de encontrar uma tendência no MQL5" e aperfeiçoá-lo. Notavelmente, o EA baseado no "leque" de três médias móveis. A melhoria consiste em livrar-se do uso do indicador para aumentar a velocidade da operação e mover a parte de cálculo do código para dentro do próprio EA. Isto permite aumentar significativamente a velocidade de teste (quase três vezes em um período de dois anos).

A parte de configuração de parâmetros de entrada é simples:

input double Lots = 0.1; 
input int  MA1Period = 200; // period of the greatest moving average
input int  MA2Period = 50;  // period of the medium moving average
input int  MA3Period = 21;  // period of the smallest moving average

O que vamos otimizar são os períodos das médias móveis.

A estrutura e a operação do Expert Advisor estão descritas em detalhes no artigo supracitado, então não as abordaremos aqui. A principal inovação é o handler de evento de conclusão de outra aprovação de teste - a função OnTester(). No momento, ela está vazia e retorna o controle.

//---------------------------------------------------------------------
//  The handler of the event of completion of another test pass:
//---------------------------------------------------------------------
double OnTester()
{
  return(0.0);
}

O arquivo do EA, FanExpert.mq5, está anexo a este artigo. Podemos nos certificar de que ele é idêntico ao EA FanTrendExpert.mq5 do ponto de vista das negociações realizadas. A verificação da existência e da direção de um sinal é realizada na abertura de uma nova barra no gráfico.

Para obter o resultado do teste calculado ao fim de cada aprovação, o TesterStatistics() é utilizado; ele devolve os valores estatísticos calculados como resultado do teste. Ele apenas pode ser chamado a partir das funções OnTester() e OnDeinit(), senão o resultado será indefinido.

Agora, vamos adicionar um critério de otimização personalizado. Suponha que nós tenhamos que encontrar os resultados ótimos com base no valor máximo do fator de recuperação - max Recovery Factor. Para fazer isso, precisamos conhecer os valores máximo de redução de balanço em dinheiro e o lucro bruto ao final do teste. O fator de recuperação é calculado como a divisão do lucro na redução máxima.

Isto é feito somente como exemplo, visto que o fator de recuperação já está incluso na lista dos resultados estatísticos do teste calculados.

Para fazer isso, adicione o seguinte código simples à função OnTester():

//---------------------------------------------------------------------
//  The handler of the event of completion of another test pass:
//---------------------------------------------------------------------
double OnTester()
{
  double  profit = TesterStatistics(STAT_PROFIT);
  double  max_dd = TesterStatistics(STAT_BALANCE_DD);
  double  rec_factor = profit/max_dd;

  return(rec_factor);
}

A verificação de divisão por zero é excluída do código para torná-lo mais fácil. Porque a redução máxima pode ser igual a zero, esta verificação deve ser feita em um Expert Advisor real.

Agora, vamos criar o critério mencionado acima: Balance max + min Drawdown + Trades Number - Balanço + Redução mínima + Número de negociações.

Para fazer isso, altere a função OnTester() da seguinte maneira:

double OnTester()
{
  double  param = 0.0;

//  Balance max + min Drawdown + Trades Number:
  double  balance = TesterStatistics(STAT_PROFIT);
  double  min_dd = TesterStatistics(STAT_BALANCE_DD);
  if(min_dd > 0.0)
  {
    min_dd = 1.0 / min_dd;
  }
  double  trades_number = TesterStatistics(STAT_TRADES);
  param = balance * min_dd * trades_number;

  return(param);
}

Aqui nós pegamos um valor que é oposto à retirada, porque quanto menor a retirada, melhor é a situação, considerando-se que as outras condições sejam iguais. Execute a otimização do EA FanExpert com o critério de otimização criado pelo parâmetro MA1Period utilizando o intervalo 2009.06.01 - 2011.06.03 e o período de tempo Н1. Estabeleça o limite de valores da média móvel de 100 a 2000.

Ao fim da otimização, você obterá a seguinte tabela de valores classificada pelos melhores parâmetros:

Figura 2. Os melhores resultados de otimização pelo critério Balanço máx. + Redução mín. + Número de negociações

Os melhores parâmetros estão listados aqui (perto da coluna Resultado).

Agora, vamos observar os piores parâmetros:

Figura 3. Os piores parâmetros de otimização pelo critério Balanço máx. + Redução mín. + Número de negociações

Comparando as duas tabelas, você pode ver que a redução e o lucro são considerados juntamente com o número de negociações, ou seja, nosso critério de otimização está funcionando. Além disso, podemos ver o gráfico de otimização (linear):

Figura 4. Gráfico de otimização para o critério Balanço máx. + Redução mín. + Número de negociações

O eixo horizontal exibe o parâmetro otimizado e o vertical exibe o critério de otimização. Podemos perceber o máximo nítido do critério estabelecido; está localizado dentro do limite de 980 a 1200.

Você deve entender e lembrar que isto é a otimização genética dos parâmetros, e não a busca completa. Esta é a razão pela qual as tabelas exibidas nas Figuras 2 e 3 contêm os parâmetros mais "viáveis" que passaram na seleção natural por diversas gerações. Provavelmente, algumas variantes bem-sucedidas foram descartadas.

A curva balanço/participação do período 1106 tem o seguinte aspecto:

Figura 5. Curva balanço/participação do período MA1Period = 1106

6. Criação de classes de critérios de otimização personalizados

Já aprendemos como criar e usar critérios simples de otimização. Agora, vamos criar uma classe para simplificar o uso dos critérios nos Expert Advisors. Um dos principais requisitos para esta classe é a velocidade de operação, além da conveniência de uso. Os cálculos dos critérios de otimização devem ser feitos rapidamente, senão você esperará muito tempo pelos resultados.

O MetaTrader 5 permite o uso da tecnologia de cálculo em nuvem para a otimização. Este é um grande avanço, visto que o processamento de um grande número de parâmetros requer um enorme poder de cálculo. Assim, para o desenvolvimento de nossa classe, utilizaremos as soluções mais simples e rápidas, mesmo que elas não sejam tão elegantes do ponto de vista da programação.

Para o desenvolvimento, utilizaremos as classes de organização de dados padrão que são entregues juntamente com o terminal do cliente.

Primeiramente, vamos classificar os tipos de resultados estatísticos do teste calculados:

• Tipo flutuante ou inteiro com proporcionalidade direta entre os valores do resultado de teste e critério de otimização.

Em outras palavras, quanto maior o valor do resultado de teste, melhor e maior é o valor do critério de otimização. Um claro exemplo desse resultado de teste é o Lucro bruto ao final do teste do STAT_PROFIT. O valor tem o formato flutuante e pode mudar de infinito negativo (na verdade, é limitado pelo valor de depósito) a infinito positivo.

Outro exemplo do resultado de teste desse tipo é o Número de negociações STAT_TRADES. Geralmente, quanto maior o número de negociações, mais confiável é o resultado da otimização. O valor tem o formato inteiro e pode mudar de zero a infinito positivo.

• Tipo flutuante ou inteiro com proporcionalidade inversa entre os valores do resultado de teste e critério de otimização.

Em outras palavras, quanto menor o valor do resultado de teste, melhor e maior é o valor do critério de otimização. Um exemplo desse resultado de teste é a Redução máxima de balanço em dinheiro STAT_BALANCE_DD bem como qualquer outra redução.

Para obter esse tipo de resultado de teste, iremos usar um valor inverso para calcular o valor do critério de otimização. é claro que temos que implementar a verificação de divisão por zero para evitar o erro correspondente.

A classe base para criação de critério personalizado de otimização,TCustomCriterion, é muito simples. O seu propósito é determinar a funcionalidade da base. Ela tem o seguinte aspecto:

class TCustomCriterion : public CObject
{
protected:
  int     criterion_level;        // type of criterion

public:
  int   GetCriterionLevel();
  virtual double  GetCriterion();  // get value of the result of optimization
};

O método virtual TCustomCriterion::GetCriterion deve ser substituído nas classes herdadas. Este é o principal método que retorna o valor do resultado integral do teste de um Expert Advisor ao final de cada aprovação de teste.

O membro de classe TCustomCriterion::criterion_level armazena o tipo de critério personalizado inerente a esta instância de classe. Ele será usado também para separar os objetos pelos seus tipos.

Agora, podemos herdar dele todas as classes requeridas para a otimização.

A classe TSimpleCriterion tem o propósito de criar critérios personalizados "simples" que correspondam a um resultado estatístico do teste especificado. A sua determinação é a seguinte:

class TSimpleCriterion : public TCustomCriterion
{
protected:
  ENUM_STATISTICS  stat_param_type;

public:
  ENUM_STATISTICS  GetCriterionType();     // get type of optimized stat. parameter

public:
  virtual double   GetCriterion();           // получить значение результата оптимизации
  TSimpleCriterion(ENUM_STATISTICS _stat); // конструктор
};

Aqui nós utilizamos um construtor com parâmetros; ele é implementado da seguinte forma:

//---------------------------------------------------------------------
//  Constructor:
//---------------------------------------------------------------------
TSimpleCriterion::TSimpleCriterion(ENUM_STATISTICS _stat)
:
stat_param_type( _stat )
{
  criterion_level = 0;
}

O uso deste novo recurso da linguagem MQL5 é conveniente para a criação de instâncias de classe. Além disso, nós substituímos o método virtual TSimpleCriterion::GetCriterion que é usado para obter o resultado da otimização ao final de cada aprovação de teste. A sua implementação é simples:

//---------------------------------------------------------------------
//  Get the result of optimization:
//---------------------------------------------------------------------
double  TSimpleCriterion::GetCriterion()
{
  return(TesterStatistics(stat_param_type));
 }

Como você pode ver, ele apenas retorna o resultado estatístico do teste correspondente.

O próximo tipo de critério personalizado "simples" é criado com o uso da classe TSimpleDivCriterion. Ele se destina aos critérios com proporcionalidade inversa entre os valores do resultado de teste e critério de otimização.

O método TSimpleDivCriterion::GetCriterion tem o seguinte aspecto:

//---------------------------------------------------------------------
//  Get value of the optimization result:
//---------------------------------------------------------------------
double  TSimpleDivCriterion::GetCriterion()
{
  double  temp = TesterStatistics(stat_param_type);
  if(temp>0.0)
  {
    return(1.0/temp);
  }
  return(0.0);
}

Este código não requer qualquer descrição adicional.

Os outros dois tipos de critério personalizado "simples" são criados com o uso das classes TSimpleMinCriterion e TSimpleMaxCriterion. Eles se destinam à criação de critérios com valores limitados do resultado estatístico de teste. No caso, o valor mínimo e máximo, respectivamente.

Eles podem ser úteis caso você precise descartar deliberadamente valores errados de parâmetros durante a otimização. Por exemplo, você pode limitar o número mínimo de negociações, redução máxima, etc.

A descrição da classe TSimpleMinCriterion é a seguinte:

class TSimpleMinCriterion : public TSimpleCriterion
{
  double  min_stat_param;

public:
  virtual double  GetCriterion();    // получить значение результата оптимизации
  TSimpleMinCriterion(ENUM_STATISTICS _stat, double _min);
};

Aqui nós usamos o construtor com dois parâmetros. O parâmetro _min estabelece o valor mínimo de um resultado estatístico do teste. Se outra aprovação de teste resulta na obtenção de valores que sejam inferiores ao especificado, o resultado é descartado.

A implementação do método TSimpleMinCriterion ::GetCriterion é a seguinte:

//---------------------------------------------------------------------
//  Get value of the optimization result:
//---------------------------------------------------------------------
double  TSimpleMinCriterion::GetCriterion()
{
  double  temp = TesterStatistics(stat_param_type);
  if(temp<this.min_stat_param)
  {
    return(-1.0);
  }
  return(temp);
}

A classe TSimpleMaxCriterion é feita de forma similar e não requer qualquer descrição adicional. As outras classes de critérios personalizados "simples" são feitas de maneira similar às descritas acima; elas estão localizadas no arquivo CustomOptimisation.mqh anexo a este artigo. O mesmo princípio pode ser usado para o desenvolvimento de qualquer outra classe a ser usada na otimização.

Antes de usar as classes descritas acima, vamos criar uma classe container para uma operação mais conveniente com o conjunto de critérios. Para esse propósito, também usamos as classes de organização de dados padrão. Porque precisamos de um processamento de critérios resultante simples, a classe mais adequada para isto é a CArrayObj. Ela permite a organização de um array dinâmico de objetos herdados da classe CObject.

A descrição da classe container TCustomCriterionArray é muito simples:

class TCustomCriterionArray : public CArrayObj
{
public:
  virtual double  GetCriterion( );  // get value of the optimization result
};

Ela possui apenas um método - TCustomCriterionArray::GetCriterion, o qual retorna o valor do critério de otimização ao final de cada aprovação de teste. A sua implementação é a seguinte:

double  TCustomCriterionArray::GetCriterion()
{
  double  temp = 1.0;
  int     count = this.Total();
  if(count == 0)
  {
    return(0.0);
  }
  for(int i=0; i<count; i++)
  {
    temp *= ((TCustomCriterion*)(this.At(i))).GetCriterion();
    if(temp <= 0.0)
    {
      return(temp);
    }
  }

  return(temp);
}

Você deve ficar atento para o seguinte: caso você encontre um valor negativo ao processar os critérios, a próxima passagem do ciclo torna-se inútil. Além disso, ela elimina a situação em que você obtém um valor positivo como resultado da multiplicação de dois valores negativos.

7. Utilização de classes de critérios de otimização personalizados

Então, temos todo o necessário para usar os critérios de otimização "simples" dos Expert Advisors. Vamos analisar a sequência de passos de otimização do EA FanExpert "experimental":

• Adicionar o arquivo incluso que contém a descrição de classes dos critérios personalizados.

#include <CustomOptimisation.mqh>

• Adicionar o ponteiro para o objeto da classe container para utilizar os critérios personalizados:

TCustomCriterionArray*  criterion_Ptr;

• Inicializar o ponteiro para o objeto da classe container para utilizar os critérios personalizados:

  criterion_array = new TCustomCriterionArray();
  if(CheckPointer(criterion_array) == POINTER_INVALID)
  {
    return(-1);
  }

Isto é feito na função OnInit. Caso a criação de objeto não tenha êxito, retorne com um valor negativo. Neste caso, o Expert Advisor interrompe a operação.

• Adicione os critérios de otimização requeridos ao Expert Advisor:

  criterion_Ptr.Add(new TSimpleCriterion(STAT_PROFIT));
  criterion_Ptr.Add(new TSimpleDivCriterion(STAT_BALANCE_DD));
  criterion_Ptr.Add(new TSimpleMinCriterion(STAT_TRADES, 20.0));

Neste caso, decidimos otimizar o EA por lucro máximo, redução mínima e número máximo de negociações. Adicionalmente, descartamos os conjuntos de parâmetros externos do Expert Advisor que resultam em menos de vinte negociações.

• Adicione a chamada correspondente à função OnTester:

  return(criterion_Ptr.GetCriterion());

• Na função OnDeinit, adicione o código para eliminação do objeto container:

  if(CheckPointer(criterion_Ptr) == POINTER_DYNAMIC)
  {
    delete(criterion_Ptr);
  }

Terminamos a otimização. Execute a otimização e certifique-se de que tudo esteja funcionando como deve. Para fazer isso, defina os parâmetros na aba Configurações do provador de estratégia, conforme apresentado na figura abaixo:

Figura 6. Configurações do provador de estratégia

O conjunto de variações de otimização de parâmetros de entrada na aba Parâmetros de entrada do provador de estratégia é apresentado na Figura 7:

Figura 7. Parâmetros de entrada otimizados

Utilize os agentes "em nuvem" para a otimização. Para fazer isso, estabeleça os seguintes parâmetros na aba Agentes:

Figura 8. Parâmetros de agentes de teste

Agora clique no botão Iniciar (Figura 6) e espere o término da otimização. Ao usar a tecnologia de cálculo "em nuvem", a otimização é muito rápida. Ao final, nós obtemos os seguintes resultados da otimização pelos critérios especificados:

Figura 9. Resultados da otimização

Nosso Expert Advisor "experimental" foi otimizado com sucesso. Com o uso dos agentes "em nuvem", a otimização demorou 13 minutos. O EA para verificação deste critério está no arquivo FanExpertSimple.mq5 anexo ao artigo.

8. Criação de uma classe de critério de otimização personalizado com base em análise de curva de balanço

A base para criação desta classe é o artigo "Controlar a inclinação da curva de balanço durante o trabalho de um Expert Advisor". A ideia deste critério de otimização é fazer com que a linha de balanço seja o mais próximo possível de uma linha reta. O grau de proximidade a uma linha reta será estimado pelo valor de desvio padrão dos resultados de negociação a partir dela A equação da linha reta será calculado para a linha de regressão desenhada pelos resultados das negociações no provador de estratégia.

Para descartar curvas com balanço resultante negativo, estabeleça limites adicionais - o lucro resultante deve ser maior que um valor especificado e o número de negociações não pode ser inferior a um valor especificado.

Assim, o nosso critério de otimização será inversamente proporcional ao valor do desvio padrão dos resultados de negociação da linha reta, considerando-se os limites de lucro resultante e número de negociações.

Para implementar o critério de otimização com base na curva de balanço, precisamos da classe TBalanceSlope do artigo mencionado acima. Nós vamos alterá-la: utilize construtores com parâmetros (por conveniência) e adicione o cálculo de desvio padrão ao cálculo da regressão linear. Este código esta localizado no arquivo BalanceSlope.mqh anexado ao artigo.

A sequência de passos para adicionar este critério de otimização ao Expert Advisor é a mesma que foi descrita acima. Agora, o critério de otimização tem o seguinte aspecto:

criterion_Ptr.Add(new TBalanceSlopeCriterion(Symbol( ), 10000.0));

Além do critério da curva de balanço, podemos adicionar outros critérios desenvolvidos por nós. Para os leitores, deixo a possibilidade de experimentar diferentes conjuntos de parâmetros estatísticos de teste.

Vamos realizar a otimização pelos critérios estabelecidos. Para obter mais negociações, realize a otimização utilizando o período de tempo H4, o período 2010.01.01 - 2011.01.01 e o símbolo EURUSD. Iremos obter um conjunto de resultados:

Figura 10. Resultado da otimização por curva de balanço

Agora, precisamos calcular a qualidade da otimização. Consideramos que o principal critério seja o trabalho do Expert Advisor fora do período de otimização. Para verificar isto, execute um único teste dentro do período 2010.01.01-2011.06.14.

Compare dois resultados (que têm quase o mesmo lucro resultante) do conjunto de parâmetros ótimos - o melhor resultado com um resultado do meio. Os resultados que estão fora do período de otimização são separados com a linha vermelha:

Figura 11. O melhor resultado de otimização

Em geral, o comportamento da curva não piorou. A lucratividade diminuiu levemente, de 1,60 para 1,56.

Figura 12. O resultado médio de otimização

O Expert Advisor não é lucrativo fora do período de otimização. A lucratividade diminuiu significativamente, de 2,17 para 1,75.

Assim, podemos chegar à conclusão de que a hipótese de correlação da curva de balanço com a duração do trabalho dos parâmetros otimizados tem direito de existir. Certamente, não podemos excluir a variante quando um resultado aceitável do uso deste critério não pode ser alcançado por um Expert Advisor. Neste caso, precisamos realizar algumas análises e experimentações adicionais.

é provável que tenhamos que usar o período máximo possível (mas razoável) para este critério. O Expert Advisor para verificação deste critério está no arquivo FanExpertBalance.mq5 anexo ao artigo.

9. Criação de uma classe de critério de otimização personalizado com base no Coeficiente do Sistema de Negociação Segura (CSTS)

Conforme descrito no artigo "Estar em fase", o coeficiente do sistema de negociação segura (CSTS) é calculado com o uso da seguinte fórmula:

CSTS = Avg.Win / Avg.Loss ((110% - %Win) / (%Win-10%) + 1)

Em que:

• Avg.Win - o valor médio de uma negociação lucrativa;
• Avg.Loss - o valor médio de uma negociação com perdas;
• %Win - o percentual de negociações lucrativas.

Se o valor do CSTS é inferior a 1, o sistema de negociação está na zona de alto risco de negociação; mesmo valores menores indicam a zona de negociação deficitária. Quanto maior o valor do CSTS, melhor a adaptação do sistema de negociação ao mercado e mais lucrativo ele é.

Todos os valores estatísticos requeridos para o cálculo do CSTS são calculados no provador de estratégia após cada aprovação de teste. Falta criar a classe TTSSFCriterion herdada do TCustomCriterion e implementar o método GetCriterion() nela. A implementação deste método no código é a seguinte:

double  TTSSFCriterion::GetCriterion()
{
  double  avg_win = TesterStatistics(STAT_GROSS_PROFIT) / TesterStatistics(STAT_PROFIT_TRADES);
  double  avg_loss = -TesterStatistics(STAT_GROSS_LOSS) / TesterStatistics(STAT_LOSS_TRADES);
  double  win_perc = 100.0 * TesterStatistics(STAT_PROFIT_TRADES) / TesterStatistics(STAT_TRADES);

//  Calculated safe ratio for this percentage of profitable deals:
  double  teor = (110.0 - win_perc) / (win_perc - 10.0) + 1.0;

//  Calculate real ratio:
  double  real = avg_win / avg_loss;

//  CSTS:
  double  tssf = real / teor;

  return(tssf);
}

Imaginamos que períodos curtos de tempo sejam adequados para este critério de otimização. Entretanto, para evitar ajustes, devemos selecionar os resultados que estão no meio dos resultados da otimização.

Vamos dar aos leitores a possibilidade de realizar suas próprias otimizações. O Expert Advisor para verificação deste critério está no arquivo FanExpertTSSF.mq5 anexo ao artigo.

Conclusão

De qualquer forma, você deve admitir que uma solução tão simples para a implementação da possibilidade de criar critérios de otimização personalizados (utilizando uma única classificação integral) é quase perfeita em comparação com outras variantes. Isso permite melhorar o nível do desenvolvimento de sistemas de negociação confiáveis. O uso da tecnologia de "nuvem" diminui significativamente a limitação das otimizações realizadas.

Formas adicionais de evolução podem estar relacionadas aos critérios comprovados matematicamente e estatisticamente, descritos em diferentes fontes de informação. Nós temos uma ferramenta para isso.