Otimização automatizada de um robô de negociação no trading real
2 622
0
Introdução
Supõe-se que um Expert Advisor com entradas ajustadas de acordo com o histórico vai negociar e lucrar pela primeira (e curta) vez. Confirmações indiretas desta proposta apareceram depois que eu tinha visto o Campeonato de trading automatizado de 2006. Quando o campeonato começou, haviam Expert Advisors muito mais rentáveis do que mais tarde, quando alguns deles deixaram de ser competitivos. Por isso, suponho que a maioria daqueles Expert Advisors que não foram terminados foram ajustados no histórico.
A ideia para verificar essa suposição na prática, nasceu no fórum russo deste site, na seção do Sistema automatizado de trading ideal. A ideia principal é começar a otimização de um EA automaticamente uma vez por dia e, em seguida, analisar os resultados obtidos com a otimização e gravá-los em variáveis do EA.Para implementar esta ideia, decidimos levar o Expert Advisor recém feito, amostra MACD, do Terminal de Cliente MetaTrader 4 e inserir a nossa própria função de otimização automática para ele. Um pouco mais tarde, o código do otimizador automatizado estava pronto e carregado no mesmo fórum, na seção do Otimizador Automatizado. Depois de mais algum tempo, as primeiras confirmações da ideia apareceram no ramo do Otimizador Automatizado. Mais tarde, para uma melhor usabilidade, o otimizador foi transformado em uma biblioteca mqh.
Instalação do Otimizador Automatizado
Abaixo está o que deve ser feito para executar essa tarefa:
- copie MACD Sample_1.mq4 para a pasta 'expert' do Terminal do cliente MetaTrader 4 preliminarmente instalado e conectado à Internet; e
- copie a pasta em conjunto com o Terminal do cliente MetaTrader 4 instalado em um novo local.
Para uma melhor usabilidade, iremos nomear o terminal original "Terminal", e a cópia será chamada "Verificador-Terminal". Iremos realizar um teste de verificação de EURUSD no calendário H1 utilizando o Expert Advisor fornecido pelo terminal, mas ligeiramente alterado - MACD Sample_1.mq4.
Configuração do Verificador-Terminal
Por favor, não esqueça de compilar MACD Sample_1.mq4 no Verificador-Terminal. Vamos iniciar primeiramente o terminal do cliente, depois o strategy testes, e configurar como mostrado na imagem abaixo.
A otimização será realizada durante três dias. Isto é suficiente para verificar o otimizador automático. Vamos selecionar a data de otimização "De" de acordo com a seguinte fórmula - a data atual menos três dias. Durante a otimização, o histórico necessário para o símbolo selecionado (no nosso caso, é EURUSD) deve ser baixado.
Aqueles que executarem a otimização pela primeira vez podem encontrar a descrição dos procedimentos necessários no menu de ajuda do terminal do cliente MetaTrader 4: . Ou podem ler o artigo nomeado Teste do Expert Advisor no Terminal Do Cliente MetaTrader 4: Um olhar de fora.
Então, vamos verificar as variáveis a serem otimizadas, como mostrado na imagem abaixo.
A otimização automatizada é limitada a quatro variáveis, mas parar os nossos propósitos para economizar tempo, apenas três são suficientes. Após a seleção das variáveis, vamos armazenar as configurações de otimização no set-file nomeado MACD Sample_1.set. Este arquivo deve ser salvo na pasta 'verificador' do Verificador-Terminal. Depois, lance a pré-otimização e memorize a hora de início. Isto é necessário para calcular o período de tempo preciso para a otimização automatizada com os parâmetros predefinidos. Após a otimização estiver concluída, vamos calcular o tempo de espera necessário. Então teremos que fechar este terminal, pois caso contrário, não seremos capazes de iniciá-lo por meio de programação.
Configuração do Expert Advisor localizado no Terminal
Para isto, vamos abrir o Expert Advisor MACD Sample_1.mq4 de teste no MetaEditor e fazer o seguinte:
- Defina a hora de início para a otimização automatizada, por exemplo, às 00:01 todos os dias:
datetime SetHour = 0; // Optimization starting hour; datetime SetMinute = 1; // Optimization starting minute.
- Defina a quantidade de dias para otimização (que deve ser a mesma que para a pré-otimização):
int TestDay = 3;
- Defina o tempo final de espera da otimização em minutos calculados anteriormente, por exemplo, 4 minutos:
int TimeOut = 4;
- Digite o nome do Expert Advisor:
string NameMTS = "MACD Sample_1"; // EA's name
- Digite o nome do conjunto de arquivos com as configurações:
// Set-file name with the settings string NameFileSet = "MACD Sample_1.set";
- Digite no caminho da pasta que contém o Verificador-Terminal, por exemplo:
// Path to the tester string PuthTester = "D:\Program Files\Forex Best Trade Station";
- Defina a prioridade de filtragem:
// Sorting by Maximal profit int Gross_Profit = 1; // Sorting by Maximal profit factor int Profit_Factor = 2; // Sorting by Maximal expected payoff int Expected_Payoff = 3;
- Escreva os nomes das variáveis de otimização:
string Per1 = "FastEMA"; string Per2 = "SlowEMA"; string Per3 = "SignalSMA"; string Per4 = "";
- Cópia em anexo o arquivo auto_optimization.mqh para a pasta 'incluir';
- Inclua o arquivo de biblioteca no Expert Advisor:
//--- Including the auto optimizer's library #include <auto_optimization.mqh>
- Ele apenas continua copiando o código abaixo para o início da função start() do seu Expert Advisor. O MACD Sample_1.mq4 já contém isto.
// Not to be launched at testing and optimizing if(!IsTesting() && !IsOptimization()) { // Compare the current hour with that preset for launching if(TimeHour(TimeLocal()) == SetHour) { // Protection against restarting if(!StartTest) { // Compare the minute range to the minute // preset for launching if(TimeMinute(TimeLocal()) > SetMinute - 1) { // the range is necessary, in case that for some reasons // no new tick is available for a long time if(TimeMinute(TimeLocal()) < SetMinute + 1) { // Flag of tester launching StartTest = true; TimeStart = TimeLocal(); Tester(TestDay, NameMTS, NameFileSet, PuthTester, TimeOut, Gross_Profit, Profit_Factor, Expected_Payoff, Per1, Per2, Per3, Per4); } } } } } FastEMA = GlobalVariableGet(Per1); SlowEMA = GlobalVariableGet(Per2); SignalSMA = GlobalVariableGet(Per3); TrailingStop = GlobalVariableGet(Per4); // If the tester launching is flagged if(StartTest) { // If more time has elapsed the launching than it was set // to be the test waiting time if(TimeLocal() - TimeStart > TimeOut*60) { // Zeroize the flag StartTest = false; } }
Isso é tudo. Após otimizador automatizado for novamente compilado, ele pode ser iniciado, mas ele pode ser utilizado apenas para o mesmo símbolo e calendário para o qual foi realizada a pré-optimização. No nosso caso, é EURUSD no H1. Para verificar o otimizador automatizado, você pode inserir o código fornecido abaixo na função int init(), em seguida, o otimizador automatizado será inicializado no Expert Advisors.
Tester(TestDay,NameMTS,NameFileSet,PuthTester,TimeOut, Gross_Profit,Profit_Factor, Expected_Payoff, Per1,Per2,Per3,Per4);
Funcionamento do Otimizador Automatizado
O otimizador automatizado funciona com base no Verificador-Terminal para otimizar os parâmetros do Expert Advisor anexado ao gráfico no Terminal. Para isso, o programa envia para o Verificador-Terminal um arquivo contendo os parâmetros de otimização (optimized.ini) e lança o Verificador Terminal no modo de otimização. Em seguida, ele copia os resultados obtidos do "FileReport........htm" de volta para o Terminal e filtra os melhores valores a partir dos resultados obtidos.
Mais detalhes sobre o funcionamento do Otimizador Automatizado
No presente momento, por exemplo, em 00.01, o otimizador automatizado deve ser lançado. As variáveis devem ser preenchidas com valores.
// Path to the terminal string PuthTerminal = TerminalPath() + "\experts\files"; // Name of the ini file for the tester string FileOptim = "optimise.ini"; string FileOptim1 = "\optimise.ini"; // Calculation of the starting date datetime DayStart = TimeLocal()-86400*TestDay; // Optimization starting date string DateStart = TimeToStr(DayStart,TIME_DATE); // Optimization ending date string DateStop = TimeToStr(TimeLocal(),TIME_DATE); // Tester report file name string FileReport = "FileReport_" + Symbol() + "_" + DateStop + ".htm"; string FileReport1 = "\FileReport_" + Symbol() + "_" + DateStop + ".htm"; // Limitation for the minimum amount of trades per day double MinTr = TestDay - 2; // Limitation for maximal amount of trades per day double MaxTr = (60 / Period()*TestDay) + 2; // The amount of attempts to copy the report file int KvoPptk = 10; // The amount of lines for sorting int StepRes = 12;
Em seguida, os parâmetros do arquivo ini são escritas no conjunto da matriz:
// Prepare the ini file for optimization ArrayOpttim[0] = ";optimise strategy tester"; // Enable/Disable Expert Advisors ArrayOpttim[1] = "ExpertsEnable = false"; // Name of the EA file ArrayOpttim[2] = "TestExpert=" + NameMTS; // Name of the file containing parameters ArrayOpttim[3] = "TestExpertParameters=" + NameFileSet; // Symbol ArrayOpttim[4] = "TestSymbol=" + Symbol(); // Timeframe ArrayOpttim[5] = "TestPeriod=" + Period(); // Modeling mode ArrayOpttim[6] = "TestModel=" + 0; // Recalculate ArrayOpttim[7] = "TestRecalculate=false"; // Optimization ArrayOpttim[8] = "TestOptimization=true"; // Use date ArrayOpttim[9] = "TestDateEnable=true"; // From ArrayOpttim[10] = "TestFromDate=" + DateStart; // To ArrayOpttim[11] = "TestToDate=" + DateStop; // Report file name ArrayOpttim[12] = "TestReport=" + FileReport; // Rewrite the report file ArrayOpttim[13] = "TestReplaceReport=true"; // Shut down the terminal upon completion ArrayOpttim[14] = "TestShutdownTerminal=true";
Os parâmetros de otimização são registrados no arquivo ini da matriz. Você também pode ler sobre como criar um arquivo ini na ajuda do Terminal do Cliente MetaTrader 4, consulte.
// Write data into the ini file // Find out about the array size OptimArraySize = ArraySize(ArrayOpttim); // Open a file to write opttim = FileOpen(FileOptim, FILE_CSV|FILE_WRITE, 0x7F); if(opttim > 0) { for(int i = 0; i < OptimArraySize; i++) { // from the array into the variable ini = ArrayOpttim[i]; // from the variable into the file FileWrite(opttim, ini); } // close the file FileClose(opttim); } else { Print("Failed writing data into the ini file. Error No ", GetLastError()); return(0); }
Depois que os parâmetros foram registrados no arquivo ini, o shell32.dll incluído na entrega do Windows padrão é conectado e a função ShellExecuteA é lançada.
#import "shell32.dll" //Connect a dll (provided with Windows) int ShellExecuteA(int hwnd,string Operation,string File,string Parameters,string Directory,int ShowCmd); #import
O arquivo que contém os parâmetros vai ser enviada para o pasta do Verificador do terminal.
// copy the ini file into the tester folder copyini = ShellExecuteA(0,"Open","xcopy", "\"" + PuthTerminal + FileOptim1 + "\" \"" + PuthTester + "\" /y", "", 3); // wait until the file is copied Sleep(1200); if(copyini < 0) { Print("Failed copying ini file"); return(0); }
Em seguida, o verificador é lançado e começa a otimizar as variáveis pré-definidas. O Expert Advisor está no estado interrompido durante a otimização.
// Start Tester start = ShellExecuteA(0, "Open", "terminal.exe", FileOptim, PuthTester, 3); if(start < 0) { Print("Failed starting Tester"); return(0); } Comment("Wait until optimization is complete"); // wait until optimization is complete Sleep(60000*TimeOut);
Após a otimização ser concluída, o verificador irá gravar automaticamente os resultados no arquivo de relatório. Esse arquivo é copiado para a pasta que contém o terminal.
for(Pptk = 0; Pptk < KvoPptk; Pptk++) { //Start a cycle attempting to compy the resport file Comment("Attempt # " + Pptk + " to copy the report file"); ShellExecuteA(0, "Open", "xcopy", "\"" + PuthTester + FileReport1 + "\" \"" + PuthTerminal + "\" /y", "", 3); // wait until the file is copied Sleep(1200); // Try to open the report file file = FileOpen(FileReport, FILE_READ, 0x7F); if(file < 0) { // if it fails to open, wait some more and try again Sleep(60000); } else break; } if(file < 0) { Print("Failed copying the report file"); return(0); }
Em seguida, os dados do arquivo de relatório serão colocados na matriz de cordas para continuar o processamento.
// Read from file into the array // Cycle, until the file ends while(FileIsEnding(file) == false) { // Read a string from the report file FileLine = FileReadString(file); // Find the necessary string and set the reference point there index = StringFind(FileLine, "title", 20); if(index > 0) { // Increase the array in size ArrayResize(ArrayStrg, NumStr + 1); // Record the strings from the file in the array ArrayStrg[NumStr] = FileLine; NumStr++; } } // Close the file FileClose(file); // Delete the file in order not to produce too many copies FileDelete(FileReport); // Set the array size by the amount of data read from the file ArrayResize(ArrayData, NumStr); strings .
Em seguida, os valores necessários são selecionados na matriz.
for(text = 0; text < NumStr; text++) { select = ArrayStrg[text]; //------------------------------------------------------------------------- // Reporting text processing (These are apples and oranges) | //------------------------------------------------------------------------- // Position Pass ClStep=StringFind(select, "; \">",20)+4; // Find the end of position ClStepRazm = StringFind(select, "td>", ClStep); // Read the value CycleStep = StringSubstr(select, ClStep, ClStepRazm - ClStep); // Position Profit // Find the beginning of the position GrProf = StringFind(select, "", ClStepRazm); // Find the end of position GrProfRazm = StringFind(select, "td>", GrProf); // Read value GrossProfit = StringSubstr(select, GrProf+4, GrProfRazm - (GrProf + 4)); // Position Total Trades // Find the beginning of position TotTrad = StringFind(select, "", GrProfRazm); // Find the end of position TotTradRazm = StringFind(select, "td>", TotTrad); // Read the value TotalTrades = StringSubstr(select, TotTrad+4, TotTradRazm - (TotTrad + 4)); // Position Profitability // Find the beginning of position ProfFact = StringFind(select, "", TotTradRazm); // Find the end of position ProfFactRazm = StringFind(select, "td>", ProfFact); // Read the value ProfitFactor = StringSubstr(select, ProfFact + 4, ProfFactRazm - (ProfFact + 4)); // Position Expected Payoff // Find the beginning of position ExpPay = StringFind(select, "", ProfFactRazm); // Find the dn of position ExpPayRazm=StringFind(select, "td>", ExpPay); // Read the value ExpectedPayoff = StringSubstr(select, ExpPay+4, ExpPayRazm - (ExpPay + 4)); // Variables' positions starting with the second one // Find the beginning of position P1 = StringFind(select, Per1, 20); // Find the end of position P1k = StringFind(select, ";", P1); // Read the Variable Perem1 = StringSubstr(select, P1 + StringLen(Per1) + 1, P1k - (P1 + 1 + StringLen(Per1))); // Find the beginning of position P2 = StringFind(select, Per2, 20); // Find the end of position P2k = StringFind(select, ";", P2); // Read the Variable Perem2 = StringSubstr(select, P2 + StringLen(Per2) + 1, P2k - (P2 + 1 + StringLen(Per2))); // Find the beginning of position P3 = StringFind(select, Per3, 20); // Find the end of position P3k = StringFind(select, ";", P3); // Read the Variable Perem3 = StringSubstr(select, P3 + StringLen(Per3) + 1, P3k - (P3 + 1 + StringLen(Per3))); // Find the beginning of position P4 = StringFind(select, Per4, 20); // Find the end of position P4k = StringFind(select, ";", P4); // Read the Variable Perem4 = StringSubstr(select, P4 + StringLen(Per4) + 1, P4k - (P4 + 1 + StringLen(Per4))); Comment("The obtained results are being analyzed");
Depois disso, os resultados obtidos, antes de serem transformados em um formato de número, foram filtrados pelo valor mínimo e pelo valor máximo do mercado. Zero é o valor do Profit-Factor substituído por 1000 para classificação correta e peneiração subsequente.
// Transform into number format TotalTradesTransit = StrToDouble(TotalTrades); GrossProfitTransit = StrToDouble(GrossProfit); ExpectedPayoffTran = StrToDouble(ExpectedPayoff); nodubl = true; if(MinTr < TotalTradesTransit && MaxTr > TotalTradesTransit) { // Filter by the amount of trades PrFactDouble = StrToDouble(ProfitFactor); // Replace 0 in the Profit_Factor for proper analysis if(PrFactDouble == 0) { PrFactDouble = 1000; }
Em seguida, os valores são verificados para duplicações e filtrados.
// Filter data having identical values for(Dubl = 0; Dubl <= ResizeArayNew; Dubl++) { // Start the loop searching for identical values if(GrossProfitTransit == ArrayData[Dubl][1]) { // check whether the results for maximal profit coincide if(TotalTradesTransit == ArrayData[Dubl][2]) { // check whether the results for the amount of trades coincide if(PrFactDouble == ArrayData[Dubl][3]) { // check whether the results for Profit Factor coincide if(ExpectedPayoffTran == ArrayData[Dubl][4]) { // check whether the results for expected payoff coincide nodubl=false; // If everything coincides, flag it as coincided } } } } }
Em seguida, os valores preparados para triagem são escritos na matriz.
// Write the filtered data in the array if(nodubl) { ArrayData[text][1] = GrossProfitTransit; ArrayData[text][2] = TotalTradesTransit; ArrayData[text][3] = PrFactDouble; ArrayData[text][4] = ExpectedPayoffTran; ArrayData[text][5] = StrToDouble(Perem1); ArrayData[text][6] = StrToDouble(Perem2); ArrayData[text][7] = StrToDouble(Perem3); ArrayData[text][8] = StrToDouble(Perem4); ResizeArayNew++; }
Em seguida, os dados começam a ser analisados na ordem de prioridade predefinida. A análise é feita da seguinte maneira:
- o loop é lançado e, na primeira passagem, os valores são classificados pelo primeiro parâmetro, por exemplo, o lucro máximo; vários melhores valores são selecionados (12, por padrão), outros são cortados;
- na segunda passagem, os valores são classificados pelo segundo parâmetro, por exemplo, pelo fator lucro; alguns melhores valores são selecionados, metade após a primeira triagem, outros são cortados;
- na terceira passagem, a última triagem é efetuada para o terceiro parâmetro, por exemplo, pelo retorno esperado; metade dos valores são coletados após a segunda triagem, outros são cortados.
// Analyzer // Analyzing principle is the sequential checking of maximal // values according to the predefined filtering priority ArrayResize(ArrayTrans, ResizeArayNew - 1); for(int PrioStep = 1; PrioStep < 4; PrioStep++) { for(PrCycle = 0; PrCycle < ResizeArayNew; PrCycle++) { Sort = ArrayData[PrCycle][0]; Prior1 = ArrayData[PrCycle][1]; transit = ArrayData[PrCycle][2]; Prior2 = ArrayData[PrCycle][3]; Prior3 = ArrayData[PrCycle][4]; transit1 = ArrayData[PrCycle][5]; transit2 = ArrayData[PrCycle][6]; transit3 = ArrayData[PrCycle][7]; transit4 = ArrayData[PrCycle][8]; if(PrioStep == 1) { //Prepare for the 1st sorting if(Gross_Profit ==1) { SortTrans = Prior1; } if(Profit_Factor == 1) { SortTrans = Prior2; } if(Expected_Payoff == 1) { SortTrans = Prior3; } } if(PrioStep == 2) { // Restore if(Gross_Profit ==1) { Prior1 = Sort; } if(Profit_Factor == 1) { Prior2 = Sort; } if(Expected_Payoff == 1) { Prior3 = Sort; } //Prepare for the 2nd sorting if(Gross_Profit == 2) { SortTrans = Prior1; } if(Profit_Factor == 2) { SortTrans = Prior2; } if(Expected_Payoff == 2) { SortTrans = Prior3; } } if(PrioStep == 3) { // Restore if(Gross_Profit == 2) { Prior1 = Sort; } if(Profit_Factor == 2) { Prior2 = Sort; } if(Expected_Payoff == 2) { Prior3 = Sort; } //Prepare for the 3rd sorting if(Gross_Profit ==3) { SortTrans = Prior1; } if(Profit_Factor == 3) { SortTrans = Prior2; } if(Expected_Payoff == 3) { SortTrans = Prior3; } } ArrayTrans[PrCycle][0] = SortTrans; ArrayTrans[PrCycle][1] = Prior1; ArrayTrans[PrCycle][2] = transit; ArrayTrans[PrCycle][3] = Prior2; ArrayTrans[PrCycle][4] = Prior3; ArrayTrans[PrCycle][5] = transit1; ArrayTrans[PrCycle][6] = transit2; ArrayTrans[PrCycle][7] = transit3; ArrayTrans[PrCycle][8] = transit4; } ArraySort(ArrayTrans,StepRes, 0, MODE_DESCEND); // Sort the array ArrayResize(ArrayTrans, StepRes); // Cut off the unnecessary things for(int CopyAr = 0; CopyAr < StepRes; CopyAr++) { ArrayData[CopyAr][0] = ArrayTrans[CopyAr][0]; ArrayData[CopyAr][1] = ArrayTrans[CopyAr][1]; ArrayData[CopyAr][2] = ArrayTrans[CopyAr][2]; ArrayData[CopyAr][3] = ArrayTrans[CopyAr][3]; ArrayData[CopyAr][4] = ArrayTrans[CopyAr][4]; // Per1 Variable 1 ArrayData[CopyAr][5] = ArrayTrans[CopyAr][5]; // Per2 Variable 2 ArrayData[CopyAr][6] = ArrayTrans[CopyAr][6]; // Per3 Variable 3 ArrayData[CopyAr][7] = ArrayTrans[CopyAr][7]; // Per4 Variable 4 ArrayData[CopyAr][8] = ArrayTrans[CopyAr][8]; } StepRes = StepRes / 2; }
Os valores filtrados desta forma são escritos em variáveis globais. Os valores das variáveis globais serão substituídos no EA.
Resultados Operacionais com Otimizador Automatizado
// Write the obtained results in variables double Peremen1 = ArrayTrans[0][5]; double Peremen2 = ArrayTrans[0][6]; double Peremen3 = ArrayTrans[0][7]; double Peremen4 = ArrayTrans[0][8]; // If the variable name is specified, write the result in // global variables if(Per1 != "") { GlobalVariableSet(Per1, Peremen1); } if(Per2 != "") { GlobalVariableSet(Per2,Peremen2); } if(Per3 != "") { GlobalVariableSet(Per3,Peremen3); } if(Per4 != "") { GlobalVariableSet(Per4,Peremen4); } Comment(Per1, " ", Peremen1, " | ", Per2, " ", Peremen2, " | ", Per3, " ", Peremen3, " | ", Per4, " ", Peremen4); Print(Per1, " ", Peremen1, " | ", Per2, " ", Peremen2, " | ", Per3, " ", Peremen3," | ",Per4," ",Peremen4); } // Function ends. That's all, automated optimization is complete.
Os resultados operacionais do otimizador automatizado podem ser observados utilizando mensagens que aparecem no canto superior esquerdo do gráfico, como mostrado na imagem abaixo:
Se os resultados da otimização aparecerem na mensagem, isso significa que a otimização está completa e os dados foram recebidos.
Para estimativa de trabalho do otimizador automatizado, pode-se olhar através de todos os arquivos que contenham dados intermediários e foram salvos durante o processo de trabalho. O verificador armazena dados no arquivo "FileReport_EURUSD_2007.03. 12. htm " onde o símbolo e a data são substituídos no nome do arquivo de acordo com o símbolo selecionado e a data atual de otimização. Este arquivo pode ser encontrado na pasta Verificador-Terminal. Estes arquivos com relatórios não são excluídos automaticamente, sendo assim, podemos usá-los para verificar mudanças de parâmetros.
O próximo arquivo, FileTest1.csv, é salvo após os valores serem filtrados pela quantidade de negociações e as cópias forem excluídas. O arquivo é salvo em: D:\Program Files\terminal_folder_ame\experts\files
Em seguida, os valores obtidos após cada etapa de peneiração são salvos no FileTest2.csv. O arquivo também é salvo nesta pasta: D:\Program Files\terminal_folder_name\experts\files
As tabelas acima mostram como os valores obtidos são filtrados. A ordem de filtragem foi definida pelo padrão: 1- Lucro_Bruto, 2- Fator_Lucro, 3- Pagamento_Esperado.
O código do otimizador automatizado contém comentários detalhados e você pode ajustar os parâmetros variáveis mais adequados, se necessário. Por exemplo, se você quiser otimizar o seu EA por um período de tempo que não seja os últimas dias, ou se você estiver planejando aumentar/diminuir a quantidade de negociações no período de otimização. Para isso, você só precisa alterar as variáveis correspondentes diretamente em auto_optimization.mqh.
// Limitation of minimal amount of trades per day double MinTr = TestDay - 2; // Limitation on maximal amount of trades per day double MaxTr = (60 / Period()*TestDay) + 2; // The amount of attempts to copy the report file int KvoPptk = 10; // The amount of strings to be sorted int StepRes = 12;
Conclusão
Este artigo não tem como objetivo ensinar elementos de otimização para novatos, por isso é altamente recomendado aprender a otimização normal antes de configurar a otimização automatizada de seu Expert Advisor. É melhor utilizar o otimizador automático depois de ter escolhido as variáveis básicas que irão influenciar seu Expert Advisor de maneiras diferentes em momentos diferentes. Ou seja, é melhor utilizar este optimizador automatizado para ajustar parâmetros variáveis nos quais as alterações influenciam o funcionamento do EA mais do que aqueles em outras variáveis, dependendo da volatilidade do mercado.
Além disso, é melhor não definir um período extenso de otimização automatizada. Suponha que o Expert Advisor foi otimizado para 6-12 horas todos os dias. Pergunto: Quando ele irá negociar? Em outras palavras, a otimização não é necessária por si só. Recomenda-se definir a periodicidade da otimização (entende-se periodicidade do lançamento do otimizador), considerando o período de tempo, em que o EA, supostamente, deve negociar. Isto significa que é necessário considerar que os dados do histórico serão bombeados quando o Verificador-Terminal for iniciado e é possível que o corretor apenas não possua os dados necessários do histórico para o período de tempo especificado. Para verificar a hipótese descrita no início deste artigo, você vai precisar de 24 horas e de uma conexão de internet estável.
Os programas desenvolvidos de otimização automatizada estão localizados nos arquivos anexados: auto_optimization.mqh - a biblioteca, MACD Sample_1.mq4 - Expert Advisor ligeiramente alterado incluído no Terminal do Cliente MetaTrader 4 no conjunto de fornecimento padrão.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/1467
ZUP - ZigZag universal com padrões Pesavento. Parte 1
Pontos de pivô ajudando a definir tendências de mercado
Indicador Alternativo Ichimoku - Configurações e exemplos de uso
Estratégia de Trading com Base na Análise de Pontos de Pivô
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso