Como desenvolver uma estratégia de negociação lucrativa

Introdução

O processo de desenvolvimento de estratégias de negociação bem sucedidas com a implementação de análise técnica pode ser dividido em vários estágios:

1. Adicione vários indicadores técnicos a uma janela de gráfico de um preço de um instrumento financeiro e identifique padrões de correlações de mercado e indicadores de sinal.
2. Formule os dados obtidos por meio do passo de correlação supracitado.
3. Converta a estratégia para uma linguagem de programação relevante, de modo a criar um sistema de negociações mecânico.
4. Execute o sistema de negociações em um simulador baseado em dados do histórico e tente igualar os seus parâmetros de entrada (otimizar).
5. Caso o passo anterior não tenha melhorado o equilíbrio, prossiga para o passo 1.
6. Para realizar testes, execute o sistema obtido por meio dos estágios anteriores em contas de demonstração para teste.
7. Caso o passo anterior não traga nenhum lucro relativo ao dinheiro virtual, prossiga para o passo 1.
8. Utilize o sistema em negociações reais, ajustando os seus parâmetros de entrada ocasionalmente de acordo com as condições variáveis do mercado.

É apenas isso, realmente. O sistema criado desta maneira pode ser usado em negociações automatizadas, e também como um conselheiro em negociações manuais, capaz de sugerir os mais importantes sinais enviados pelos indicadores técnicos.

Vejamos o que acontece se tentarmos informatizar todo o processo.

Este artigo analisa o uso de uma rede neural simples de camada única para a identificação dos futuros movimentos de preço com base em leituras do oscilador de aceleração/desaceleração (AC).

Rede neural

O que é uma rede neural ou "perceptron"? Trata-se de um algoritmo que usa um filtro linear para adicionar um objeto a uma classe particular ou, do contrário, para excluí-lo da mesma classe objeto. É assim que a inequação se parece:

w1 * a1 + w2 * a2 + ... wn * an > d,

onde:

wi - coeficiente de pesagem com índice i,

ai - valor numérico de um sinal com índice de objeto i,

d - valor limite que frequentemente é igual a 0.


Caso o lado esquerdo da inequação seja mais alto do que o valor limite, o objeto pertence a uma classe específica, caso ele seja mais baixo, o mesmo não se aplica. Caso a classificação do objeto implique na separação entre duas classes, a rede neural de camada única é suficiente.

Pode parecer que a inequação usada na rede neural é, de alguma maneira, parecida com uma "passe de mágica", no que se refere a fatores de pesagem. Entretanto, não é esse o caso. O princípio da operação da rede neural tem um significado geométrico.

Na verdade, um plano é descrito geometricamente como uma equação linear. Por exemplo, em um espaço tridimensional a equação de plano referente as coordenadas X, Y e Z são as seguintes:

A * X + B * Y + C * Z + D = 0

As coordenadas de todos os pontos localizados em um lado do plano neste espaço satisfazem a inequação:

A * X + B * Y + C * Z + D > 0

As coordenadas de todos os pontos localizados no outro lado do plano satisfazem a inequação:

A * X + B * Y + C * Z + D > 0

Portanto, caso uma equação de plano e quaisquer coordenadas de pontos sejam de nosso conhecimento, podemos dividir um grupo de pontos no espaço entre dois grupos de pontos separados por este plano.

Respectivamente, coeficientes de pesagem em uma inequação de rede neural são constantes que definem uma certa equação de plano no espaço multidimensional de sinais de objetos. Por meio da inequação somos capazes de determinar precisamente se esses objetos estão posicionados em um lado ou outro do plano especificado. Para fazer isso, basta localizar as coordenadas do objeto e, substituindo-as na inequação do plano, compará-las a zero.

Definição do problema

Se dividirmos os objetos em duas classes, como por exemplo: posições de log aberto e posições curtas, e utilizarmos valores de análise técnica de indicadores e osciladores, será necessário somente encontrar uma equação de plano e usá-la para propósitos de identificação. A definição do problema é clara.

No entanto, há um problema com as redes neurais. Vamos considerar um espaço bidimensional de sinais descritos por coordenadas X e Y. Nós usaremos este espaço para posicionar objetos com coordenadas de pontos.

A figura acima mostra que, se um grupo de pontos de cor vermelha que não tem intersecção com um grupo de pontos coordenados está marcado em azul, então ambos os grupos podem ser separados usando linhas (uma linha é uma separação no espaço bidimensional, e um plano - em um espaço tridimensional ou polidimensional). Por favor, observe que as equações para essas linhas divisoras podem variar. Um outro exemplo:

Podemos observar que o conjunto de pontos tem intersecção no espaço, e não é possível desenhar uma linha divisora clara entre eles. A única solução viável seria desenhar uma linha que separaria dois grupos de pontos, para que a maioria dos objetos vermelhos fiquem em um lado, e os objetos azuis, do outro lado. Desta vez, estamos lidando com um problema de otimização, ou seja, procurar por uma equação que dividia o plano ou a linha que seja capaz de ter uma separação máxima entre duas classes de objetos, mas com a probabilidade de que alguns pontos de adesão sejam identificados erroneamente como uma adesão a outra classe.

Há outras maneiras de implementar redes neurais, principalmente através de filtros não lineares e redes multi-camadas. Filtros não lineares permitem utilizar uma superfície divisora de ordem alta com uma camada de divisão separadora entre objetos de classes diferentes. Redes multi-camadas implicam na utilização de múltiplos filtros (separando planos ou superfícies) para a identificação de objetos que pertençam a três ou mais classes.

Vamos tentar definir um problema que nós teremos que resolver. Uma informação básica que um trader deve conhecer para obter resultados lucrativos nas negociações é uma direção das alterações de preço. Caso um preço suba, um trader deve abrir uma posição longa. Caso um preço desça, um trader deve abrir uma posição curta. Portanto, nós já temos duas classes de objetos, a saber, as direções dos movimentos de preço. Para fazer uma decisão, seguindo a análise técnica, traders consultam um estudo dos chamados indicadores e osciladores técnicos. Também iremos analisar o oscilador chamado AC.

Dado que os osciladores técnicos são histogramas cujos valores desviam de uma linha horizontal, nós precisaremos, respectivamente, de uma rede neural com um filtro de linha. Nós usaremos padrões como sinais para um objeto, ou seja, os valores de oscilador em quatro pontos tomados de sete passos de período retrocedendo no histórico, começando do momento presente.

O valor do oscilador é marcado com um círculo na figura acima. Nós os identificaremos como a1, a2, a3 e a4 e colocaremos na equação de separação de planos para comparar o valor obtido com zero e descobrir qual lado do padrão resultará.

Só resta agora obter a equação plana, que irá separar os padrões anteriores a um movimento de subida do preço dos padrões que precedem um movimento de preço de descida.

Para este propósito nós usaremos o algoritmo genético integrado ao MetaTrader 4 e que é destinado a acelerar os processos de otimização. Em outras palavras, nós selecionaremos os valores dos coeficientes de pesagem de filtro de linha de uma maneira tal que, consequentemente, nos permitirá obter a equação de linha divisora para o equilíbrio máximo, usando as estratégias de otimização baseadas nos dados de histórico.

Para esse efeito nós precisamos pelo menos de uma formulação da estratégia de negociações, de modo a implementar o agoritmo e convertê-lo ao código do expert advisor para o MetaTrader 4.

Em teoria, um sistema de negociações deve fornecer sinais tanto para a entrada quanto para a saída do mercado. No entanto, os sinais de saída são opcionais e podem ser evitados sob as seguintes condições:

1. Realização de pedidos de take profit e stop loss;
2. Voltar-se para a direção oposta após o recebimento de um sinal indicando uma alteração na direção da tendência do mercado.

Para evitar complicar o sistema de negociações, nós usaremos as saídas para as paradas de proteção: stop loss e sinais de reversão. Neste caso, a rede neural irá receber apenas dois sinais de saída para os valores de sinais de objetos, a saber:

• Preços provavelmente irão subir;
• Preços provavelmente irão descer.

Isto simplifica a tarefa de identificar objetos para redes neurais através da divisão de todos eles em duas classes. O processo de otimização do sistema de negociações também pode ser simplificado pela eliminação do controle dos pedidos de tomada de lucros (take profit), ou seja, evitando selecionar outro parâmetro de entrada. Neste caso, é suficiente usar pedidos de trailing stop para gradualmente colocar o stop-loss em direção ao lado lucrativo, até que a rede neural envie um sinal oposto ou cometa um erro. Qualquer erro da rede neural irá ativar a parada de proteção. Além disso, o sistema de gerenciamento de pedido torna-se complicado. Uma rápida reversão de posição para uma direção oposta é melhor implementada através do uso de um pedido contrário com um lote duplo e o subsequente fechamento de uma posição contrária. Esta manobra permite a execução imediata de todas as operações de reversão, assim que a rede neural recebe o sinal.

Para reduzir o número de falsos sinais da rede neural, nós iremos ler e tomar decisões com base somente em barras formadas e nos preços iniciais das mesmas barras.

Solução do problema

Por favor, encontre abaixo o código fonte do expert advisor implementando esta estratégia de negociações:

//+------------------------------------------------------------------+
//|                                       ArtificialIntelligence.mq4 |
//|                               Copyright й 2006, Yury V. Reshetov |
//|                                         http://reshetov.xnet.uz/ |
//+------------------------------------------------------------------+
#property copyright "Copyright й 2006, Yury V. Reshetov ICQ:282715499  http://reshetov.xnet.uz/"
#property link      "http://reshetov.xnet.uz/"
//---- input parameters
extern int    x1 = 120;
extern int    x2 = 172;
extern int    x3 = 39;
extern int    x4 = 172;
// StopLoss level
extern double sl = 50;
extern double lots = 0.1;
extern int    MagicNumber = 888;
static int prevtime = 0;
static int spread = 3;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   if(Time[0] == prevtime) 
       return(0);
   prevtime = Time[0];
//----
   if(IsTradeAllowed()) 
     {
       spread = MarketInfo(Symbol(), MODE_SPREAD);
     } 
   else 
     {
       prevtime = Time[1];
       return(0);
     }
   int ticket = -1;
   // check for opened position
   int total = OrdersTotal();   
   for(int i = 0; i < total; i++) 
     {
       OrderSelect(i, SELECT_BY_POS, MODE_TRADES); 
       // check for symbol & magic number
       if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) 
         {
           int prevticket = OrderTicket();
           // long position is opened
           if(OrderType() == OP_BUY) 
             {
               // check profit 
               if(Bid > (OrderStopLoss() + (sl * 2  + spread) * Point)) 
                 {               
                   if(perceptron() < 0) 
                     { 
                       // reverse
                       ticket = OrderSend(Symbol(), OP_SELL, lots * 2, Bid, 3, 
                                          Ask + sl * Point, 0, "AI", MagicNumber, 
                                          0, Red); 
                       Sleep(30000);
                       if(ticket < 0) 
                         {
                           prevtime = Time[1];
                         } 
                       else 
                         {
                           OrderCloseBy(ticket, prevticket, Blue);   
                         }
                     } 
                   else 
                     { 
                       // trailing stop
                       if(!OrderModify(OrderTicket(), OrderOpenPrice(), 
                          Bid - sl * Point, 0, 0, Blue)) 
                         {
                           Sleep(30000);
                           prevtime = Time[1];
                         }
                     }
                 }  
               // short position is opened
             } 
           else 
             {
               // check profit 
               if(Ask < (OrderStopLoss() - (sl * 2 + spread) * Point)) 
                 {
                   if(perceptron() > 0) 
                     { 
                       // reverse
                       ticket = OrderSend(Symbol(), OP_BUY, lots * 2, Ask, 3, 
                                          Bid - sl * Point, 0, "AI", MagicNumber,
                                          0, Blue); 
                       Sleep(30000);
                       if(ticket < 0) 
                         {
                           prevtime = Time[1];
                         } 
                       else 
                         {
                           OrderCloseBy(ticket, prevticket, Blue);   
                         }
                     } 
                   else 
                     { 
                       // trailing stop
                       if(!OrderModify(OrderTicket(), OrderOpenPrice(), 
                          Ask + sl * Point, 0, 0, Blue)) 
                         {
                           Sleep(30000);
                           prevtime = Time[1];
                         }  
                     }
                 }  
             }
           // exit
           return(0);
         }
     }
   // check for long or short position possibility
   if(perceptron() > 0) 
     { 
       //long
       ticket = OrderSend(Symbol(), OP_BUY, lots, Ask, 3, Bid - sl * Point, 0, 
                      "AI", MagicNumber, 0, Blue); 
       if(ticket < 0) 
         {
           Sleep(30000);
           prevtime = Time[1];
         }
     } 
   else 
     { 
       // short
       ticket = OrderSend(Symbol(), OP_SELL, lots, Bid, 3, Ask + sl * Point, 0, 
                      "AI", MagicNumber, 0, Red); 
       if(ticket < 0) 
         {
           Sleep(30000);
           prevtime = Time[1];
         }
     }
//--- exit
   return(0);
  }
//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   double a1 = iAC(Symbol(), 0, 0);
   double a2 = iAC(Symbol(), 0, 7);
   double a3 = iAC(Symbol(), 0, 14);
   double a4 = iAC(Symbol(), 0, 21);
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }
//+------------------------------------------------------------------+

Agora, nós simplesmente devemos selecionar os coeficientes de pesagem da equação linear de plano de separação para a rede neural. Vamos executar um provador de estratégias pressionando as teclas Ctrl + R:

Na aba de "configurações" nós selecionamos um modelo de mercado de método de emulação rápido somente para preços de abertura (sinais no nosso EA são lidos com base nas barras formadas). Nós marcamos as opções "recalcular" e "otimização" e depois clicamos em "propriedades do expert".

Aba de testes:

Nós escolhemos o depósito inicial de $3.000, e a otimização e o teste serão realizados com base em posições longas e curtas. O índice de otimização principal será considerado como o equilíbrio máximo durante o período de teste. Além disso, uma algoritmo genético deve ser incluído de modo a acelerar o processo de otimização.

Aba de entradas:

Nós iremos marcar os parâmetros de entrada selecionados por um algoritmo genético: x1, x2, x3 e x4 para os fatores de pesagem da rede neural, além disso, nós teremos que escolher o valor aceitável de sl - nível de stop loss. O número de lotes será definido como 1 e um "magic number" ("número mágico") irá permanecer como padrão.

Aba de otimização:

Para acelerar o processo de otimização, o levantamento máximo será configurado no nível de 35%. Para esclarecer o nível aceitável de um levantamento máximo é necessário primeiramente iniciar o processo de otimização sem nenhuma restrição. Apenas depois da obtenção dos resultados da primeira otimização torna-se necessário tomar o seu valor, arredondá-lo, e, depois de interromper o processo, inserir os limites de negociação. O processo de otimização reiniciado será executado com uma velocidade consideravelmente maior.

Clique OK para fechar a aba de configurações do expert. Agora nós podemos iniciar o processo de otimização pressionando o botão "Start". Também é aconselhável desativar a saída de resultados inúteis:

Durante o processo de otimização, caso o computador seja fraco e possua pouca memória RAM, é aconselhável limpar todos os diários periodicamente.

No Pentium III, todo o processo de otimização leva um pouco mais do que uma hora. O tempo depende do instrumento financeiro.

Agora, tudo o que resta é clicar o botão direito localizado na linha superior e, selecionando "inserir parâmetros de entrada" no menu pop-up, começar os testes nos dados de histórico.

Não há dúvida de que os resultados irão corresponder aos dados emitidos pelo otimizador.

Nós gostaríamos de publicar estes resultados aqui. No entanto, qualquer pessoa que estivesse em dúvida poderia afirmar que as informações poderiam simplesmente estar sendo adequadas aos dados do histórico. E como a estratégia obtida irá se comportar em caso de alteração do mercado? O quão relevante são os padrões obtidos em relação ao últimos períodos no futuro? Vamos considerar, por exemplo, a participação no campeonato de negociações automatizadas, onde as regras proíbem a realização de quaisquer correções aos parâmetros de entrada até o fim do campeonato.

Vamos tentar realizar um experimento. Para fazer isso, a rede neural será treinada em relação aos dados do histórico, tomados com uma amostra representativa, mas irá excluir os dados dos últimos três meses. Para este propósito nós usaremos uma limitação de período e testes de otimização através de funções de datas integradas no provador.

Vamos iniciar o processo de otimização. Nós iremos obter os resultados relativos aos parâmetros de entrada: x1 = 146, x2 = 25, x3 = 154, x4 = 121, sl = 45.

Em seguida, vamos verificar a estratégia obtida para o período durante o qual ela não havia sido otimizada e não era capaz fazer nenhuma suposição, isto é, três meses depois do período de otimização. Nós precisamos simplesmente desmarcar a opção "data de uso" e observar como a estratégia irá gerenciar as negociações:

O resultado fala por si só. A estratégia eventualmente obteve lucro. Certamente, em comparação com o lucro observado no campeonato em si, o rendimento foi bastante modesto. No entanto, devemos ter em mente que o capital e o gerenciamento de risco não são realizados pelo EA, pois ele somente fornece posições com uma quantidade fixa de lotes. Além disso, a otimização excessiva deve ser realizada em negociações reais, e com uma frequência muito maior do que uma vez a cada três meses.

Conclusão

Como nós devemos tratar as conclusões relativas a redes neurais feitas por D. Katz e D. McCormick em seu livro "The Encyclopedia of Trading Strategies" (A enciclopédia de estratégias de negociação)?

Em primeiro lugar, opere a partir do princípio: confie, mas verifique. As assim chamadas atividades de D. Katz e D. McCormick são construídas de modo a evitar a possibilidade deste teste. Em outras palavras, esta é uma abordagem não científica que exclui a possibilidade de reprodução. É compreensível que algumas pessoas estejam envolvidas no negócio editorial, e não no financeiro. Sua tarefa é vender o artigo, independentemente do conteúdo. Para esclarecer isso, basta compreender o caminho seguido por eles para criar o papel de sucata em estilo "500 conselhos inúteis" intercalados com figuras. Vamos tentar compreender.

• A definição do problema por D. Katz e D. McCormick foi criar um indicador não existente ou, para ser mais preciso, um %K lento inverso estocástico, que de fato age como uma máquina do tempo e tira informação de 10 linhas à frente e baseando-se nisso fornece leituras para 10 linhas para trás. Caso eu tivesse este indicador, Bill Gates e George Soros provavelmente não seriam páreo para mim;
• O próximo passo seria tomar alguns dados e usar habilidades telepáticas para obter as previsões estocásticas. Já definiram a tarefa de aproximação, isto é, saber os argumentos da função, para obter o seu valor. A aproximação, é, de fato, a adaptação, que Katz e McCormick apontam diretamente nas páginas de seu artigo;
• Não importa muito a maneira pela qual a aproximação foi alcançada, porque é mais importante que as redes neurais não sejam adequadas a este objetivo. Seria muito mais fácil completar a mesma tarefa, por exemplo, por meio de um análise espectral;
• Redes neurais estão atuando ainda pior com tarefas de interpolação e extrapolação, e se tomarmos informação de uma amostra representativa, então a extrapolação é aplicável, em vez de uma adesão a uma certa classe.
• Katz e McCormick, tendo um tipo de aproximação estocástica telepática cuja realização incluía erros óbvios, foram adiante e, com base nas leituras deste dispositivo errôneo, criaram uma "estratégia de negociações", que também precisava interpretar as leituras de um aparelho defeituoso, a saber, caso %K ultrapasse certos limites, então é provável que os preços tenham alcançado valores máximos ou mínimos. Ademais, este "cordão" estava preso a um sistema mecânico de negociações e, tendo recebido suas estatísticas e conclusões apressadas, os autores propuseram apresentá-los aos seus leitores.

Os resultados foram instantâneos. Em amostras representativas houve um certo progresso, no entanto, fora deste grupo, a oportunidade de se obter lucro foi limitada, e apenas perdas foram registradas.

No entanto, não foram somente Katz e McCormick que fracassaram nos experimentos ligados a redes neurais. O primeiro projeto de rede neural chamado "Perceptron" também não justificou as expectativas que foram colocadas sobre ele. É o primeiro passo problemático, exatamente o que aconteceu com Frankenstein. Análises objetivas posteriores sobre as capacidades e desvantagens da rede neural foram conduzidas por M. Minsky e S. Papert [1]. Portanto, antes de tentar encontrar uma solução para alguns problemas com redes neurais, tente não cometer os mesmos erros duas vezes:

1. A definição de problema não deve conter projeções futuras telepáticas para conseguir uma resposta precisa para a questão de quando e quanto. A solução deve se restringir a forma de uma identificação de decisão baseada nos sinais atuais em uma forma de separação em poucas situações potenciais exclusivas. Por exemplo, caso você tenha uma tarefa relacionada ao clima, não tente descobrir exatamente se vai começar a chover, ou a quantidade de chuva por milímetros. Limite a previsão de uma situação em potencial para uma mudança direcionada a um tempo de sol ou chuvoso.
2. Corte tudo o que é desnecessário com a navalha de Occam. Alguns experimentadores acreditam que, quanto mais camadas de rede neural houver e quanto mais complexas forem suas funções de ativação, melhores serão os resultados. Dessa maneira você pode traçar uma linha de separação mais precisa separando os objetos identificados baseando-se em suas características. Ninguém irá discordar disso. Mas por quê? Ademais, esse tipo de abordagem equivale a construir castelos de areia. Caso a borda tivesse uma forma definida que permaneceu constante no tempo e independente de outras circunstâncias, então a complexidade de maximizar um refinamento faria sentido. Mas a maioria dos problemas resolvidos com a ajuda das redes neurais não pertence a essa categoria. Instrumentos financeiros também não ficam imóveis. Por conseguinte, a rede neural mais simples com um baixo número de entradas e uma camada única pode ser mais aceitável do que uma construção mais complexa com uma eficiência descartável.

E isto é tudo que eu gostaria de dizer neste artigo.

Referências

1. Minsky, M. e Papert, S. (1969) PERCEPTRON; "an Introduction to Computational Geometry" ("Uma introdução à geometria computacional"), MIT Press, Massachussetts