MetaTrader 5 Global Optimizer: Uma Estrutura Profissional para Otimizar EAs por Grupos, Subgrupos e Critérios de Robustez

Introdução

A otimização de Expert Advisors no MetaTrader 5 evoluiu muito além da simples busca pelo maior lucro em um único backtest. A própria comunidade MQL5 já vem explorando projetos avançados nessa direção, como a coleta estruturada de resultados com OnTesterInit, OnTesterPass e OnTesterDeinit no artigo “Collecting optimization results for single trading strategy”; a construção de robôs auto-otimizáveis em “Build Self Optimising Expert Advisors in MQL5”; a integração de MQL5 com Python em “Build Self Optimizing Expert Advisors With MQL5 And Python”; além de estudos sobre algoritmos alternativos de otimização. Essas abordagens apontam para uma mesma conclusão: otimizar um EA de forma profissional exige processo, rastreabilidade, comparação e critérios de robustez, e não apenas escolher o maior lucro em uma tabela de resultados.

Este artigo apresenta o MetaTrader 5 Global Optimizer, uma automação em Python. Ele organiza otimizações por grupos e subgrupos, compara cada etapa com uma linha de base, permite seleção manual, automática ou semiautomática e gera arquivos finais de auditoria. A proposta é transformar a otimização de qualquer EA em uma metodologia mais clara: cada bloco da estratégia é testado separadamente, seus resultados são consolidados em múltiplos ativos, os melhores sets são ranqueados por critérios de robustez e o usuário pode intervir antes que o processo siga para a próxima etapa.

Em vez de uma otimização tradicional (em que o resultado pode virar uma “caixa-preta”), esta estrutura registra decisões, linhas de base, conjuntos aceitos/rejeitados, retrocessos e reprocessamentos de extremos. 

O objetivo não é apenas automatizar a execução do Strategy Tester, mas criar uma camada de inteligência: uma estrutura capaz de reduzir decisões impulsivas, organizar grandes volumes de testes, evitar escolhas baseadas apenas em lucro e aproximar o desenvolvimento de EAs de um processo mais profissional de pesquisa, validação e melhoria contínua.

Para que serve o programa

O MetaTrader 5 Global Optimizer serve para transformar a otimização de um Expert Advisor em um fluxo organizado, repetível e auditável. Em vez de abrir o Strategy Tester manualmente, configurar um grupo de parâmetros, rodar, anotar resultados e repetir tudo, o Python gera os arquivos .set e .ini, chama o terminal, coleta os CSVs exportados pelo EA e compara os resultados de forma padronizada.

A ideia não é substituir a análise do desenvolvedor. A ideia é reduzir trabalho repetitivo, impedir decisões impulsivas baseadas em apenas um melhor resultado e criar um histórico claro do que foi aceito, rejeitado ou escolhido manualmente.

O programa é especialmente útil para EAs com muitos blocos lógicos: regime, entrada, stop, parcial, break-even, trailing, filtro de horário, indicadores, volatilidade, gestão por tempo, etc. Cada bloco pode virar um subgrupo de otimização.

Por que a automação está estruturada dessa forma

Uma otimização grande com todos os parâmetros ao mesmo tempo tende a gerar três problemas: excesso de combinações, risco de overfitting e dificuldade de entender qual parte do EA realmente melhorou. O modelo por grupos reduz esse problema, porque otimiza partes coerentes da estratégia em sequência.

A estrutura por baseline também é essencial. Antes de otimizar cada subgrupo, o programa testa os parâmetros atuais. Depois compara o melhor resultado otimizado contra esse baseline. Isso evita aceitar uma mudança que parece boa isoladamente, mas que piora a estabilidade geral.

O programa adiciona a escolha assistida dos sets. Isso é importante porque o melhor score matemático nem sempre é o melhor set para continuar a pesquisa. Um TOP 1 pode ter lucro maior, mas estar concentrado em um ativo, ter poucos trades, drawdown maior ou estar colado no extremo do range.

Problema no processo manual	Como o programa trata	Benefício prático
Ranges trocados manualmente	Ranges ficam em config.json ou comentários @opt no .mq5	Menos erro operacional
Otimização gigante e confusa	EA é dividido em grupos/subgrupos	Leitura lógica dos resultados
Lucro isolado engana	Cada grupo compara otimizado vs baseline	Menor chance de overfit
Resultado bom na borda do range	Detecta pressão de extremo e pode expandir	Evita cortar o range cedo demais
Ajuste final grosseiro	Rewind fino em torno dos melhores parâmetros	Refinamento controlado
Difícil repetir o estudo	Gera manifest, CSVs, relatório e .set final	Auditoria e reprodutibilidade

Características principais

Como funciona o processo

1. O trader define os parâmetros do estudo

Na primeira etapa, o trader escolhe:

• o robô de trading;
• os ativos que serão testados;
• o período histórico;
• o timeframe;
• o modo do Strategy Tester;
• o modelo de teste;
• o método de seleção dos melhores sets.

A configuração pode ser definida pelo wizard no PowerShell, por um arquivo config.json, por um arquivo .set base ou por comentários especiais @opt e @fixed no código MQL5.

2. O Python prepara a otimização

O Python lê os dados de entrada, identifica quais parâmetros devem ser otimizados, quais devem permanecer fixos e gera automaticamente os arquivos de trabalho para o MetaTrader 5.

Para cada ativo e grupo de parâmetros, são criados:

• arquivos .set com os intervalos de otimização;
• arquivos .ini para iniciar o terminal64.exe;
• estrutura de pastas para relatórios, CSVs e resultados intermediários.

Isso elimina grande parte da preparação manual e reduz o risco de erros.

3. O MetaTrader 5 executa os testes

O MetaTrader 5 executa o backtest e a otimização por meio do Strategy Tester.

O EA em MQL5 calcula seu próprio score pela função OnTester e exporta os resultados de cada passagem para CSV.

Nos dados finais, ficam registradas as principais métricas:

• net profit;
• Profit Factor;
• drawdown;
• número de trades;
• recovery factor;
• score;
• conjunto de parâmetros usado em cada passagem

4. A sistema compara e seleciona os melhores sets

Após cada série de otimização, o Python lê os arquivos CSV, consolida os resultados e cria um ranking dos TOP sets.

Em seguida, o sistema compara o melhor resultado com o baseline, avalia o risco estatístico e toma uma das seguintes decisões:

• aceitar automaticamente o set recomendado;
• manter o baseline atual;
• pedir ao trader uma escolha manual;
• ignorar o grupo de parâmetros;
• salvar o progresso e continuar depois.

O trader mantém o controle, mas não precisa mais analisar manualmente cada tabela.

O que o trader recebe no final

Ao concluir o processo, o sistema gera um conjunto completo de resultados:

• arquivo .set final para carregar no MetaTrader 5;
• arquivos CSV com os resultados da otimização;
• relatórios por grupos de parâmetros;
• estatísticas por ativo;
• manifests.json com o histórico das execuções;
• current_defaults.json com as configurações atualmente aceitas;
• registro das decisões tomadas em cada etapa.

Isso permite não apenas obter o set final, mas também entender exatamente como ele foi escolhido.

Ideia principal

O sistema não busca apenas a combinação de parâmetros “mais lucrativa”.

Ele ajuda a selecionar configurações mais robustas, considerando vários fatores:

• rentabilidade;
• drawdown;
• número de trades;
• estabilidade do resultado;
• qualidade do score;
• diferença em relação ao baseline;
• risco de sobreotimização.

O objetivo não é encontrar o resultado mais bonito no histórico, mas escolher um set que pareça razoável do ponto de vista estatístico e de gestão de risco.

Preparação do EA no MQL5

Para funcionar com a automação, o EA precisa estar preparado para trocar informações com o Python. A automação não substitui o Strategy Tester do MetaTrader 5, ela apenas organiza a execução, gera arquivos .set e .ini, chama o terminal, lê os resultados exportados e decide quais parâmetros avançam para a próxima etapa.

Do lado do MQL5, o EA precisa cumprir três funções principais:

1.  Expor inputs de controle que o Python consiga alterar.
2.  Calcular um score no OnTester().
3.  Exportar os resultados de cada passe de otimização para CSV.

O MetaTrader 5 já permite otimizar variáveis declaradas como input. Por isso, o Python trabalha alterando esses inputs nos arquivos .set gerados automaticamente. O EA, por sua vez, calcula as métricas no OnTester() e exporta os resultados para que o Python possa consolidar, comparar e escolher os melhores conjuntos.

Inputs obrigatórios

Todo EA integrado ao otimizador deve conter estes inputs mínimos:

// Tag automatically changed by Python.
// Identifies the run, subgroup and symbol.
input string optimizationTag = "manual";

// Enables or disables CSV export for optimization passes.
input bool saveOptimizationPasses = true;

// Used by Python to run the baseline as a real single-pass optimization.
input int dummyOptimizationPass = 0;

// Prefix of the exported CSV file.
// Generated file: csvExportPrefix + "_" + optimizationTag + "_frames.csv"
input string csvExportPrefix = "MyEA";

A função de cada input é:

• optimizationTag — identifica a rodada executada pelo Python. Exemplo: BASE_G1B_EMAS_WIN$N ou MSG_G1B_EMAS_WIN$N.
• saveOptimizationPasses — liga ou desliga a exportação dos resultados.
• dummyOptimizationPass — permite que o Python rode o baseline como uma otimização de um único passe.
• csvExportPrefix — define o início do nome do CSV exportado pelo EA.

O nome final do arquivo segue este padrão:

csvExportPrefix + "_" + optimizationTag + "_frames.csv"

Exemplo: MyEA_MSG_G1B_EMAS_WIN$N_frames.csv

Exportação por Frames do MetaTrader 5

O modelo recomendado de exportação usa os próprios frames de otimização do MetaTrader 5. Nesse formato, o EA não precisa listar manualmente todos os parâmetros no CSV.

A lógica é:

1. OnTester() calcula as métricas do passe.
2. O EA salva essas métricas com FrameAdd().
3. OnTesterPass() e OnTesterDeinit() processam os frames.
4. FrameInputs() recupera automaticamente os inputs usados no passe.
5. O EA grava um CSV com métricas + parâmetros do passe.

Essa abordagem evita manutenção manual da função de exportação. Se um novo input for otimizado pelo Python, ele aparece automaticamente no CSV, desde que faça parte do passe executado pelo Strategy Tester.

Variáveis obrigatórias da exportação

const long OPT_FRAME_ID = 1003;
int  frameCsvHandle = INVALID_HANDLE;
bool frameCsvHeaderWritten = false;

Salvar métricas do passe

O OnTester() chama esta função ao final de cada passe. Ela empacota as principais métricas em um array e envia para o sistema de frames do MetaTrader 5.

//+------------------------------------------------------------------+
//| Saves optimization pass metrics into an MT5 optimization frame   |
//+------------------------------------------------------------------+
void SaveOptimizationPass(const double score,
                          const double profit,
                          const double trades,
                          const double pf,
                          const double ddRel,
                          const double payoff,
                          const double recovery,
                          const double sharpe)
  {
   if(!saveOptimizationPasses)
      return;

   double data[8];
   data[0] = score;
   data[1] = profit;
   data[2] = trades;
   data[3] = pf;
   data[4] = ddRel;
   data[5] = payoff;
   data[6] = recovery;
   data[7] = sharpe;

   FrameAdd(optimizationTag, OPT_FRAME_ID, score, data);
  }

Separar nome e valor dos parâmetros

O FrameInputs() retorna os parâmetros no formato parâmetro = valor. As funções abaixo separam o nome da coluna e o valor que será gravado no CSV.

//+------------------------------------------------------------------+
//| Returns the parameter name from a FrameInputs entry              |
//+------------------------------------------------------------------+
string FrameParameterName(const string parameter)
  {
   int pos = StringFind(parameter, "=");

   if(pos < 0)
      return parameter;

   return StringSubstr(parameter, 0, pos);
  }

//+------------------------------------------------------------------+
//| Returns the parameter value from a FrameInputs entry             |
//+------------------------------------------------------------------+
string FrameParameterValue(const string parameter)
  {
   int pos = StringFind(parameter, "=");

   if(pos < 0)
      return parameter;

   return StringSubstr(parameter, pos + 1);
  }

Abrir o CSV

//+------------------------------------------------------------------+
//| Opens the CSV file used to export optimization frames            |
//+------------------------------------------------------------------+
bool OpenFramesCsv()
  {
   if(frameCsvHandle != INVALID_HANDLE)
      return true;

   string csvPrefix = csvExportPrefix;

   if(csvPrefix == "")
      csvPrefix = MQLInfoString(MQL_PROGRAM_NAME);

   string fileName = csvPrefix + "_" + optimizationTag + "_frames.csv";

   frameCsvHandle = FileOpen(fileName,
                             FILE_WRITE | FILE_CSV | FILE_ANSI | FILE_SHARE_READ,
                             ';');

   if(frameCsvHandle == INVALID_HANDLE)
     {
      Print("Error opening optimization CSV: ", fileName, " error=", GetLastError());
      return false;
     }

   frameCsvHeaderWritten = false;
   return true;
  }

Processar frames e gerar CSV

Esta função percorre os frames salvos pelo OnTester(), escreve o cabeçalho do CSV e adiciona automaticamente os parâmetros usados em cada passe.

//+------------------------------------------------------------------+
//| Processes MT5 optimization frames and writes them to the CSV file|
//+------------------------------------------------------------------+
void ProcessOptimizationFrames()
  {
   if(!saveOptimizationPasses || !OpenFramesCsv())
      return;

   ulong pass = 0;
   string name = "";
   long frameId = 0;
   double value = 0.0;
   double data[];

   ResetLastError();

   while(FrameNext(pass, name, frameId, value, data))
     {
      if(frameId != OPT_FRAME_ID)
         continue;

      string parameters[];
      uint count = 0;

      if(!FrameInputs(pass, parameters, count))
         continue;

      if(!frameCsvHeaderWritten)
        {
         string header = "tag;pass;score;profit;trades;pf;ddRel;payoff;recovery;sharpe";

         for(uint i = 0; i < count; i++)
            header += ";" + FrameParameterName(parameters[i]);

         FileWriteString(frameCsvHandle, header + "\r\n");
         frameCsvHeaderWritten = true;
        }

      string line = name + ";" + IntegerToString((long)pass);

      for(int i = 0; i < 8; i++)
        {
         double v = (ArraySize(data) > i ? data[i] : 0.0);
         int digits = (i == 1 || i == 2 ? 2 : 8);
         line += ";" + DoubleToString(v, digits);
        }

      for(uint i = 0; i < count; i++)
         line += ";" + FrameParameterValue(parameters[i]);

      FileWriteString(frameCsvHandle, line + "\r\n");
     }

   FileFlush(frameCsvHandle);
  }

Eventos do testador

Esses eventos fazem a ponte entre o Strategy Tester e a exportação dos frames.

//+------------------------------------------------------------------+
//| Initializes the optimization frame CSV export                    |
//+------------------------------------------------------------------+
int OnTesterInit()
  {
   if(saveOptimizationPasses)
      OpenFramesCsv();

   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Processes each optimization pass frame                           |
//+------------------------------------------------------------------+
void OnTesterPass()
  {
   ProcessOptimizationFrames();
  }

//+------------------------------------------------------------------+
//| Finalizes optimization frame processing and closes the CSV file  |
//+------------------------------------------------------------------+
void OnTesterDeinit()
  {
   ProcessOptimizationFrames();

   if(frameCsvHandle != INVALID_HANDLE)
     {
      FileClose(frameCsvHandle);
      frameCsvHandle = INVALID_HANDLE;
     }
  }

OnTester() base

O OnTester() é executado pelo Strategy Tester ao final de cada passe de otimização. Ele coleta as estatísticas, calcula um score e salva os dados do passe.

//+------------------------------------------------------------------+
//| Calculates the custom optimization score and saves pass metrics  |
//+------------------------------------------------------------------+
double OnTester()
  {
   double profit   = TesterStatistics(STAT_PROFIT);
   double trades   = TesterStatistics(STAT_TRADES);
   double pf       = TesterStatistics(STAT_PROFIT_FACTOR);
   double ddRel    = TesterStatistics(STAT_EQUITY_DDREL_PERCENT);
   double recovery = TesterStatistics(STAT_RECOVERY_FACTOR);
   double payoff   = TesterStatistics(STAT_EXPECTED_PAYOFF);
   double sharpe   = TesterStatistics(STAT_SHARPE_RATIO);

   if(profit <= 0.0 || trades < 30 || pf <= 1.0)
     {
      SaveOptimizationPass(0.0, profit, trades, pf, ddRel, payoff, recovery, sharpe);
      return 0.0;
     }

   double tradeScore = MathMin(1.0, trades / 300.0);
   tradeScore = tradeScore * tradeScore;

   double pfScore       = MathMin(pf, 2.0) / 2.0;
   double recoveryScore = MathMax(0.0, MathMin(recovery, 8.0)) / 8.0;
   double sharpeScore   = MathMax(0.0, MathMin(sharpe, 4.0)) / 4.0;
   double ddPenalty     = 1.0 / (1.0 + MathPow(ddRel / 15.0, 2.0));

   double score = profit *
                  pfScore *
                  tradeScore *
                  (0.50 + 0.50 * recoveryScore) *
                  (0.70 + 0.30 * sharpeScore) *
                  ddPenalty;

   SaveOptimizationPass(score, profit, trades, pf, ddRel, payoff, recovery, sharpe);

   return score;
  }

Resumo da preparação

Para o EA funcionar com o Python, ele precisa ter:

1. Inputs obrigatórios de controle.
2. Prefixo do CSV em csvExportPrefix.
3. Rotina de exportação por frames.
4. Eventos OnTesterInit(), OnTesterPass() e OnTesterDeinit().
5. OnTester() calculando score e chamando SaveOptimizationPass().

Com essa estrutura, o Python consegue executar o MetaTrader 5, localizar o CSV correto, consolidar os passes, comparar os melhores sets e atualizar os parâmetros ao longo da automação. O EA não precisa listar manualmente todos os inputs no CSV, porque FrameInputs() recupera automaticamente os parâmetros usados em cada passe de otimização.

Configuração automática por comentários @group, @subgroup, @opt e @fixed

Para reduzir a configuração manual, o MetaTrader 5 Global Optimizer pode ler o próprio código .mq5 do EA. Para isso, o robô usa comentários padronizados acima dos inputs. Esses comentários não alteram a compilação nem o funcionamento do EA. Eles servem apenas como metadados para o Python montar automaticamente os grupos, subgrupos, ranges e parâmetros fixos.

A estrutura recomendada é a seguinte: neste exemplo, o Python entende que os parâmetros pertencem ao grupo G1_REGIME e ao subgrupo G1B_EMAS. Cada linha @opt informa o range de otimização do input logo abaixo.

A estrutura do @opt é:

//==================================================================
// @group G1_REGIME
// @subgroup G1B_EMAS
//==================================================================

// @opt 10 2 40
input int fastEMAPeriod = 24;

// @opt 20 5 120
input int slowEMAPeriod = 70;

// @opt 1.4 0.2 2.2
input double minEMARatio = 1.4;

// @fixed
input ENUM_TIMEFRAMES regimeTimeframe = PERIOD_M5;

Nesse exemplo, o Python entende que os inputs pertencem ao grupo G1_REGIME e ao subgrupo G1B_EMAS.

O comentário @opt segue o formato:

// @opt start step stop

Exemplo:

// @opt 10 2 40
input int fastEMAPeriod = 24;

Interpretação:

• Parâmetro: fastEMAPeriod
• Default: 24
• Range: 10 a 40
• Passo: 2

Para parâmetros booleanos, pode-se usar:

// @opt false true
input bool useBreakEven = true;

Nesse caso, o Python testa o parâmetro desligado e ligado.

Já o @fixed indica que o input deve entrar no .set, mas sem ser otimizado:

// @fixed
input bool useDayTradeHours = true;

Assim, cada subgrupo pode ter seus próprios parâmetros otimizáveis e também seus valores fixos.

Na prática, a lógica fica assim:

• @group → define o bloco principal da estratégia
• @subgroup → define a etapa de otimização
• @opt → define o range do input abaixo
• @fixed → mantém o input abaixo como valor fixo

Antes de rodar a automação completa, é recomendável validar a leitura automática com: python mt5_global_optimizer.py --parse-mq5 "C:\path\to\YourEA.mq5".

O comando deve mostrar os inputs, defaults, grupos, subgrupos, ranges e parâmetros fixos encontrados.

Limite importante: O Python não consegue ler comentários de um arquivo .ex5 compilado. Para essa configuração automática funcionar, ele precisa acessar o .mq5, um .mqh incluído ou um arquivo auxiliar de metadados. O .set base ajuda a importar defaults, mas não informa a estrutura de grupos e subgrupos.

Passo a passo de uso no Windows

Antes de executar a automação, é importante entender que o programa é um arquivo .py. Portanto, ele precisa ser executado pelo Python instalado no Windows. Em muitos computadores, o comando py não funciona, então, neste artigo, usaremos o comando:

python

Se o comando python também não for reconhecido, significa que o Python não está instalado corretamente ou não foi adicionado ao PATH do Windows.

Instalar o Python e preparar os arquivos

Antes de executar o MetaTrader 5 Global Optimizer, é necessário preparar o Python, a pasta de trabalho da automação e o Expert Advisor que será otimizado.

Baixe e instale o Python pelo site oficial: https://www.python.org/downloads/windows/

Também é possível consultar o tutorial oficial de instalação no Windows em: https://docs.python.org/3/using/windows.html

Durante a instalação, marque a opção:

Add python.exe to PATH

Essa opção é importante porque permite executar o Python diretamente pelo PowerShell usando o comando python.

Acesse pelo PowerShell a pasta onde está o arquivo da automação e verifique se ele aparece no diretório:

cd C:\MT5_Global_Optimizer
dir

Após o comando, o arquivo mt5_global_optimizer.py terá que ser exibido.

Abrir o PowerShell na pasta correta

Antes de rodar qualquer comando, entre na pasta onde está o arquivo Python.

Exemplo:

cd "C:\MT5_Global_Optimizer"

Depois confirme se o arquivo está ali:

dir

Você deve ver algo parecido com:

mt5_global_optimizer.py

Se você tentar rodar o comando fora da pasta correta, o PowerShell pode retornar erro dizendo que não encontrou o arquivo.

Testar a leitura automática do EA

Antes de criar o config.json, teste se o Python consegue ler corretamente os grupos, subgrupos, ranges e defaults do EA.

Use:

python mt5_global_optimizer.py --parse-mq5 "C:\path\to\MyEA.mq5"

Esse comando imprime um JSON contendo:

• base
• subgroups
• ranges
• fixed
• defaults

Se algum grupo ou input não aparecer, verifique:

1. Se o caminho do .mq5 está correto.
2. Se o comentário @opt está acima do input.
3. Se o @group e @subgroup foram declarados antes dos inputs.
4. Se o input não está comentado.
5. 5. Se o EA salvo é o mesmo que você está abrindo/lendo.

Criando o arquivo de configuração com o wizard

Depois da conferência do .mq5, crie o arquivo de configuração com:

python mt5_global_optimizer.py --wizard

O wizard fará perguntas sobre o terminal do Meta Trader 5, o Data Path, o Expert Advisor, os ativos, o período do teste, o timeframe, o modelo do Strategy Tester e o modo de seleção dos melhores conjuntos de parâmetros.

Um exemplo completo das perguntas do wizard foi deixado no arquivo anexo: Exemplo_Wizard.txt.

Esse anexo mostra o significado de cada campo e exemplos de preenchimento.

Ao final do processo, o wizard gera um arquivo .json com toda a configuração do estudo. Depois que esse arquivo é criado, o usuário pode repetir a execução sem responder ao wizard novamente.

Rodando a otimização completa

Com a configuração pronta, execute:

python mt5_global_optimizer.py --config config_MyEA_global.json --stage all

Esse comando executa a bateria completa.

O script irá:

• criar arquivos .set;
• criar arquivos .ini;
• abrir o MetaTrader 5;
• rodar o Strategy Tester;
• ler os resultados exportados pelo EA;
• atualizar os melhores defaults;
• gerar relatórios.

Rodando apenas partes da bateria

Para rodar somente a etapa principal:

python mt5_global_optimizer.py --config config_MyEA_global.json --stage main

Para rodar somente o refinamento:

python mt5_global_optimizer.py --config config_MyEA_global.json --stage rewind

Para parar após um subgrupo específico:

python mt5_global_optimizer.py --config config_MyEA_global.json --stage main --stop-after NAME_OF_SUBGROUP

Para começar a partir de um subgrupo específico:

Arquivos gerados

Durante a execução, o Expert Advisor exporta os resultados da otimização em arquivos CSV.

O padrão esperado para o nome do arquivo é:

PREFIX_OF_EA_<optimizationTag>_frames.csv

Exemplo:

MyEA_MSG_G1B_EMAS_WIN$N_frames.csv

Esses arquivos CSV são usados pelo otimizador em Python para ler os passes da otimização, comparar os conjuntos de parâmetros, montar os relatórios e selecionar os melhores clusters.

Ao final do processo, são normalmente gerados os seguintes arquivos:

current_defaults.json
manifest.json
GLOBAL_OPTIMIZER_REPORT.md

Também pode ser criado um arquivo .set final para uso no Strategy Tester.

Resumo do fluxo

O processo completo é:

cd "C:\PATH_TO_YOUR_TERMINAL\MQL5\Experts\MT5_Global_Optimizer"
python mt5_global_optimizer.py --parse-mq5 "C:\CAMINHO_DO_SEU_TERMINAL\MQL5\Experts\MeuEA.mq5"
python mt5_global_optimizer.py --wizard
python mt5_global_optimizer.py --config config_MyEA_global.json --stage all

Em resumo: o arquivo .mq5 define o que será otimizado, o wizard cria a configuração, e o Python automatiza o MetaTrader 5 para executar os testes.

Escolha assistida dos melhores sets

A automação permite que o usuário participe da decisão de quais sets devem seguir para o próximo subgrupo. Isso evita aceitar automaticamente um conjunto frágil apenas porque ele ficou em primeiro lugar no score.

Modo auto. No modo auto, o programa aplica o recomendado sem perguntar. É adequado para rodadas exploratórias longas ou quando o usuário quer deixar a automação rodando sem intervenção.

Modo manual. No modo manual, o programa sempre mostra a tabela de TOP sets e pergunta o que fazer. É o melhor modo para estudar um EA novo, validar uma estratégia ou criar material para artigo.

Modo semi auto. No modo semi auto, o programa só pergunta quando detecta risco estatístico ou decisão sensível. Esse é o modo recomendado para pesquisa séria, porque combina automação com controle humano.

O programa pausa quando encontra sinais como: concentração alta no melhor ativo, PF mediano baixo, drawdown alto, poucos trades, nem todos os ativos positivos, TOP 1 muito próximo do TOP 2 ou parâmetros sensíveis no TOP 20.

As opções de decisão são:

• A = accept recommended - aceita o conjunto recomendado pelo otimizador
• B = keep baseline - mantém os parâmetros atuais, sem aplicar o resultado otimizado
• 1-20 = apply selected TOP set - aplica manualmente um dos TOP sets exibidos na tabela
• P = skip subgroup without changes - pula o subgrupo sem alterar os parâmetros atuais
• S = save and exit - salva o estado atual e encerra a execução
• R = mark for manual boundary reprocessing later - marca o subgrupo para reprocessamento manual de extremos posteriormente

Quando o usuário escolhe um rank específico, o Python aplica os parâmetros daquele TOP ao current_defaults.json e registra a decisão no manifest.json com selected_rank.

Boas práticas e limitações

1. Comece com poucos grupos e poucos ativos para validar se a exportação CSV está correta.
2. Use o modo manual nas primeiras execuções para entender como o score global se comporta.
3. Não aceite TOP 1 automaticamente se ele tiver poucos trades, muita concentração ou drawdown maior.
4. Use o .set final como ponto de partida para walk-forward, não como prova definitiva.
5. Mantenha os ranges coerentes com a lógica da estratégia; ranges absurdos aumentam o overfitting.
6. Rode testes OOS depois da otimização.
7. Para M1/M5, valide com custos, spread e slippage realistas.
8. Documente cada alteração no EA antes de comparar resultados.

Conclusão

A automação global transforma o processo de otimização em uma esteira auditável. O usuário deixa de editar o Python para cada EA e passa a configurar o ambiente pelo Windows, via wizard ou JSON. A estrutura por grupos reduz a complexidade, o baseline impede que cada etapa deteriore a anterior, o score global combate concentração em um único ativo, o rewind refina os valores aceitos e o reprocessamento de extremos evita ranges artificiais.

O ponto mais importante para o sucesso é a preparação do EA: exportação correta dos passes, métricas confiáveis e nomes de parâmetros consistentes. Com isso validado, o script se torna um motor reutilizável para artigos, testes sistemáticos e construção de portfólio de Expert Advisors.

Além disso, o código Python está aberto a alterações, adaptações e novas implementações, conforme a necessidade de cada usuário ou estratégia. Isso permite que a ferramenta evolua continuamente: novos critérios de score, diferentes modos de seleção, validações adicionais, novos relatórios, integração com walk-forward, filtros estatísticos e rotinas específicas podem ser incorporados em versões futuras. Dessa forma, o MetaTrader 5 Global Optimizer não deve ser visto como um sistema fechado, mas como uma base profissional para experimentação, melhoria contínua e expansão metodológica no desenvolvimento de EAs.

Referências técnicas

• MQL5 Documentation - Input Variables: https://www.mql5.com/en/docs/basis/variables/inputvariables
• MQL5 Documentation - OnTester: https://www.mql5.com/en/docs/event_handlers/ontester
• MQL5 Documentation - OnTesterPass: https://www.mql5.com/en/docs/event_handlers/ontesterpass
• MQL5 Documentation - Working with Optimization Results: https://www.mql5.com/en/docs/optimization_frames
• MetaTrader 5 Help - Strategy Optimization: https://www.metatrader5.com/en/terminal/help/algotrading/strategy_optimization

№	Nome	Tipo	Descrição
1	mt5_global_optimizer.py	Script Python	Programa feito em python para gerenciar a bateria de otimizações
2	EA_Template_GlobalOptimizer.mq5	Expert Advisor	EA de base mostrando o básico necessário
3	Exemplo_Wizard.txt	Arquivo txt	Exemplo modelo para preenchimento do Wizard no PowerShell