Conectando NeuroSolutions Neuronets

12 fevereiro 2014, 13:20
ds2
0
1 159

Introdução

Eu suponho que todos os negociantes que se familiarizarem com as neuronets pensem em como seria bom usá-las em análise de mercado. Há um monte de programas que permitem convenientemente criar suas próprias redes de qualquer configuração, ensinando e testando-as em um modo visual. Você pode exportar as informações necessárias a partir do terminal do cliente para um programa neuronet e analisá-lo lá.

Mas e se você quiser usar a neuronet criada em negociação automática? é possível fazer um Expert Advisor conectar a uma neuronet e ao comércio em tempo real?

Sim, é. Vários programas de neuronet tem as interfaces de programas necessários. Um deles é chamado NeuroSolutions. Sua última versão é a 6, porém, nem todo mundo a tem, e a versão mais popular agora é a 5ª. é por isso que este artigo descreve a interação com a 5ª versão. Você precisa da distributiva completa do programa, que inclui o assistente de solução personalizada que precisamos.


Pensar em uma Estratégia

A estratégia para o nosso exemplo teste será simples. Vamos chamá-lo WeekPattern. Ele vai predizer o preço de fechamento de uma barra em sua abertura no período de tempo D1 utilizando uma neuronet. Dependendo das informações obtidas, ele vai fazer uma transação de compra ou venda e mantê-la durante o dia. A previsão de preço será na base de valores OHLC das 5 barras anteriores. Para aumentar a precisão da operação da neuronet, vamos enviá-lo apenas as variações de preços relativamente ao preço de abertura da barra (zero) atual, em vez dos próprios preços.


Preparando Dados para Treinamento

Antes de iniciar a criação de uma rede, vamos escrever um script MQL5, que irá exportar todas as citações do terminal do cliente na forma requerida. Esta informação é necessária para treinar a neuronet. Os dados serão exportados para um arquivo de texto. O campo dos nomes na lista são separados por uma vírgula na primeira lista do arquivo. As próximas linhas serão utilizadas para os dados separados por vírgula. Cada linha é uma combinação de entradas e saídas da neuronet. No nosso caso, o script retornará por uma barra do histórico de preço em cada linha e escrever os valores OHLC de 6 barras na linha (5 barras do passado são entradas, e uma barra atual é a saída).

O script скрипт WeekPattern-Export.mq5 deve ser iniciado em um prazo exigido de um símbolo obrigatório (no nosso exemplo, ele é o D1 EURUSD). Nas configurações, você deve especificar um nome de arquivo e o número requerido de linhas (260 linhas para D1 é cerca de 1 ano de história). O código completo do script:

#property script_show_inputs
//+------------------------------------------------------------------+
input string    Export_FileName = "NeuroSolutions\\data.csv"; // File for exporting (in the folder "MQL5\Files")
input int       Export_Bars     = 260; // Number of lines to be exported
//+------------------------------------------------------------------+
void OnStart() 
  {
  
   // Create the file
   int file = FileOpen(Export_FileName, FILE_WRITE|FILE_CSV|FILE_ANSI, ',');
   
   if (file != INVALID_HANDLE)
     {
      // Write the heading of data
      
      string row="";
      for (int i=0; i<=5; i++)
        {
         if (StringLen(row)) row += ",";
         row += "Open"+i+",High"+i+",Low"+i+",Close"+i;
        }
      FileWrite(file, row);
      
      // Copy all required information from the history
      
      MqlRates rates[], rate;
      int count = Export_Bars + 5;
      if (CopyRates(Symbol(), Period(), 1, count, rates) < count)
        {
         Print("Error! Not enough history for exporting of data.");
         return;
        }
      ArraySetAsSeries(rates, true);
      
      // Write data      
      
      for (int bar=0; bar<Export_Bars; bar++)
        {
         row="";
         double zlevel=0;
         for (int i=0; i<=5; i++)
           {
            if (StringLen(row)) row += ",";
            rate = rates[bar+i];
            if (i==0) zlevel = rate.open; // level for counting of prices
            row += NormalizeDouble(rate.open -zlevel, Digits()) + ","
                 + NormalizeDouble(rate.high -zlevel, Digits()) + ","
                 + NormalizeDouble(rate.low  -zlevel, Digits()) + ","
                 + NormalizeDouble(rate.close-zlevel, Digits());
           }
         FileWrite(file, row);
        }

      FileClose(file);
      Print("Export of data finished successfully.");
     }
   else Print("Error! Failed to create the file for data export. ", GetLastError());
  }
//+------------------------------------------------------------------+

Depois de exportar os dados, obtemos o arquivo data.csv, suas primeiras linhas (por exemplo) parecem da seguinte forma:

Open0,High0,Low0,Close0,Open1,High1,Low1,Close1,Open2,High2,Low2,Close2,Open3,High3,Low3,Close3,Open4,High4,Low4,Close4,Open5,High5,Low5,Close5
0,0.00463,-0.0041,0.00274,-0.00518,0.00182,-0.00721,-6e-005,0.00561,0.00749,-0.00413,-0.00402,0.02038,0.02242,0.00377,0.00565,0.03642,0.0379,0.01798,0.02028,0.0405,0.04873,0.03462,0.03647
0,0.007,-0.00203,0.00512,0.01079,0.01267,0.00105,0.00116,0.02556,0.0276,0.00895,0.01083,0.0416,0.04308,0.02316,0.02546,0.04568,0.05391,0.0398,0.04165,0.04504,0.05006,0.03562,0.0456
0,0.00188,-0.00974,-0.00963,0.01477,0.01681,-0.00184,4e-005,0.03081,0.03229,0.01237,0.01467,0.03489,0.04312,0.02901,0.03086,0.03425,0.03927,0.02483,0.03481,0.02883,0.04205,0.02845,0.03809
    

Este é o formato, o qual pode ser compreendido por NeuroSolutions. Agora podemos começar a criar e treinar uma rede.


Criando Neuronet

Em NeuroSolutions você pode criar rapidamente uma neuronet, mesmo se você estiver vendo este programa pela primeira vez e saber pouco sobre neuronets. Para fazer isso, selecione o assistente para iniciantes NeuralExpert (Iniciante), no início do programa:

Nele, você deve especificar um tipo de problema que deve ser resolvido pela neuronet:

Em seguida, especifique o arquivo com informações de treinamento, que nós criamos no capítulo anterior:

Como as entradas da rede, selecione todos os campos do arquivo, exceto os campos da barra zero:

Uma vez que não temos campos de texto, não selecione nada:

Especifique o nosso arquivo com as informações novamente:

Escolha apenas uma saída de nossa rede:

O assistente sugere a criação de uma rede mais simples padrão. Vamos fazer assim:

O assistente terminou o seu trabalho criando uma neuronet para nós (e não uma rede treinada, apenas uma estrutura simples):

Agora podemos trabalhar com ela. Podemos treinar, testar e utiliza-la para análise de dados.

Se você clicar no botão de teste, você será capaz de ver como a rede inexperiente vai resolver o nosso problema. Responda às perguntas do assistente de testes:

Realize o teste com base em informações do mesmo arquivo:

O teste acabou. Na janela de "Saída versus Diagrama Desejado" você pode ver no gráfico que mostra os valores obtidos a partir da rede (cor vermelha) em nossa história e os valores reais (cor azul). Você pode ver que são bastante diferentes:

Agora vamos treinar a rede. A fim de fazer isso, clique no botão verde Iniciar na barra de ferramentas abaixo do menu. O treinamento será concluído após alguns segundos e o gráfico mudará.


Agora, no gráfico, você pode ver que a rede mostra os resultados que parecem ser verdadeiros. Portanto, você pode usá-los para negociação. Salve a net com o nome WeekPattern.


Exportar a neuronet em uma DLL

Sem sair de NeuroSolutions, clique no botão CSW que inicia o Assistente de Solução Personalizada. Precisamos gerar uma DLL a partir da neuronet atual.

O assistente pode gerar DLLs para diferentes programas. Tanto quanto percebi, para a compilação da DLL você precisa de Visual C ++ de uma das seguintes versões: 5.0/6.0/7.0 (.NET 2002)/7.1 (.NET 2003)/8.0 (.NET 2005). Por alguma razão, ele não usa a versão Express (eu verifiquei).

Não há MetaTrader na lista das aplicações visadas. é por isso que seleciona-se Visual C++.

Rota para salvar o resultado:

Se tudo transcorreu com sucesso, o assistente informa sobre:

Um monte de arquivos aparecerá na pasta especificada no assistente. Os que mais precisam são: O WeekPattern.dll, que contém nossa neuronet com a interface do programa para ele, e o arquivo WeekPattern.nsw, que contém as configurações de balanço da neuronet após a sua formação. Entre os outros arquivos você pode encontrar aquele com um exemplo de trabalho com esta neuronet DLL. Neste caso é o projeto visual C++ 6.


Conectando a neuronet DLL ao MetaTrader

Criada no capítulo anterior, a neuronet DLL é destinada para uso em projetos visual C++. Ela opera com os objetos de uma estrutura complexa que seria difícil ou mesmo impossível descrever em MQL5. é por isso que nós não estamos indo conectar esta DLL ao MetaTrader diretamente. Em vez disso, vamos criar um pequeno adaptador DLL. Este adaptador irá conter uma função simples para trabalhar com neuronet. Ele vai criar a rede, passar a informação de entrada e retornar os dados de saída.

Este adaptador será facilmente chamado de MetaTrader 5. E o adaptador irá conectar-se à neuronet DLL criada em NeuroSolutions. Uma vez que o adaptador será escrito em Visual C++, ele não vai ter problemas com objetos desta DLL.




Não há necessidade de criar o próprio adaptador DLL. O DLL trivial está ligado a este artigo. O adaptador funciona com qualquer neuronet DLL criada em NeuroSolutions. Você pode pular mais lições deste capítulo.

Mas se você tem uma experiência em programação em C++, e se você estiver interessado em como criar tal adaptador, leia este capítulo até o fim. Provavelmente, você terá interesse em melhorá-lo, uma vez que algumas outras funções podem ser exportadas a partir de uma neuronet DLL. Por exemplo, a função de treinamento (para um Expert Advisor, faz adaptação a uma mudança do mercado, retreinando a rede automaticamente). Você pode aprender a lista completa de funções analisando o exemplo gerado pelo assistente de solução personalizada, que é mostrado no capítulo anterior.

Vamos precisar de apenas alguns arquivos daquele exemplo.

No Visual C++ (a mesma versão usada no assistente de solução personalizada), criar um projeto DLL vazio chamado NeuroSolutionsAdapter e copiar os arquivos NSNetwork.h, NSNetwork.cpp e StdAfx.h do exemplo para ele. Também criar um arquivo main.cpp vazio:


Escreva o seguinte código no arquivo main.cpp:

#include "stdafx.h"
#include "NSNetwork.h"

extern "C" __declspec(dllexport) int __stdcall CalcNeuralNet(
                LPCWSTR dllPath_u, LPCWSTR weightsPath_u,
                double* inputs, double* outputs)
{       
    // Transform the lines from Unicode to normal ones
    CString dllPath     (dllPath_u);
    CString weightsPath (weightsPath_u);

    // Create neuronet
    NSRecallNetwork nn(dllPath);
    if (!nn.IsLoaded()) return (1);

    // Load balances
    if (nn.LoadWeights(weightsPath) != 0) return (2);
        
    // Pass input data and calculate the output
    if (nn.GetResponse(1, inputs, outputs) != 0) return (3);

    return 0;
}

Construir. O adaptador DLL está pronto!


Usando Neuronet em Expert Advisor

Bem, nós já criamos vários arquivos. Deixe-me listar os arquivos, que são necessários para o Expert Advisor trabalhar, e as pastas onde você deve colocá-los. Todos os arquivos são anexados ao artigo.

Arquivo
Descrição
Onde colocar (na pasta terminal)
WeekPattern.dll
nossa neuronet DLL criada em NeuroSolutions
MQL5\Files\NeuroSolutions\
WeekPattern.nswconfigurações de balanço para nossa neuronet
MQL5\Files\NeuroSolutions\
NeuroSolutionsAdapter.dll
adaptador DLL universal DLL para qualquer neuronet DLL
MQL5\Libraries\


Aqui está o código completo do Expert Advisor WeekPattern.mq5. Para maior conveniência de busca e uma posterior modificação, todas as coisas concernentes a neuronet são colocados em classes separadas da CNeuroSolutionsNeuralNet.

input double    Lots = 0.1;
//+------------------------------------------------------------------+
// Connect the DLL adapter, using which we are going to use the DLL neuronet created in NeuroSolutions
#import "NeuroSolutionsAdapter.dll"
int CalcNeuralNet(string dllPath, string weightsPath, double& inputs[], double& outputs[]);
#import 
//+------------------------------------------------------------------+
class CNeuroSolutionsNeuralNet
{
private:
   string dllPath;     // Path to a DLL neuronet created in NeuroSolutions
   string weightsPath; // Path to a file of the neuronet balances
public:
   double in[20]; // Neuronet inputs - OHLC of 5 bars
   double out[1]; // Neuronet outputs - Close of a current bar

   CNeuroSolutionsNeuralNet();
   bool Calc();
};
//+------------------------------------------------------------------+
void CNeuroSolutionsNeuralNet::CNeuroSolutionsNeuralNet()
{
   string terminal = TerminalInfoString(TERMINAL_PATH);
   dllPath     = terminal + "\\MQL5\\Files\\NeuroSolutions\\WeekPattern.dll";
   weightsPath = terminal + "\\MQL5\\Files\\NeuroSolutions\\WeekPattern.nsw";
}
//+------------------------------------------------------------------+
bool CNeuroSolutionsNeuralNet::Calc()
  {
   // Get current quotes for the neuronet
   MqlRates rates[], rate;
   CopyRates(Symbol(), Period(), 0, 6, rates);
   ArraySetAsSeries(rates, true);
      
   // Fill the array of input data of the neuronet
   double zlevel=0;   
   for (int bar=0; bar<=5; bar++)
     {
      rate = rates[bar];
      // 0 bar is not taken for input
      if (bar==0) zlevel=rate.open; // level of price calculation
      // 1-5 bars are inputed
      else
        {
         int i=(bar-1)*4; // input number
         in[i  ] = rate.open -zlevel;
         in[i+1] = rate.high -zlevel;
         in[i+2] = rate.low  -zlevel;
         in[i+3] = rate.close-zlevel;
        }
     }
 
   // Calculate the neuronet in the NeuroSolutions DLL (though the DLL adapter)
   int res = CalcNeuralNet(dllPath, weightsPath, in, out);
   switch (res)
     {
      case 1: Print("Error of creating neuronet from DLL \"", dllPath, "\""); return (false);
      case 2: Print("Error of loading balances to neuronet from the file \"", weightsPath, "\""); return (false);
      case 3: Print("Error of calculation of neuronet");  return (false);
     }
     
   // Output of the neuronet has appeared in the array out, you shouldn't do anything with it

   return (true);
  }
//+------------------------------------------------------------------+

CNeuroSolutionsNeuralNet NN;
double Prognoze;

//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
//+------------------------------------------------------------------+
void OnTick() 
  {
   // Get the price prediction from the neuronet
   if (NN.Calc()) Prognoze = NN.out[0];
   else           Prognoze = 0;

   // Perform necessary trade actions
   Trade();
  }
//+------------------------------------------------------------------+
void Trade() 
  {

   // Close an open position if it is opposite to the prediction

   if(PositionSelect(_Symbol)) 
     {
      long type=PositionGetInteger(POSITION_TYPE);
      bool close=false;
      if((type == POSITION_TYPE_BUY)  && (Prognoze <= 0)) close = true;
      if((type == POSITION_TYPE_SELL) && (Prognoze >= 0)) close = true;
      if(close) 
        {
         CTrade trade;
         trade.PositionClose(_Symbol);
        }
     }

   // If there is no positions, open one according to the prediction

   if((Prognoze!=0) && (!PositionSelect(_Symbol))) 
     {
      CTrade trade;
      if(Prognoze > 0) trade.Buy (Lots);
      if(Prognoze < 0) trade.Sell(Lots);
     }
  }
//+------------------------------------------------------------------+


Uma boa maneira de verificar se estamos conectado a neuronet corretamente, é executar o Expert Advisor no testador de estratégia no mesmo período de tempo que o utilizado para treinamento da neuronet.

Bem, como os negociantes experientes dizem, a neuronet é "adaptada" para esse período. Portanto, ela é treinada para reconhecer e informar sobre um sinal de lucro para os padrões de dados exatos, que dominam nesse período específico. Um gráfico de lucratividade de um Expert Advisor desenhado para tal período deve ser crescente.

Vamos dar uma olhada. No nosso caso, será o lindo quadro seguinte:


Isso significa que tudo tenha sido conectado corretamente.

E para as estatísticas, aqui estão os outros relatórios sobre o teste do Expert Advisor:




Por segurança, deixe-me dar explicações para os desenvolvedores iniciantes das neuronets e estratégias de negócio.

A rentabilidade de um Expert Advisor em um período, que foi utilizado para a sua otimização (formação de sua neuronet), não diz respeito a rentabilidade total da EA. Em outras palavras, ele não garante sua rentabilidade por outro período. Pode haver outros padrões dominantes.

A criação de estratégias de negócios que mantêm a sua rentabilidade por trás do período de treinamento é uma tarefa complexa e complicada. Você não deve contar com os NeuroSolutions ou qualquer outra aplicação da neuronet para resolver este problema para você. Ele só cria uma neuronet para seus dados.

Essas são as razões pelas quais eu não dou aqui o resultado do teste emitido do Expert Advisor obtido. A criação de uma estratégia de negócio rentável não é o objetivo deste artigo. O objetivo é contar como se conectar a neuronet de um Expert Advisor.


Conclusão

Agora os negociantes têm outra ferramenta poderosa e fácil para análise de negociação automática e comercial. Usá-la juntamente com uma compreensão profunda dos princípios e possibilidades das neuronets, bem como as regras de formação delas, permitirá que você siga o caminho da criação de Expert Advisors rentáveis.

Traduzido do russo pela MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/236

Arquivos anexados |
dll_nsw.zip (383.37 KB)
weekpattern.mq5 (3.78 KB)
Moving Mini-Max: um Novo Indicador para a Análise Técnica e sua Implementação no MQL5 Moving Mini-Max: um Novo Indicador para a Análise Técnica e sua Implementação no MQL5
No seguinte artigo, descrevo um processo de implementação do indicador Moving Mini-Max com base em um documento de Z.G.Silagadze 'Moving Mini-max: a new indicator for technical analysis'. A ideia do indicador baseia-se na simulação do fenômeno de tunelamento quântico, proposto por G. Gamov na teoria de desintegração alfa.
A Implementação de um Modo Multi-currency (múltiplas moedas) no MetaTrader 5 A Implementação de um Modo Multi-currency (múltiplas moedas) no MetaTrader 5
Por um longo tempo a análise de várias moedas e negociação de várias moedas foi de interesse das pessoas. A oportunidade para implementar um regime de várias moedas completo tornou-se possível apenas com o lançamento público do MetaTrader 5 e a linguagem de programação MQL5. Neste artigo, propomos um modo para analisar e processar todos os ticks de entrada para diversos símbolos. Como ilustração, vamos considerar um indicador RSI de várias moedas do índice de dólar USDx.
O jogador de negociação baseado no histórico de acordo O jogador de negociação baseado no histórico de acordo
O reprodutor de negócio. Apenas quatro palavras, não há necessidade de explicação. Pensamentos sobre uma pequena caixa com botões vêm à mente. Pressione um botão - ele reproduz, move a alavanca - a velocidade da reprodução muda. Na realidade, é bastante similar. Neste artigo, quero mostrar meu desenvolvimento que reproduz o histórico de negócio quase como em tempo real. O artigo cobre algumas nuances de OOP, trabalhando com indicadores e gráficos de gerenciamento.
Assistente MQL5: como criar um módulo de rastreamento de posições abertas Assistente MQL5: como criar um módulo de rastreamento de posições abertas
O gerador de estratégias de negociação do Assistente MQL5 simplifica o teste de ideias de negociação. O artigo discute como escrever e conectar ao gerador de estratégias de negociação do Assistente MQL5 a sua própria classe de gerenciamento de posições abertas, movendo o nível de Stop Loss para a zona lossless quando o preço for em direção da posição, permitindo diminuir levantamentos ao negociar. Fala também sobre a estrutura e o formato da descrição da classe criada para o Assistente MQL5.