Criando EAs de rede neural usando o assistente do MQL5 e o gerador EA Hlaiman
4 076
0
Introdução
Virtualmente cada negociador sabe sobre a existência de redes neurais. Mas, para a maioria deles, ela continua sendo uma caixa preta, com as únicas coisas conhecidas sendo a capacidade das redes neurais reconhecerem padrões, produzirem pesquisa associativa para soluções e aprendizagem, bem como o fato de que elas podem ser eficazes em prever o comportamento do mercado e em negociação automatizada. Muitas fontes de informação que incidem sobre a aplicação de redes neurais muitas vezes falam sobre sua dificuldade, enfatizando que é preciso dedicar uma grande quantidade de tempo e esforço para aprender bem o assunto e ser capaz de usar redes neurais no futuro.
Este artigo tem como objetivo refutar esses argumentos e provar que os métodos avançados de automação permitem que os negociadores tenham uma introdução fácil às redes neurais e evitem o longo processo de aprendizagem. Não há nada de difícil em obter sua própria experiência com redes neurais. Ela é certamente mais fácil do que a análise técnica.
Com isto em vista, vamos descrever um método de geração automática de EAs de rede neural para MetaTrader 5 usando o assistente do MQL5 e gerador EA Hlaiman.
A escolha das ferramentas para resolver a tarefa em questão está longe de ser aleatória:
- O assistente do MQL5 é um mecanismo eficiente e mais rápido de geração de código MQL5 automático até hoje, o qual permite que você dimensione o código gerado usando módulos adicionais.
- O gerador EA Hlaiman é um motor de rede neural com um mecanismo flexível de integração de objeto, programável diretamente no código do MQL5 de um Expert Advisor.
A abreviação 'EA' foi adicionada ao nome Expert Advisor intencionalmente, como as propriedades humanóides associadas com o reconhecimento e aprendizagem são predominantes em um EA de rede neural, ao contrário de outros casos em que a utilização de 'EA' em um nome é muitas vezes enganosa e faz não refletir a verdadeira natureza das coisas.
Descrição geral
Você não encontrará aqui qualquer informação teórica, classificações e estrutura de redes neurais ou dados de pesquisa relacionados aos mercados financeiros devido à razão descrita no objetivo do artigo. Essa informação está disponível em outras fontes. Neste artigo, nos limitaremos deliberadamente ao conceito de uma rede neural como uma caixa preta capaz de ter um pensamento associativo e prever as entradas de mercado com base no reconhecimento de padrões de preços gráficos. Pela mesma razão, usaremos a noção mais simples do padrão, sendo uma sequência contínua de barras em um gráfico de instrumento de negociação que antecede um movimento de preço rentável.
Algumas palavras sobre as ferramentas de resolução de problemas. Ao contrário de Hlaiman, o assistente do MQL5 tem sido muitas vezes o assunto de vários artigos e documentação, e não precisa de introdução, assim como o MetaTrader 5. O projeto de orientabilidade de Hlaiman é destinado ao desenvolvimento e promoção de software multiuso na forma de plug-ins, com o gerador EA sendo um deles. Como mencionado anteriormente, funcionalmente o gerador EA representa um motor de rede neural com o mecanismo de integração.
Ogerador EA Hlaiman inclui - uma aparência que representa uma aplicação gráfica do Windows com interface de documentos múltiplos e plug-ins, na forma de bibliotecas de componentes carregáveisdinamicamente. O sistema fornece uma ampla gama de métodos de controle de componente e de ajustes manual e algorítmico, que podem ser tanto padrão e carregável como parte de plug-ins. No decorrer da operação do sistema, você pode criar hierarquias complexas de objetos e ter controle flexível sobre seus métodos e propriedades, usando o inspetor de objetos e ferramentas de software de automação, por exemplo, scripts.
A integração do gerador EA Hlaiman com MQL5 envolve o intérprete do script Object Pascal, enquanto o código-fonte é passado via pipes nomeados. Um perceptron de multicamada (MLP) é utilizado como o principal componente de rede neural.
O gerador EA Hlaiman é integrado com o assistente do MQL5 usando um módulo de biblioteca sinal - SignalHNN.mqh. Uma vez gerado automaticamente, o Expert Advisor pode então ser ensinado a negociar em qualquer número de instrumentos e prazos. No terminal МetaТrader 5, as setas indicando sinais podem ser tanto desenhadas no gráfico de preços manualmente, usando os objetos gráficos para flechas, ou automaticamente, usando o script TeachHNN.mq5 que, ao mesmo tempo, inicia o processo de ensinamento do Expert Advisor.
Isto conclui a descrição teórica. Passamos agora para a parte prática, que é dividida em duas seções - Implementação e princípios operacionais.
A segunda seção é destinada a desenvolvedores de software e é fornecida aqui, principalmente em consideração a este site. Por isso, é opcional, especialmente para os negociadores que têm pouco ou nenhum interesse em obter conhecimentos de programação mas estão interessadosem criar EAs de redes neurais e estimar sua eficiência ou inutilidade em termos de negociação.
Princípios operacionais
Em MQL5.community, provavelmente seria desnecessário mencionar que você precisa do terminal MetaТrader 5 a fim de prosseguir. Se você não o têm, faça o download e instale o mesmo. Você também deve fazer o download e instalar uma versão demo do gerador EA Hlaiman.
Execute o terminal МetaТrader 5 e inicie o MetaEditor. Abra o assistente do MQL5. Você pode fazer isso usando a opção "Novo" na barra de ferramentas padrão ou no menu arquivo, bem como usando as teclas de atalho 'Ctrl+N'.
Na janela do assistente do MQL5, selecione '(gerar) Expert Advisor' e clique em 'Próximo'.
Fig. 1. Criando um Expert Advisor no assistente do MQL5
Especifique a localização e o nome do Expert Advisor, por exemplo 'Experts\SampleHNN' e clique em 'Próximo'.
Fig. 2. Propriedades gerais do Expert Advisor
Clique no botão 'Add'. Você verá a janela de "parâmetros do módulo de sinal", onde você precisa selecionar 'sinais do gerador EA da rede neural Hlaiman padrões' a partir da lista suspensa e clicar em 'OK'.
Fig. 3. Selecionando o módulo de sinal de negociação do 'gerador EA da rede neural Hlaiman'
No caso de uma implementação bem básica, você pode clicar em "Próximo" em todas as etapas restantes do assistente do MQL5. Se necessário, o Expert Advisor pode ser aprimorado selecionando opções adicionais.
Após a conclusão da geração de código, clique em "compilar" e feche a janela do MetaEditor. O Expert Advisor gerado aparecerá no painel do navegador do terminal MetaTrader 5 em 'Expert Advisors'.
Fig. 4. O Expert Advisor SampleHNN
Antes de prosseguirmos ensinando o Expert Advisor gerado, precisamos abrir um gráfico com o símbolo e período de tempo exigidos no terminal. O aplicativo do gerador EA Hlaiman deve estar funcionando.
Fig. 5. Preparação de ensino para rede neural
Para ensinar o Expert Advisor, selecione 'TeachHNN' em 'Scripts' no painel do navegador do terminal e ative-o para o gráfico especificado.
Antes de executar o script 'TeachHNN', você deve se certificar de que ele tem todas as configurações adequadas. Ele tem os seguintes parâmetros:
- Nome do documento - nome do Expert Advisor para ensino;
- Camadas neurais - número de camadas da rede neural;
- Neurõnios centrais - número de neurõnios;
- Épocas de ensino - número de épocas de ensino;
- Barras padrão - Número de barras em um padrão;
- Ensinando uma rede? - inicie o processo de ensinamento da rede neural (ou simplesmente a geração de sinal);
- SignalsCreate - para automaticamente criar imagens gráficas de sinais;
- SignalsBarPoints - limiar de geração do sinal expresso em pontos;
- SignalsBarsCount - número de barras para o cálculo de pontos;
- SignalsStartTime, SignalsEndTime - hora de início e fim do período para a geração do sinal;
- SignalsClear - para apagar automaticamente as imagens do sinal após a conclusão do ensino.
Fig. 6. Os parâmetros do script TeachHNN
Se tudo estiver pronto, clique em "OK" para iniciar o processo de ensinamento do Expert Advisor. Isto vai iniciar a geração automática de padrões gráficos para cada um dos sinais disponíveis no gráfico.
A informação relevante é exibida na aba 'Experts' no painel 'caixa de ferramentas' do terminal, enquanto os objetos correspondentes aparecem na janela do gerador EA Hlaiman.
Após a conclusão da geração de padrões, o processo de ensino começa. Ele é exibido na barra de progresso de ensino que aparece na tela.
Fig. 7. Painel de progresso de ensino
Espere até que o processo seja concluído. O processo de ensino pode ser finalizado antes que esteja concluído clicando com o botão direito na barra de progresso de ensino e selecionando a opção apropriada no menu de contexto.
Após a conclusão do processo de ensino e operação do script, a mensagem relevante será adicionada ao registro na aba "Experts", por exemplo, 'rede neural criada com sucesso! Em 431 padrões indica que o ensino do Expert Advisor foi concluído com êxito usando 431 sinais.
Estas mensagens mostram quantos padrões foram envolvidos no processo de ensino e localiza os números desses padrões. A COMPRA e VENDA, em particular, são determinados utilizando as mensagens do seguinte tipo: 'Sinal de venda detectado no padrão #211'.
Fig. 8. As mensagens do script TeachHNN no curso de ensino
As razões pelas quais o processo de ensinamento do Expert Advisor pode começar com um erro são as seguintes:
- O aplicativo Hlaiman não estava em funcionamento antes do início, como requerido. Neste caso, a mensagem de erro será a seguinte "Erro CSignalHNN::InitHNN!: Erro! inicializar o servidor de pipe (razão possível: A APLICAÇÃO HLAIMAN NÃO ESTÁ FUNCIONANDO!)".
- A ausência de setas que indicam sinais no gráfico sob a geração automática deficiente de sinais (a variável SignalsCreate = falso). Neste caso, a mensagem de erro a ser exibida é a seguinte: Erro "OnStart: ordens de seta não encontradas!" Se a geração automática de sinais está habilitada (a variável SignalsCreate = verdadeiro), um erro pode ser causado pela presença de outros objetos gráficos no gráfico, uma vez que as marcações personalizadas não são supostamente para estarem envolvidas no programa. Portanto, é recomendável abrir todas os gráficos separadamente para fins de geração automática de sinais.
Quando o ensinamento do Expert Advisor for concluído, você pode ver os resultados relevantes passando para a interface gráfica Hlaiman e selecionando objetos apropriados e os painéis de visualização.
Fig. 9. A aba 'texto' do aplicativo Hlaiman
Fig. 10. A aba 'gráfico' do aplicativo Hlaiman
Depois de ensinar com sucesso o Expert Advisor em pelo menos um instrumento de negociação, podemos prosseguir aos testes e/ou à otimização.
Para fazer isso, selecione o nome do Expert Advisor treinado, símbolo, período de tempo, intervalo e outros parâmetros de teste no testador de estratégia. Configure as variáveis externas, se necessário e execute o teste.
Fig. 11. Configurações do Expert Advisor SampleHNN para teste retrospectivo
Fig. 12. Variáveis externas do Expert Advisor SampleHNN podem ser modificadas
Abaixo encontra-se um exemplo do relatório de operação do Expert Advisor no testador de estratégia. O Expert Advisor foi ensinado através de sinais gerados automaticamente, com todos os parâmetros externos do script de ensino sendo definidos por padrão. O período de ensino: 01.01.2010-01.07.2013, instrumento: EURUSD H4.
Relatório do testador de estratégia
| Expert Advisor: | SampleHNN |
|---|---|
| Símbolo: | EURUSD |
| Período: | H4 (2010.01.01-2013.07.12) |
| Moeda: | USD |
| Depósito Inicial: | 10.000,00 |
| Alavancagem: | 0,111111111 |
| Teste retrospectivo | |
| Qualidade do histórico: | 100% |
| Barras: | 5497 |
| Lucro da rede: | 9.159,58 |
| Lucro bruto: | 29.735,97 |
| Prejuízo bruto: | -20.576,39 |
| Fator de lucro: | 1,45 |
| Fator de recuperação: | 12,81 |
| AHPR: | 1,0005 (0.05%) |
| GHPR: | 1,0005 (0.05%) |
| Total de negócios: | 1417 |
| Total de acordos: | 2246 |
| Ticks: | 60211228 |
| Queda absoluta de balanço: | 0,00 |
| Queda máxima de balanço: | 679,98 (3.81%) |
| Queda relativa de balanço: | 4.00% (715,08) |
| Pagamento esperado: | 6,46 |
| Taxa de Sharpe: | 0,16 |
| Correlação LR: | 0,98 |
| Erro padrão LR: | 595,06 |
| Negócios curtos ( ganho 0%): | 703 (56.61%) |
| Negócios lucrativos (% do total): | 793 (55.96%) |
| Negócio com maior lucro: | 53,00 |
| Lucro médio de negociação: | 37,50 |
| Máximo de ganhos consecutivos: | 9 (450.38) |
| Máximo de lucro consecutivo: | 450,38 (9) |
| Médias de ganhos consecutivos: | 2 |
| Símbolos: | 1 |
| Queda absoluta de patrimõnio líquido: | 6,60 |
| Queda máxima de lucro líquido: | 715,08 (4.00%) |
| Queda relativa de patrimõnio líquido: | 4.00% (715,08) |
| Nível de margem: | 6929,24% |
| Z-Account: | -1,24 (78.50%) |
| Resultado onTester: | 0 |
| Negócios longos (ganho %): | 714 (55.32%) |
| Negócios com prejuízo ( % do total): | 624 (44.04%) |
| Negócio com maior perda: | -53,30 |
| Perda comercial média: | -32,97 |
| Máximo de perdas consecutivas: | 9 (-234.00) |
| Máximo de perda consecutiva: | -276,67 (7) |
| Médias de perdas consecutivas: | 2 |
Fig. 13. Resultados do teste retrospectivo do Expert Advisor SampleHNN
Fig. 14. As estatísticas de entrada no mercado do Expert Advisor SampleHNN
Fig. 15. Correlação entre lucro e MFE/MAE do Expert Advisor SampleHNN
Fig. 16. As estatísticas do tempo de retenção da posição do Expert Advisor SampleHNN
Implementação
O principal componente da implementação do MQL5 é a classe CSignalHNN descrita no módulo sinal SignalHNN.mqh. A classe é herdada da classe base CExpertSignal e inclui todos os campos de dados e métodos necessários para a operação e integração de Hlaiman, bem como para trabalhar com Expert Advisors gerados usando o assistente do MQL5.
O modelo de classe é o seguinte:
//+------------------------------------------------------------------+ //| Class CSignalHNN. | //| Purpose: Class of generator of trade signals based on | //| the 'Hlaiman EA Generator Neural Net' indicator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalHNN :public CExpertSignal { protected: //--- variables int m_hnn; // handle of HNN connect string hnn_path; // MT5 Terminal data path string hnn_fil; // HNN file w neural net string hnn_nam; // Expert name string hnn_sym; // Symbol name string hnn_per; // Period name ENUM_TIMEFRAMES hnn_period; // Period timeframe int hnn_index; // Index ext multinet int hnn_bar; // index of last bar int hnn_in; // input layer int hnn_out; // output layer int hnn_layers; // layers count int hnn_neurons; // neurons count int hnn_epoch; // learn epoch double hnn_signal; // value of last signal double pattern[]; // values of the pattern bool hnn_norm; // normalize pattern public: CSignalHNN(void); // class constructor ~CSignalHNN(void); // class destructor //--- methods of setting adjustable parameters void PatternBarsCount(int value) { hnn_in = value; ArrayResize(pattern, value + 1); } void LayersCount(int value) { hnn_layers = value; } void NeuronsCount(int value) { hnn_neurons = value; } void EpochCount(int value) { hnn_epoch = value; } void Normalize(bool value) { hnn_norm = value; } //--- method of verification of settings virtual bool ValidationSettings(void); //--- method of creating the indicator and timeseries virtual bool InitIndicators(CIndicators *indicators); //--- methods of checking conditions of entering the market virtual double Direction(void); bool FillPattern(datetime tim = 0); // prepare pattern bool AddPattern(string name, int ptype); // add new pattern bool TeachHNN(void); // learn neural net bool SaveFileHNN(void); // neural net file double CalculateHNN(void); // calc neural signal //protected: //--- method of initialization of the Hlaiman Application bool InitHNN(bool openn); // Hlaiman App Init void FreeHNN(void) { // Hlaiman App Deinit if(m_hnn!=0 && m_hnn!=INVALID_HANDLE) { FileClose(m_hnn); m_hnn=0; } }; };
Após a criação da instância da classe usando o construtor, este objeto pode funcionar em dois modos principais:
- Modo de ensino: este modo é associado com a coleção de padrões de mercado e ensino da rede neural.
- Modo indicador: neste modo, o sinal de rede neural é calculado usando o padrão atual.
O modo é identificado após chamar o modo de inicialização InitHNN usando o parâmetro booliano openn. O valor real deste parâmetro inicia a busca e a abertura, assim como o carregamento e operação do arquivo de dados da rede neural ensinado no modo indicador (2). Este modo é considerado ser o modo de funcionamento e é usado no Expert Advisor para negociação.
Ao contrário do modo de ensino (1), que é inicializado ao chamar o método InitHNN com openn=falso, o modo indicador é preparatório para o Expert Advisor e é usado para a operação do script de ensino.
O método de inicialização é implementado da seguinte forma:
//+------------------------------------------------------------------+ //| Initialize HNN | //+------------------------------------------------------------------+ bool CSignalHNN::InitHNN(bool openn) { //--- initialize Hlaiman Application int num=0; ulong res=0; if(m_symbol!=NULL) { hnn_sym=m_symbol.Name(); hnn_period=m_period; } else { hnn_sym=_Symbol; hnn_period=_Period; } hnn_per = string(PeriodSeconds(hnn_period) / 60); hnn_fil = hnn_nam + NAME_DELIM + hnn_sym + hnn_per + NAME_DELIM + string(hnn_index) + TYPE_NEURO; if(m_hnn== 0|| m_hnn == INVALID_HANDLE) m_hnn=FileOpen(HLAIMAN_PIPE,FILE_READ|FILE_WRITE|FILE_BIN); if(m_hnn!=0 && m_hnn!=INVALID_HANDLE) { string source,result=""; if(openn==true) { result=CON_OPENN+CON_TRUE; if(!FileIsExist(hnn_fil,FILE_READ)) { if(FileIsExist(hnn_fil,FILE_READ|FILE_COMMON)) hnn_fil=TerminalInfoString(TERMINAL_COMMONDATA_PATH)+PATH_FILES+hnn_fil; else { // hnn_fil = hnn_path + PATH_MQL5 + PATH_FILES + hnn_fil; hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } } else hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } else { result=CON_OPENN+CON_FALSE; hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } source="unit InitHNN; Interface "+result+" var libr, term, exp, sym: TObject;" " Implementation function main: integer;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');" " if (exp = nil) then exp := term.AddObject('TMT45Expert');\n\r" // Line #5 " if (exp <> nil) then" " begin" " if (exp.Name <> '"+hnn_nam+"') then exp.Name := '"+hnn_nam+"';\n\r" // Line #6 " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');" " if (sym = nil) then sym := exp.AddObject('TMT45Symbol');" " if (sym <> nil) then" " begin" " sym.Log.Add('"+hnn_sym+hnn_per+"');\n\r" " if (sym.Name <> '"+hnn_sym+hnn_per+"') then sym.Name := '"+hnn_sym+hnn_per+"';" " if (sym.Period <> "+hnn_per+") then sym.Period := "+hnn_per+";" " if (openn = true) then" " begin" // " sym.Log.Add('" + hnn_fil + "');" " if (sym.Open('"+hnn_fil+"')) then Result := sym.TeachInput;\n\r" // ret input Line #8 " end else" " begin" " sym.TeachInput := "+IntegerToString(hnn_in)+";" " sym.TeachOutput := "+IntegerToString(hnn_out)+";" " sym.TeachLayer := "+IntegerToString(hnn_layers)+";" " sym.TeachNeurons := "+IntegerToString(hnn_neurons)+";" " sym.TeachEpoch := "+IntegerToString(hnn_epoch)+";" " sym.FileName := '"+hnn_fil+"';" " Result := sym.TeachInput;\n\r" // ret input Line #9 " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(res<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); res=FileSize(m_hnn); num++; } if(res>0) { result=FileReadString(m_hnn,int(res/2)); res=StringToInteger(result); if(res<=RES_OK) printf(__FUNCTION__+": Error! Initialization data(possible reason: FILE NOT EXIST OR CORRUPTED "+hnn_fil); else { printf(__FUNCTION__+": Initialization successful! NEURAL PATTERN "+string(res)); ArrayResize(pattern,int(res+1)); return(true); } } else printf(__FUNCTION__+": Error! pipe server not responding(possible elimination: RESTART HLAIMAN APPLICATION)"); } else printf(__FUNCTION__+": Error! initializing pipe server (possible reason: HLAIMAN APPLICATION IS NOT RUNNING!)"); //--- ok return(false); }
Como pode ser visto a partir do código, o primeiro passo da inicialização abrange uma tentativa de abrir um pipe nomeado para a ligação com o do aplicativo Hlaiman. Se essa tentativa falhar (por exemplo, quando não está em execução), a saída é realizada com um status negativo. Na segunda etapa (após a conclusão bem sucedida da primeira etapa e do modo indicador operacional), as pastas locais e comuns do terminal são pesquisadas para o nome do arquivo desejado com os dados da rede neural. A terceira etapa trata da preparação do código em ObjectPascal (Delphi) para a inicialização diretamente no aplicativo Hlaiman.
O texto do código é então movido para a sequência de origem. Por conveniência de formatação, ele é dividido em subsequências usando '\n\r' e contém invocações das propriedades e métodos do objeto Hlaiman (ver comentários). Conforme definido no texto, o ambiente baseado em objeto do plug-in MetaTrader 5 Hlaiman representa a arquitetura da árvore, com o objeto do plug-in repousado na raiz.
O objeto do terminal МetaТrader 5 está no próximo nível seguido por Expert Advisor e objetos de símbolos. No caso de uma tradução e execução bem-sucedida do código-fonte passado através do pipe nomeado, o valor do resultado retornado conterá o número de elementos do vetor de entrada da rede neural. Como o código sugere, este valor é usado para inicializar a matriz padrão e a execução do método é concluído com um status positivo.
Os outros principais métodos da classe CSignalHNN são CalculateHNN, AddPattern e TeachHNN. O primeiro retorna o resultado do cálculo da rede neural no modo de indicador. Os outros dois métodos são utilizados no modo de ensino ao juntar padrões e iniciar o processo de ensino da rede neural, respectivamente.
A implementação desses métodos em é a seguinte:
//+------------------------------------------------------------------+ //| Calculate HNN signal | //+------------------------------------------------------------------+ double CSignalHNN::CalculateHNN(void) { if(m_hnn==0 || m_hnn==INVALID_HANDLE) return(0.0); int num = 0; ulong siz = 0; double res=0.0; string source,result=""; if(FillPattern(0)==true) { result=CON_START; for(int i=1; i<(ArraySize(pattern)-1); i++) result= result+DoubleToString(pattern[i])+CON_ADD; result = result + DoubleToString(pattern[ArraySize(pattern) - 1]) + CON_END; source = "unit CalcHNN; Interface " + result + " var i: integer; libr, term, exp, sym, lst: TObject;" " Implementation function main: double;\n\r" // Line #1 " begin" " Result := 0.0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " lst := TStringList.Create;" " if (lst <> nil) then" " begin" " lst.Text := cons;" " if (lst.Count >= sym.NetInputs.Count) then" " begin" " for i := 0 to sym.NetInputs.Count - 1 do" " begin" " sym.NetInputs.Objects[i].NetValue := StrToFloat(lst[i]);\n\r" // Line #6 // " sym.Log.Add('Input ' + IntToStr(i) + ' = ' + lst[i]);" " end;" " sym.Computed := true;" " Result := sym.NetOutputs.Objects[0].NetValue;\n\r" // ret input Line #7 " end;" " lst.Free;" " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToDouble(result); } } //else Print("fill pattern error!"); return(res); } //+------------------------------------------------------------------+ //| AddPattern | //+------------------------------------------------------------------+ bool CSignalHNN::AddPattern(string name,int ptype) { int num=0; long res=0; ulong siz=0; string result,source,nam=name; if(m_hnn!=0 || m_hnn!=INVALID_HANDLE) { pattern[0]=ptype; result=CON_START; for(int i=0; i<(ArraySize(pattern)-1); i++) result= result+DoubleToString(pattern[i])+CON_ADD; result = result + DoubleToString(pattern[ArraySize(pattern) - 1]) + CON_END; source = "unit AddPatternHNN; Interface " + result + " Implementation function main: integer;" " var i: integer; out: double; onam: string;" " libr, term, exp, sym, ord, tck, lst: TObject;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " lst := TStringList.Create;" " if (lst <> nil) then" " begin" " lst.Text := cons;" " if (lst.Count >= (sym.TeachInput + sym.TeachOutput)) then" " begin" " out := StrToFloat(lst[0]);" " if(out >= 0) then onam := 'BUY-"+nam+"'" " else onam := 'SELL-"+nam+"';" " ord := sym.ObjectOfName(onam);" " if (ord = nil) then ord := sym.AddObject('TMT45Order');\n\r" // Line #6 " if (ord <> nil) then" " begin" " if (ord.Name <> onam) then ord.Name := onam;\n\r" // Line #7 " if (out >= 0) then ord.OrderType := 0 else ord.OrderType := 1;" " if (ord.NetOutput <> out) then ord.NetOutput := out;\n\r" // Line #8 " for i := 1 to sym.TeachInput do" " begin" " if(i <= ord.Count) then tck := ord.Items[i - 1] else" " tck := ord.AddObject('TMT45Tick');\n\r" // Line #10 " if (tck <> nil) then" " begin" " tck.x := i;" " tck.y := StrToFloat(lst[i]);\n\r" // Line #11 " end;" " end;" " end;" " Result := sym.Count;\n\r" // ret input Line #12 " end;" " lst.Free;" " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToInteger(result); } } return(res>0); } //+------------------------------------------------------------------+ //| TeachHNN | //+------------------------------------------------------------------+ bool CSignalHNN::TeachHNN(void) { int num=0; long res=0; ulong siz=0; string result,source; if(m_hnn!=0 || m_hnn!=INVALID_HANDLE) { source="unit TeachHNN; Interface const WAIT_TIM = 100; WAIT_CNT = 100;" " var i: integer; libr, term, exp, sym: TObject;" " Implementation function main: integer;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " if (sym.Teached) then sym.Teached := false;\n\r" // Line #6 " sym.Teached := true;\n\r" // Line #7 " Result := sym.Count;\n\r" // ret input Line #8 " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0) {// && (MQL5InfoInteger(MQL5_TESTER) || num < WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToInteger(result); } } return(res>0); }
Como pode ser visto a partir do código, o corpo do método consiste principalmente das linhas de origem, cujo texto é disposto de forma similar aos textos acima considerados na descrição do método InitHNN. A única diferença é que a hierarquia baseada em objetos do plug-in tem mais dois níveis para a representação padrão - ordem e tick. Além disso, o código contém propriedades e métodos de objetos adicionais. Por exemplo, o início do cálculo da rede neural é sinalizado pelo indicador Computadorizado do objeto 'símbolo', enquanto o indicador Ensinado é usado quando se inicia o processo de ensino.
O método CalculateHNN também é diferente de outros métodos em que o tipo de valor 'principal' retornado pela função, neste caso, é "duplo". Este valor é a saída da rede neural - o sinal, através do qual o nível de COMPRA se situa no intervalo 0..1 e o nível VENDA está na gama de 0..-1. Este sinal é usado pelo Expert Advisor na tomada de decisões relativas à abertura ou fechamento de posições de negociação e é controlado pelo método Direction (direção). Esse método realiza o recálculo no caso da nova barra e retorna seu valor expresso em porcentagem.
//+------------------------------------------------------------------+ //| Check conditions for trading signals. | //+------------------------------------------------------------------+ double CSignalHNN::Direction(void) { if( m_hnn == 0 || m_hnn == INVALID_HANDLE) return(EMPTY_VALUE); //--- check new bar condition int cur_bar = Bars(hnn_sym, hnn_period); if (hnn_bar != cur_bar) { //--- condition OK hnn_signal = CalculateHNN() * 100; hnn_bar = cur_bar; } return(hnn_signal); }
Para definir o limite de resposta do sinal do Expert Advisor em relação aos sinais de abertura e fechamento de posições de negociação, você pode usar as seguintes variáveis externas:
- input int Signal_ThresholdOpen =10; // Valor limite de sinal para abrir [0...100]
- input int Signal_ThresholdClose=10; // Valor limite de sinal para fechar [0...100]
Na prática, os níveis de sinal dependem da qualidade e intensidade de ensino da rede neural que, como regra geral, pode ser avaliada monitorando visualmente a dinâmica de diminuição do erro computacional exibido no indicador no curso de ensino.
Conclusões
O gerador EA Hlaiman fornece componentes e um ambiente baseado em objeto controlado de forma transparente para a integração com MQL5, segundo o qual:
- A interface do assistente do MQL5 recebe um tipo adicional baseado no reconhecimento de sinais e padrões, bem como a possibilidade de geração de EAs de rede neural.
- Além da capacidade de gerar rapidamente EAs de redes neurais, você também pode adaptá-los rapidamente ao comportamento do mercado em mudança e repetidamente ensinar os mesmos sobre os diferentes instrumentos e prazos de negociação.
- Devido ao fato de que o assistente do MQL5 pode permitir vários módulos de sinal, você pode criar EAs de rede neural multi-moedas complexos e/ou EAs de rede neural baseados em indicador composto. Eles também podem ser combinados com vários filtros adicionais, por exemplo, filtros de tempo.
- E, finalmente, o módulo de rede neural em si pode ser utilizado como um filtro adicional para aumentar a eficiência de um Expert Advisor já pronto. Isto é possível devido à capacidade de uma rede neural ser ensinada utilizando os gráficos de visualização dos resultados dos testes do Expert Advisor original.
O uso do intérprete do script, que faz com que o sistema de computação integrado apareça com um desempenho não tão alto, pode ser considerado como uma das desvantagens da implementação fornecida acima. Primeiro, no entanto, deve notar-se que a interpretação do código do script, bem como o funcionamento do plug-in Hlaiman é assíncrono com EX5, ou seja, nós tratamos com paralelização de tarefa. Em segundo lugar, para aumentar a velocidade de cálculos demorados, por exemplo, ao lidar com grandes redes neurais, o MetaTrader 5 e Hlaiman podem ser executados em diferentes computadores conectados através de pipes de rede nomeados. Ao lançar um terminal de negociação em um computador separado você não só vai ganhar em desempenho mas também pode aumentar a sua segurança.
Quando colocado em perspectiva, podemos olhar o desenvolvimento de Expert Advisors que podem auto-aprender no curso de negociação. Neste ponto, a maneira mais fácil de fazer isso é através da combinação do código do Expert Advisor com o código do script de ensino já que ambos usam a mesma classe CSignalHNN que fornece a funcionalidade necessária. Este material pode se tornar o assunto do artigo a seguir ou formar a base de um completamente novo, caso mostrar-se ser de interesse.
O download da versão demo do gerador EA Hlaiman pode ser feito aqui.
Anexos:
- SignalHNN.mqh - módulo do sinal "MQL5\Include\Expert\Signal\".
- TeachHNN.mq5 - script de ensino "MQL5\Scripts\".
- SampleHNN.mq5 - Expert Advisor baseado no módulo do sinal de negociação 'Sinais do gerador EA de rede neural Hlaiman padrões' e gerado usando o assistente MQL5.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/706
Construindo um negociante de notícias automático
Outra classe OOP do MQL5
Assistente MQL5: Como ensinar um EA a abrir ordens pendentes a qualquer preço
Como instalar e utilizar o OpenCL para realizar cálculos
- 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