Redes neurais de maneira fácil (Parte 40): Abordagens para usar Go-Explore em uma grande quantidade de dados

Introdução

No artigo anterior Redes neurais de maneira fácil (Parte 39): Go-Explore - uma abordagem diferente para exploração, nós nos familiarizamos com o algoritmo Go-Explore e sua capacidade de explorar efetivamente o ambiente circundante. Lembre-se de que este algoritmo consiste em 2 fases:

• Fase 1 — Exploração
  
• Fase 2 — Treinamento da Política com Base em Exemplos

Na Fase 1, usamos a seleção aleatória de ações para obter uma imagem completa do ambiente circundante. Essa abordagem nos permitiu reunir uma base de exemplos suficiente para treinar com sucesso um agente com base em dados históricos em um mês do calendário. O modelo que construímos foi capaz de encontrar uma estratégia para obter lucro no conjunto de treinamento.

No entanto, um mês do calendário é um período de tempo muito curto para generalizar os dados e construir uma estratégia que possa ser lucrativa no futuro imediato. Portanto, para encontrar sua própria estratégia, somos obrigados a estender o período de treinamento. Ao aumentar o período de treinamento para três meses, descobrimos que o uso da seleção aleatória de ações não resulta em nenhum passe lucrativo.

Do ponto de vista da teoria das probabilidades, esse resultado é completamente esperado. A probabilidade de um evento composto é igual ao produto das probabilidades de todas as suas partes constituintes. No entanto, uma vez que a probabilidade de cada evento individual é menor que 1, à medida que o número de etapas aumenta, a probabilidade de obter um passe lucrativo diminui.

Também é importante observar que, ao aumentar o período de treinamento, podem ocorrer mudanças no ambiente circundante que podem afetar os resultados do treinamento do agente. Portanto, é crucial realizar monitoramento regular do desempenho do agente e analisar seu desempenho em estágios intermediários.

Para melhorar os resultados do treinamento em um período mais longo, podem ser aplicados vários métodos de otimização do algoritmo Go-Explore, como a adoção de uma abordagem aprimorada para a seleção de ações. Essa abordagem deve levar em consideração um contexto mais amplo da tarefa e permitir que o agente tome decisões mais fundamentadas.

Neste artigo, examinaremos mais detalhadamente os métodos de otimização possíveis do algoritmo Go-Explore para aumentar sua eficácia em períodos de treinamento mais longos.

1. Desafios do uso do Go-Explore com aumento do período de treinamento

Com o aumento do período de treinamento do algoritmo Go-Explore, surgem desafios específicos que podem dificultar sua utilização. Alguns deles incluem:

1. Problema da Maldição da Dimensionalidade: Com o aumento do período de treinamento, o número de estados que o agente pode visitar cresce exponencialmente, tornando a tarefa de encontrar uma estratégia ótima mais complexa.

2. Alteração no Ambiente: Com o aumento do período de treinamento, podem ocorrer mudanças no ambiente circundante que podem afetar os resultados do treinamento do agente. Isso pode fazer com que uma estratégia anteriormente bem-sucedida se torne ineficaz ou até impossível.

3. Complexidade na Escolha de Ações: À medida que o período de treinamento aumenta, o agente pode precisar considerar um contexto mais amplo da tarefa para tomar decisões fundamentadas. Isso pode complicar a tarefa de escolher a ação ótima e exigir métodos de otimização do algoritmo mais complexos.

4. Aumento do Tempo de Treinamento: Com o aumento do período de treinamento, o tempo necessário para coletar dados suficientes e treinar o modelo também aumenta. Isso pode reduzir a eficácia e a rapidez do treinamento do agente.

Com o aumento do período de treinamento, pode surgir o problema do aumento da dimensionalidade do espaço de estados a ser explorado. Isso pode levar ao problema da "maldição da dimensionalidade", onde o número de estados possíveis aumenta exponencialmente com o aumento da dimensionalidade. Isso torna a exploração do espaço de estados mais difícil e pode fazer com que o algoritmo gaste muito tempo explorando estados irrelevantes.

Para resolver esse problema, podem ser usados métodos de redução de dimensionalidade, como o PCA, por exemplo. Esses métodos permitem reduzir a dimensionalidade do espaço de estados, preservando ao mesmo tempo informações sobre a estrutura dos dados. Também é possível usar métodos de seleção de recursos mais importantes para reduzir a dimensionalidade do espaço de estados e concentrar-se nos aspectos mais significativos da tarefa.

Além disso, para explorar o espaço de estados de forma mais eficaz, podem ser utilizados métodos adicionais, como otimização baseada em algoritmos evolutivos ou genéticos, que permitem buscar soluções ótimas em espaços de estados amplos. Esses métodos permitem explorar diferentes comportamentos do agente e selecionar as soluções mais ótimas para a tarefa específica.

Também é possível usar abordagens diferentes para a seleção de ações, como métodos de exploração com base na confiança, que permitem ao agente explorar novas regiões do espaço de estados levando em consideração não apenas a probabilidade de recompensa, mas também a confiança em seu conhecimento sobre a tarefa. Isso pode ajudar a evitar o problema de ficar preso em ótimos locais e garantir uma exploração mais eficaz do espaço de estados.

Ao demonstrar o método de Aprendizado por Reforço (RL), geralmente são usados jogos de computador ou outro ambiente artificialmente simulado que é estacionário, ou seja, não muda com o tempo. No entanto, em aplicações do mundo real, o ambiente pode mudar ao longo do tempo, o que pode afetar os resultados do treinamento do agente.

Ao usar o algoritmo Go-Explore, que inclui uma fase de exploração do ambiente para obter dados históricos, a mudança no ambiente pode levar a resultados inesperados ao treinar o agente com base em dados históricos.

Por exemplo, se o agente foi treinado com dados por vários meses e durante esse período ocorreram mudanças no ambiente, como mudanças nas regras do jogo ou a introdução de novos objetos, o agente pode não se adaptar ao novo ambiente, e sua estratégia anteriormente bem-sucedida pode se tornar ineficaz ou até impossível.

Para reduzir o impacto das mudanças no ambiente nos resultados do treinamento do agente, é necessário realizar monitoramento regular do ambiente e analisar suas mudanças durante o treinamento do agente. Se mudanças significativas no ambiente forem identificadas, é necessário reiniciar o processo de treinamento do agente usando dados e algoritmos atualizados.

Também é possível usar métodos de treinamento que levam em consideração a mudança no ambiente durante o treinamento, como métodos baseados em modelos de Aprendizado por Reforço (model-based RL), que constroem um modelo do ambiente e o usam para prever estados futuros e recompensas. Isso permite que o agente se adapte às mudanças no ambiente e tome decisões mais fundamentadas.

Você também pode usar outros métodos de otimização, como ajustar os hiperparâmetros do algoritmo ou fazer modificações no próprio algoritmo para um treinamento mais eficaz.

Em resumo, o uso do algoritmo Go-Explore para treinar agentes em períodos mais longos pode ser bastante complexo e requer várias soluções técnicas e melhorias.

No final, o uso do algoritmo Go-Explore pode ser desafiador e requer várias soluções técnicas e melhorias. O algoritmo Go-Explore é uma ferramenta poderosa para explorar ambientes complexos e treinar agentes em tarefas com um grande número de estados e ações. No entanto, sua eficácia pode diminuir com o aumento do período de treinamento e mudanças nas condições da tarefa. Portanto, é necessário usar diferentes métodos de otimização e ajuste de parâmetros para alcançar os melhores resultados. Isso pode ser um campo de pesquisa muito promissor.

2. Opções para otimizar a abordagem

A partir do que foi discutido, fica claro que estender o período de treinamento exige uma abordagem mais cuidadosa do que simplesmente ajustar as datas no testador de estratégias e carregar dados históricos adicionais. Para criar uma estratégia de negociação real, é necessário treinar o modelo com a maior quantidade possível de dados históricos. Somente essa abordagem permitirá criar um modelo capaz de gerar lucro no futuro.

Neste artigo, não vamos complicar o modelo. Em vez disso, usaremos algumas abordagens simples que ajudarão a ampliar a profundidade dos dados históricos para treinar o modelo com o algoritmo Go-Explore.

Antes de otimizar o algoritmo anteriormente criado, é necessário analisar suas limitações.

O primeiro passo será alterar as constantes na estrutura da célula (Cell). Esta estrutura é usada para armazenar o estado individual do sistema e o caminho percorrido. Devido a limitações técnicas, somos obrigados a usar apenas arrays estáticos nesta estrutura. À medida que aumentamos o período de treinamento do modelo, o tamanho do caminho para alcançar o estado descrito aumenta. Para lidar com isso, já previamente criamos uma constante que especifica o tamanho do array. Agora, precisamos ajustar o valor dessa constante para garantir espaço suficiente para registrar o caminho completo percorrido pelo agente do início ao fim do período de treinamento.

Para determinar o valor da constante, usaremos uma matemática simples. Em média, um mês do calendário possui 21-22 dias úteis. Para evitar erros, usaremos o valor máximo de dias úteis, que é 22. Em 4 meses, teremos 88 dias úteis.

Ao testar modelos, usamos o intervalo de tempo H1. Um dia tem 24 horas. Portanto, para treinar o modelo, precisaremos de um buffer com 2112 elementos (88 * 24). Esses cálculos levam em consideração valores máximos possíveis e fornecem uma margem de segurança em relação ao número real de barras, evitando erros críticos de estouro de array. No entanto, ao treinar com dados de cotações que incluem fins de semana (por exemplo, criptomoedas), é importante considerar os dias do calendário ao calcular o tamanho do buffer, levando em conta o período completo de treinamento e as características das cotações do instrumento.

#define                    Buffer_Size  2112

Um segundo ponto crítico é a ordenação dos exemplos antes de salvá-los. A prática demonstrou que a ordenação dos dados pode levar mais tempo do que o próprio processo de passagem pelos dados históricos e coleta desses estados. À medida que o período de treinamento aumenta, o volume de dados a ser ordenado também aumenta. Portanto, decidimos abandonar a ordenação dos dados. Como resultado, a função OnTesterDeinit no consultor Faza1.mq5 ficou da seguinte forma:

//+------------------------------------------------------------------+
//| TesterDeinit function                                            |
//+------------------------------------------------------------------+
void OnTesterDeinit()
  {
//---
   int total = ArraySize(Total);
   printf("total %d", total);
   Print("Saving...");
   SaveTotalBase();
   Print("Saved");
  }

Durante o processo de teste, observamos que o Expert Advisor frequentemente abre várias posições e as mantém abertas por longos períodos. Queríamos abordar esse problema adotando uma abordagem abrangente e fizemos algumas alterações no funcionamento do Expert Advisor de coleta de exemplos.

Uma das alterações está relacionada à definição da recompensa. Anteriormente, usávamos a variação no patrimônio líquido como recompensa. Esse método permitia que o modelo levasse em consideração as variações nos lucros acumulados e não realizados, penalizando as quedas e incentivando o acúmulo de lucros em posições lucrativas. No entanto, essa abordagem limitava a capacidade de realizar lucros. Não queríamos abandonar a vantagem do uso do patrimônio líquido, mas também queríamos adicionar uma recompensa pela realização de lucros.

Encontramos uma solução de compromisso, que envolve a utilização da média aritmética das variações no patrimônio líquido e no saldo da conta. Quando há ganhos ou perdas em uma posição aberta, o patrimônio líquido muda, mas o saldo da conta permanece inalterado. O agente recebe metade da variação acumulada no patrimônio líquido como recompensa ou penalização. Quando os lucros ou perdas são realizados, o patrimônio líquido não muda, mas o valor acumulado reflete no saldo da conta. O agente recebe a segunda metade da recompensa ou penalização atrasada. Dessa forma, o agente se torna mais interessado em fechar posições lucrativas e menos inclinado a manter posições abertas em excesso.

      Base[action_count - 1].value = ( Base[action_count - 1].state[241] - state[241] + 
                                       Base[action_count - 1].state[240] - state[240] ) / 2.0f;

Decidimos também limitar o volume máximo de posições abertas para reduzir a quantidade delas. Durante a criação de exemplos e o teste do modelo, utilizamos um volume mínimo fixo para cada negociação. Portanto, introduzir um limite no volume máximo de posições em aberto é essencialmente o mesmo que limitar a quantidade de posições em aberto. No entanto, ao descrever o estado atual do sistema, coletamos informações sobre o volume de posições em aberto e os lucros/prejuízos acumulados. Para evitar cálculos adicionais, utilizamos o volume de posições abertas para limitar o volume máximo possível. Definimos o valor máximo possível do volume de posições em aberto como uma variável externa, o que nos permite experimentar diferentes valores.

input double               MaxPosition = 0.1;

O objetivo final de nossa limitação ao máximo de posições abertas é reduzir o número de posições abertas na conta e evitar acumular negociações em bloqueio, seja positivo ou negativo. Para isso, verificamos as restrições separadamente para negociações longas e curtas, sem considerar a diferença entre elas.

É importante observar que não estamos impondo restrições explicitamente à nossa modelagem. Em vez disso, aplicamos restrições ao volume máximo de posições abertas durante a fase de criação de exemplos, que serão usados para treinar o modelo. Em seguida, usamos esses exemplos para treinar o modelo, e ele constrói sua própria estratégia com base nos exemplos fornecidos. Essa abordagem permite que o modelo se adapte à situação de mercado em constante mudança e escolha as ações mais eficazes.

No entanto, é importante notar que, no caso em que geramos uma ação para abrir uma posição, mas devido às restrições introduzidas, essa ação não pode ser executada, o estado subsequente do sistema e a recompensa não corresponderão à ação gerada. Para resolver esse problema, registramos na base de exemplos uma ação que corresponde à espera (ou seja, ausência de operações de negociação) caso a ação gerada não seja executada. Isso garante a correspondência entre ação e recompensa, garantindo um treinamento correto do modelo.

   switch(act)
     {
      case 0:
         if(buy_value >= MaxPosition || !Trade.Buy(Symb.LotsMin(), Symb.Name()))
            act = 3;
         break;
      case 1:
         if(sell_value >= MaxPosition || !Trade.Sell(Symb.LotsMin(), Symb.Name()))
            act = 3;
         break;
      case 2:
         for(int i = PositionsTotal() - 1; i >= 0; i--)
            if(PositionGetSymbol(i) == Symb.Name())
               if(!Trade.PositionClose(PositionGetInteger(POSITION_IDENTIFIER)))
                 {
                  act = 3;
                  break;
                 }
         break;
     }

Dado que estamos operando em condições de risco nos mercados, nosso objetivo não é apenas gerar lucro, mas também minimizar possíveis perdas. Para isso, adicionamos à nossa modelagem uma restrição de tempo máximo de retenção de uma posição aberta.

Essa restrição é representada por uma variável externa de valor inteiro que especifica o número máximo de barras que uma posição aberta pode ser mantida. 

input int                  MaxLifeTime = 48;

Determinamos o tempo de vida da posição mais antiga e quando o valor limite é atingido, forçamos a ação de fechamento de todas as posições.

Isso é feito para evitar que mantenhamos posições abertas por muito tempo, o que pode resultar em grandes perdas. Ao coletar informações sobre o estado atual da conta e das posições abertas, levamos em consideração esta limitação para não ultrapassar o tempo máximo de manutenção.

   int total = PositionsTotal();
   datetime time_current = TimeCurrent();
   int first_order = 0;
   for(int i = 0; i < total; i++)
     {
      if(PositionGetSymbol(i) != Symb.Name())
         continue;
      switch((int)PositionGetInteger(POSITION_TYPE))
        {
         case POSITION_TYPE_BUY:
            buy_value += PositionGetDouble(POSITION_VOLUME);
            buy_profit += PositionGetDouble(POSITION_PROFIT);
            break;
         case POSITION_TYPE_SELL:
            sell_value += PositionGetDouble(POSITION_VOLUME);
            sell_profit += PositionGetDouble(POSITION_PROFIT);
            break;
        }
      first_order = MathMax((int)(PositionGetInteger(POSITION_TIME) - time_current) / PeriodSeconds(TimeFrame), first_order);
     }

No entanto, se permitirmos que essa restrição seja violada, tomamos medidas apropriadas. Nesse caso, não apenas fechamos uma única posição quando o tempo se esgota, mas emitimos uma ação para fechar todas as posições, garantindo assim a consistência entre a ação executada, o novo estado e a recompensa, o que é crucial para o correto funcionamento do modelo.

   int act = (first_order < MaxLifeTime ? SampleAction(4) : 2);

Portanto, o uso da restrição de tempo máximo de retenção de uma posição aberta é mais um mecanismo de nossa modelagem que nos ajuda a controlar os riscos e alcançar resultados mais estáveis em condições de incerteza no mercado.

Descrevemos abordagens para otimizar o algoritmo com base nas deficiências identificadas durante o teste do modelo. Agora, passaremos para a abordagem de treinamento do modelo em um conjunto de dados históricos expandido. Consideraremos a possibilidade de dividir um grande conjunto de treinamento em partes menores e treinar o agente em cada uma dessas partes. Podemos supor que, se o algoritmo funcionar bem em intervalos de tempo menores, ele também poderá funcionar bem em intervalos de tempo mais longos. Portanto, podemos usar essa abordagem para melhorar o treinamento do modelo em grandes volumes de dados.

Essa abordagem permite que o modelo capture as tendências do mercado de forma mais eficaz e aumenta sua resistência a mudanças nos fatores externos. Isso é especialmente importante ao usar o modelo para negociações nos mercados reais, onde a previsão das mudanças na direção da tendência é um fator crucial. Além disso, essa abordagem permite que o modelo use os dados disponíveis de forma mais eficaz, em vez de apenas as observações mais recentes, o que, por sua vez, melhora a qualidade das previsões.

É importante observar que a divisão do conjunto de treinamento em segmentos de tempo menores deve ser realizada levando em consideração a ordem cronológica dos dados, a fim de evitar sobreposições de dados e deslocamentos nas previsões. Além disso, é importante notar que ao dividir os dados em segmentos menores, a quantidade de dados disponíveis para treinamento em cada segmento será menor, o que pode resultar em uma redução na precisão das previsões do modelo.

Portanto, a divisão do conjunto de treinamento em intervalos de tempo menores é uma abordagem eficaz para otimizar o algoritmo e pode significativamente aumentar a qualidade das previsões do modelo.

Ao dividir o conjunto de treinamento em episódios menores, nos deparamos com a necessidade de desenvolver uma estratégia geral que permita percorrer com sucesso todo o conjunto de treinamento. Para isso, podemos usar uma combinação de amostragem aleatória de ações e uma passagem direcionada por etapas pelo conjunto de treinamento, o que ajudará a encontrar a estratégia mais bem-sucedida e lucrativa.

A ideia é passar sequencialmente por pequenos episódios, usando amostragem aleatória de ações em cada episódio. Em seguida, selecionamos as passagens mais lucrativas e as usamos como ponto de partida para o próximo episódio. Dessa forma, percorremos todo o conjunto de treinamento sequencialmente, acumulando exemplos de estratégias lucrativas.

Esse método combina aparentemente ideias opostas: amostragem aleatória e treinamento direcionado. Com a amostragem aleatória, exploramos o ambiente circundante, enquanto o treinamento direcionado ao percorrer o conjunto de treinamento ajuda a encontrar a estratégia mais bem-sucedida. Como resultado, podemos obter uma estratégia mais generalizada e lucrativa para o nosso agente.

No geral, a combinação de amostragem aleatória e treinamento direcionado nos permite obter a estratégia mais ótima para percorrer o conjunto de treinamento, utilizando tanto a aleatoriedade quanto a experiência acumulada em ações bem-sucedidas.

Para implementar essa abordagem, introduziremos 3 variáveis externas:

• MinStartSteps — número mínimo de etapas antes do início da amostragem
• MaxSteps — número máximo de etapas de amostragem (tamanho do episódio)
• MinProfit — lucro mínimo para armazenamento no banco de dados de exemplos.

input int                  MinStartSteps = 96;
input int                  MaxSteps = 120;
input double               MinProfit = 10;

Durante a discussão sobre a otimização do algoritmo, descobrimos que a ordenação de exemplos antes de salvá-los não é eficaz. Em vez disso, decidimos usar a variável MinProfit para determinar o lucro mínimo necessário para que os exemplos sejam armazenados no banco de dados. Isso nos permite priorizar exemplos usados como pontos de partida para amostragem subsequente. Além disso, usamos a variável MinStartSteps para definir o número mínimo de etapas em um exemplo necessário para usá-lo como ponto de partida. Isso nos ajuda a evitar "ficar presos" em estágios intermediários durante a amostragem e avançar para o próximo episódio.

Também usamos a variável MaxSteps, que define o comprimento máximo de um episódio. Após exceder esse valor, a amostragem deixa de ser eficaz e precisamos salvar o caminho percorrido. Dessa forma, podemos utilizar os recursos de forma mais eficiente e acelerar o processo de treinamento.

No método OnInit do nosso EA Faza1.mq5, após carregar o banco de dados de exemplos criado anteriormente, primeiro filtramos os exemplos que atendem ao requisito de número de etapas percorridas.

   if(LoadTotalBase())
     {
      int total = ArraySize(Total);
      Cell temp[];
      ArrayResize(temp, total);
      int count = 0;
      for(int i = 0; i < total; i++)
         if(Total[i].total_actions >= MinStartSteps)
           {
            temp[count] = Total[i];
            count++;
           }

Em seguida, selecionamos aleatoriamente um exemplo entre os selecionados. Este exemplo escolhido aleatoriamente será usado como ponto de partida para a amostragem.

      if(count > 0)
        {
         count = (int)(((double)(MathRand() * MathRand()) / MathPow(32768.0, 2.0)) * (count - 1));
         StartCell = temp[count];
        }
      else
        {
         count = (int)(((double)(MathRand() * MathRand()) / MathPow(32768.0, 2.0)) * (total - 1));
         StartCell = Total[count];
        }
     }

No método OnTick do nosso EA, primeiro executamos todo o caminho até atingir o ponto de partida do nosso episódio.

void OnTick()
  {
//---
   if(!IsNewBar())
      return;
   bar++;
   if(bar < StartCell.total_actions)
     {
      switch(StartCell.actions[bar])
        {
         case 0:
            Trade.Buy(Symb.LotsMin(), Symb.Name());
            break;
         case 1:
            Trade.Sell(Symb.LotsMin(), Symb.Name());
            break;
         case 2:
            for(int i = PositionsTotal() - 1; i >= 0; i--)
               if(PositionGetSymbol(i) == Symb.Name())
                  Trade.PositionClose(PositionGetInteger(POSITION_IDENTIFIER));
            break;
        }
      return;
     }

E somente após atingirmos o início do nosso episódio é que prosseguimos com as operações de amostragem de ações. Nesse ínterim, controlamos a quantidade de ações aleatórias executadas, a qual não deve exceder o comprimento máximo do episódio. Caso o número máximo de etapas seja atingido, primeiro geramos uma ação para fechar todas as posições.

Caso atinja o número máximo de passos, primeiro geramos a ação de fechamento de todas as posições.

   int act = (action_count < MaxSteps || first_order < MaxLifeTime ? SampleAction(4) : 2);

E depois de um movimento, inicializamos o encerramento do EA.

   if(action_count > MaxSteps)
      ExpertRemove();

Após a conclusão da passagem no testador de estratégias, verificamos o tamanho do lucro obtido durante a mesma. Se o critério de alcançar um valor mínimo de rentabilidade for satisfeito, transmitimos os dados para adição ao banco de exemplos.

//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
//---
   double ret = 0.0;
//---
   double profit = TesterStatistics(STAT_PROFIT);
   action_count--;
   if(profit >= MinProfit)
      FrameAdd(MQLInfoString(MQL_PROGRAM_NAME), action_count, profit, Base);
//---
   return(ret);
  }

No texto do artigo, são apresentados e explicados apenas ajustes pontuais no código do EA. O código completo do EA pode ser encontrado no anexo.

3. Teste

Para coletar exemplos para treinar o modelo, como na edição anterior, usaremos dados históricos do par de moedas EURUSD, com intervalo de tempo H1. No entanto, desta vez, usaremos dados históricos de quatro meses de 2023.

Para explorar o ambiente da forma mais eficaz possível, é necessário usar valores diversos para os parâmetros externos durante a coleta de exemplos. Além disso, trataremos esses parâmetros como otimizáveis, o que nos permitirá alterar seus valores a cada passagem.

Para iniciar o processo de otimização, escolhemos dois parâmetros: MaxSteps e MaxLifeTime. Max Steps e Max Life Time. O primeiro parâmetro define o comprimento máximo de um episódio, após o qual a coleta de exemplos se torna ineficaz. O segundo parâmetro indica o tempo máximo que uma posição pode ser mantida em um único episódio. Ao usar diferentes valores para esses parâmetros durante a coleta de exemplos, podemos estudar o ambiente de forma mais abrangente.

Por exemplo, ao usar valores diferentes para MaxSteps e MaxLifeTime, podemos coletar exemplos para diferentes durações e períodos de retenção de posição. Isso nos permite obter exemplos para uma ampla variedade de situações que podem ocorrer no ambiente. Assim, podemos criar um modelo de aprendizado mais versátil e eficaz, que leve em consideração muitos cenários diferentes.

Definimos um valor de lucro limite próximo a zero, pois esta é a primeira execução e é suficiente obter um pequeno lucro.

Como resultado da primeira execução do processo de otimização, observamos várias execuções bem-sucedidas com um lucro de 46 USD nas duas primeiras semanas de janeiro de 2023. O fator de lucro dessas execuções atinge o valor de 1,55.

Antes de iniciar a otimização, faremos algumas alterações nos parâmetros. Para coletar exemplos em diferentes intervalos de tempo, adicionaremos à nossa variável otimizável o número mínimo de etapas antes do início da amostragem. Os valores dessa variável variarão de 1 a 3 semanas, com incrementos semanais. Além disso, melhoraremos os resultados obtidos aumentando o valor mínimo de lucro para 40 USD.

Após o segundo processo de otimização, observamos um aumento no lucro para 84 USD em janeiro de 2023. No entanto, o fator de lucro diminuiu para 1,38.

Apesar disso, notamos que nossas ações na otimização do processo de coleta de exemplos começam a dar resultados. Embora ainda não tenhamos alcançado sucesso final, a tendência geral de desenvolvimento está de acordo com nossos objetivos e expectativas.

Aumentaremos o valor mínimo de etapas antes do início da amostragem para a segunda semana de janeiro de 2023 e realizaremos outro processo de otimização. Desta vez, aumentaremos o valor mínimo de lucratividade para 80 USD, já que estamos buscando a estratégia mais lucrativa.

Conforme prevíamos, como resultado da subsequente otimização do processo de coleta de exemplos, conseguimos um aumento ainda maior na lucratividade. O lucro total da execução mais bem-sucedida aumentou para 125 USD. O fator de lucro diminuiu ligeiramente, para 1,36, o que ainda significa que o lucro supera os custos. É importante observar que esse aumento na lucratividade foi alcançado por meio do aprimoramento do processo de coleta de exemplos, e podemos ter confiança em sua eficácia. No entanto, é importante ressaltar que o processo de treinamento ainda não está concluído e continuaremos a trabalhar nele.

Continuamos as iterações de coleta de exemplos no modo de otimização do testador de estratégias, gradualmente ajustando o ponto de início da amostragem e alterando o valor mínimo de lucratividade. Esse método nos permitiu obter exemplos de várias execuções bem-sucedidas ao longo de todo o conjunto de dados de treinamento. O mais lucrativo deles rendeu 281 USD, com um fator de lucro de 1,5. Esses resultados confirmam que nossa estratégia de otimização do processo de coleta de exemplos está produzindo um efeito positivo e ajudando a alcançar níveis mais altos de lucratividade. No entanto, compreendemos que esse processo não está completo e requer otimização e aprimoramento contínuos.

Resultados

Após a conclusão do processo de coleta de exemplos, passamos para o treinamento do modelo usando o algoritmo Go-Explore, com base nos dados coletados. Em seguida, realizamos o treinamento adicional do modelo usando métodos de aprendizado por reforço para melhorar ainda mais seu desempenho.

Para avaliar a qualidade e eficácia do modelo treinado, realizamos testes usando conjuntos de dados de treinamento e teste. É importante observar que nosso modelo conseguiu gerar lucro com dados históricos da primeira semana de maio de 2023, que não estavam incluídos no conjunto de treinamento, mas imediatamente o seguiram.

Considerações finais

Neste artigo, exploramos métodos simples, porém eficazes, para otimizar o algoritmo Go-Explore, permitindo sua aplicação no treinamento de modelos com grandes volumes de dados de treinamento. Nosso modelo foi treinado com dados históricos de 4 meses, mas, graças ao uso de métodos de otimização, o algoritmo Go-Explore pode ser empregado no treinamento de modelos em períodos ainda mais longos. Também conduzimos testes do modelo com conjuntos de dados de treinamento e teste, confirmando sua alta eficácia e qualidade.

No geral, o algoritmo Go-Explore abre novas possibilidades para o treinamento de modelos em conjuntos de dados extensos e pode se tornar uma ferramenta poderosa em várias aplicações de inteligência artificial.

No entanto, é importante lembrar que os mercados financeiros são altamente dinâmicos e sujeitos a mudanças abruptas, portanto, mesmo o modelo de maior qualidade não pode garantir sucesso absoluto. Portanto, devemos monitorar constantemente as mudanças no mercado e adaptar nosso modelo conforme necessário.

Referências

1. Go-Explore: a New Approach for Hard-Exploration Problems
2. Redes neurais de maneira fácil (Parte 35): módulo de curiosidade intrínseca
3. Redes neurais de maneira fácil (Parte 36): modelos relacionais de aprendizado por reforço
4. Redes neurais de maneira fácil (Parte 37): atenção esparsa
5. Redes neurais de maneira fácil (Parte 38): exploração auto-supervisionada via desacordo
6. Redes neurais de maneira fácil (Parte 39): Go-Explore - uma abordagem diferente para exploração

Programas utilizados no artigo

#	Nome	Tipo	Descrição
1	Faza1.mq5	Expert Advisor	EA da primeira fase
2	Faza2.mql5	Expert Advisor	EA da segunda fase
3	GE-lerning.mq5	Expert Advisor	EA de ajuste fino de políticas
4	Cell.mqh	Biblioteca de classe	Estrutura de descrição do estado do sistema
5	FQF.mqh	Biblioteca de classe	Biblioteca de classes de preparação de modelos totalmente parametrizada
6	NeuroNet.mqh	Biblioteca de classe	Biblioteca de classes para a criação de uma rede neural
7	NeuroNet.cl	Biblioteca	Biblioteca do código do programa OpenCL