Aprofundando na "memória" do mercado através da diferenciação e do análise de entropia

Maxim Dmitrievsky | 7 agosto, 2019

Motivação para aplicar a abordagem e uma breve pré-história

Uma característica comum dos gráficos de preços é a presença de não estacionariedade, isto é, a disponibilidade de um longo histórico de níveis de preços que deslocam o preço médio ao longo do tempo. Para realizar uma análise estatística, os pesquisadores precisam trabalhar com incrementos de preços (ou com logaritmos de incrementos), com mudanças nos rendimentos ou na volatilidade. Essas transformações tornam a série temporal estacionária, removendo toda a memória das sequências de preços. Apesar do fato de que a estacionariedade é uma propriedade necessária para interferência estatística, nem sempre é necessário excluir toda a memória, pois é a base para as propriedades preditivas dos modelos. Por exemplo, os modelos estacionários devem conter uma certa quantidade de memória para avaliar até que ponto o preço se afasta de seu valor esperado.

O problema é que os incrementos de preço são estacionários, mas não contêm memória do passado, enquanto a série de preços contém a quantidade total de memória disponível, mas não é estacionária. Surge a pergunta: é necessário diferenciar a série temporal para que ela se torne estacionária e, ao mesmo tempo, contenha a quantidade máxima possível de memória. Assim, gostaríamos de generalizar o conceito de incrementos de preço para considerar séries estacionárias em que nem toda a memória é apagada. Nesse sentido, os incrementos de preço não são uma solução ideal para a transformação de preços, em comparação com outros métodos.

Assim, será introduzido o conceito de diferenciação fracionária. Existe uma ampla faixa de possibilidades entre dois extremos: entre diferenciação única e zero. Por um lado, preços totalmente diferenciados e, por outro, não diferenciados.

O campo para aplicar a diferenciação fracionária é bastante amplo. Por exemplo, os algoritmos de aprendizado de máquina geralmente recebem uma série diferenciada na entrada. O problema é que é necessário derivar novos dados de acordo com o histórico existente, para que o modelo de aprendizado de máquina possa reconhecê-los. No caso de uma série não estacionária, os novos dados podem estar fora do intervalo conhecido de valores, o que causará operação incorreta do modelo.

Diferenciação fracionária

//+------------------------------------------------------------------+
void get_weight_ffd(double d, double thres, int lim, double &w[]) {
    ArrayResize(w,1); 
    ArrayInitialize(w,1.0);
    ArraySetAsSeries(w,true);
    
    int k = 1;
    int ctr = 0;
    double w_ = 0;
    while (ctr != lim - 1) {
        w_ = -w[ctr] / k * (d - k + 1);
        if (MathAbs(w_) < thres) break;  
        ArrayResize(w,ArraySize(w)+1); 
        w[ctr+1] = w_;      
        k += 1;
        ctr += 1;
    }
}
//+------------------------------------------------------------------+
void frac_diff_ffd(double &x[], double d, double thres, double &output[]) {
   double w[];
   get_weight_ffd(d, thres, ArraySize(x), w);

   int width = ArraySize(w) - 1;
   
   ArrayResize(output, width);
   ArrayInitialize(output,0.0);
   ArraySetAsSeries(output,true);
   ArraySetAsSeries(x,true);
   ArraySetAsSeries(w,true);
   
   int o = 0;
   for(int i=width;i<ArraySize(x);i++) {
      ArrayResize(output,ArraySize(output)+1);
      
      for(int l=0;l<ArraySize(w);l++)       
         output[o] += w[l]*x[i-width+l];      
      o++; } 
   ArrayResize(output,ArraySize(output)-width);
}

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   for(double i=0.05; i<1.0; plotFFD(i+=0.05,1e-5))     
  }
//+------------------------------------------------------------------+
void plotFFD(double fd, double thresh) {
   double prarr[], out[];
   CopyClose(_Symbol, 0, 0, hist, prarr);
   
   for(int i=0; i < ArraySize(prarr); i++)
      prarr[i] = log(prarr[i]);
    
   frac_diff_ffd(prarr, fd, thresh, out);
   GraphPlot(out,1); Sleep(500);
}

frac_diff_ffd(weights, price, ind_buffer, hist_display, prev_calculated !=0);  

double sample_entropy(double &data[], int m, double r, int N, double sd)
{
  int Cm = 0, Cm1 = 0;
  double err = 0.0, sum = 0.0;
  
  err = sd * r;
  
  for (int i = 0; i < N - (m + 1) + 1; i++) {
    for (int j = i + 1; j < N - (m + 1) + 1; j++) {      
      bool eq = true;
      //m - length series
      for (int k = 0; k < m; k++) {
        if (MathAbs(data[i+k] - data[j+k]) > err) {
          eq = false;
          break;
        }
      }
      if (eq) Cm++;
      
      //m+1 - length series
      int k = m;
      if (eq && MathAbs(data[i+k] - data[j+k]) <= err)
        Cm1++;
    }
  }
  
  if (Cm > 0 && Cm1 > 0)
    return log((double)Cm / (double)Cm1);
  else
    return 0.0; 
}

// Calculate the cross-sample entropy of 2 signals
// u : signal 1
// v : signal 2
// m : length of the patterns that compared to each other
// r : tolerance
// return the cross-sample entropy value
double cross_SampEn(double &u[], double &v[], int m, double r) {
    double B = 0.0;
    double A = 0.0;
    if (ArraySize(u) != ArraySize(v))
        Print("Error : lenght of u different than lenght of v");
    int N = ArraySize(u);
    
    for(int i=0;i<(N-m);i++)
      {
         for(int j=0;j<(N-m);j++)
           {   
               double ins[]; ArrayResize(ins, m); double ins2[]; ArrayResize(ins2, m);
               ArrayCopy(ins, u, 0, i, m); ArrayCopy(ins2, v, 0, j, m);
               B += cross_match(ins, ins2, m, r) / (N - m);
               ArrayResize(ins, m+1); ArrayResize(ins2, m+1);
               ArrayCopy(ins, u, 0, i, m + 1); ArrayCopy(ins2, v, 0, j, m +1);
               A += cross_match(ins, ins2, m + 1, r) / (N - m);
           }
      }
    
    B /= N - m;
    A /= N - m;
    return -log(A / B);
}
// calculation of the matching number
// it use in the cross-sample entropy calculation
double cross_match(double &signal1[], double &signal2[], int m, double r) {
    // return 0 if not match and 1 if match
    double darr[];
    for(int i=0; i<m; i++)
      {
         double ins[1]; ins[0] = MathAbs(signal1[i] - signal2[i]);
         ArrayInsert(darr, ins, 0, 0, 1);
      }    
    if(darr[ArrayMaximum(darr)] <= r)  return 1.0; else return 0.0;
}

input bool   entropy_eval = true; // exibir leituras de entropia ou incremento
input double diff_degree = 0.3;   // grau de diferenciação da série temporal
input double treshhold = 1e-5;    // limite para cortar pesos em excesso (pode ser deixado por padrão)
input int    hist_display = 5000; // profundidade do histórico exibido
input int    entropy_window = 50; // janela deslizante para avaliar a entropia do processo

Fig.4. Curva logística (sigmóide). Fonte: Wikipedia.

Não descreveremos o algoritmo de regressão logística em detalhes, já que é amplamente conhecido, mas usaremos a classe CLogitModel pronta da biblioteca Alglib.

//+------------------------------------------------------------------+
//|Auto optimizer class                                              |
//+------------------------------------------------------------------+
class CAuto_optimizer
  {
private:
// Logit regression model |||||||||||||||
   CMatrixDouble     LRPM;
   CLogitModel       Lmodel;
   CLogitModelShell  Lshell; 
   CMNLReport        Lrep;
   int               Linfo;
   double            Lout[];
//||||||||||||||||||||||||||||||||||||||||
   int               number_of_samples, relearn_timout, relearnCounter;
   virtual void      virtual_optimizer();
   double            lVector[][2];
   int               hnd, hnd1;
   
public:
                     CAuto_optimizer(int number_of_sampleS, int relearn_timeouT, double diff_degree, int entropy_window) {                                      
                             this.number_of_samples = number_of_sampleS;
                             this.relearn_timout = relearn_timeouT;
                             relearnCounter = 0;
                             LRPM.Resize(this.number_of_samples, 5);
                             hnd = iCustom(NULL, 0, "fractional entropy", false, diff_degree, 1e-05, number_of_sampleS, entropy_window);
                             hnd1 = iCustom(NULL, 0, "fractional entropy", true, diff_degree, 1e-05, number_of_sampleS, entropy_window);
                            }
                     ~CAuto_optimizer() {};
   double            getTradeSignal();
  };

Aqui, na seção //Logit regression model// é criada uma matriz para os valores x e y, ela registra o Lmodel e suas classes auxiliares. A matriz Lout[], após o treinamento, o modelo assumirá a probabilidade de atribuir o sinal a uma determinada classe 0:1. 

O construtor, portanto, assume o tamanho da janela de aprendizado number_of_samples, o período após o qual o modelo será re-otimizado relearn_timout, e o grau de diferenciação fracionária para o indicador diff_degree, bem como uma janela para calcular a entropia entropy_window.

Vamos nos debruçar sobre o método virtual_optimizer():

//+------------------------------------------------------------------+
//|Virtual tester                                                    |
//+------------------------------------------------------------------+
CAuto_optimizer::virtual_optimizer(void) {
   double indarr[], indarr2[];
   CopyBuffer(hnd, 0, 1, this.number_of_samples, indarr);
   CopyBuffer(hnd1, 0, 1, this.number_of_samples, indarr2);
   ArraySetAsSeries(indarr, true); ArraySetAsSeries(indarr2, true);
   
   for(int s=this.number_of_samples-1;s>=0;s--) {
      LRPM[s].Set(0, indarr[s]);
      LRPM[s].Set(1, indarr2[s]);
      LRPM[s].Set(2, s);
     
      if(iClose(NULL, 0, s) > iClose(NULL, 0, s+1)) { 
         LRPM[s].Set(3, 0.0);
         LRPM[s].Set(4, 1.0);
      }
      else {
         LRPM[s].Set(3, 1.0);
         LRPM[s].Set(4, 0.0);
      }  
    }
     
    CLogit::MNLTrainH(LRPM, LRPM.Size(), 3, 2, Linfo, Lmodel, Lrep);
    
    double profit[], out[], prof[1];
    ArrayResize(profit,1); ArraySetAsSeries(profit, true); profit[0] = 0.0;
    int pos = 0, openpr = 0;
    
    for(int s=this.number_of_samples-1;s>=0;s--) {
      double in[3];
      in[0] = indarr[s]; in[1] = indarr2[s]; in[2] = s;
      CLogit::MNLProcess(Lmodel, in, out);
      
      if(out[0] > 0.5 && !pos) {pos = 1; openpr = s;};
      if(out[0] < 0.5 && !pos) {pos = -1; openpr = s;};
      
      if(out[0] > 0.5 && pos == 1) continue;
      if(out[0] < 0.5 && pos == -1) continue;
      
      if(out[0] > 0.5 && pos == -1) {
         prof[0] = profit[0] + (iClose(NULL, 0, openpr) - iClose(NULL, 0, s)); 
         ArrayInsert(profit, prof, 0, 0, 1); pos = 0; }
         
      if(out[0] < 0.5 && pos == 1) {
         prof[0] = profit[0] + (iClose(NULL, 0, s) - iClose(NULL, 0, openpr)); 
         ArrayInsert(profit, prof, 0, 0, 1); pos = 0; }
    }
 GraphPlot(profit);
}

É óbvio que é muito simples e, portanto, rápido. No ciclo, a primeira coluna da matriz LRPM é preenchida com valores de indicador + valor de tendência linear (foi decidido adicioná-lo). Depois, no próximo ciclo, o preço de fechamento atual é comparado com o anterior para esclarecer a probabilidade de uma transação: comprar ou vender. Se o valor atual é maior do que o anterior, significa que houve um sinal para comprar, caso contrário, para vender. Consequentemente, as colunas a seguir são preenchidas com os valores 0 e 1.

Assim, este é um testador muito simples, que não pretende a seleção ideal de sinais, mas simplesmente os tira de cada nova barra. Ele pode ser melhorado sobrecarregando o método, o que está além do escopo deste artigo.

Depois disso, a regressão logística é treinada usando o método MNLTrain(), que assume a matriz, seu tamanho, o número de variáveis x (temos apenas uma variável passada para cada caso), um objeto da classe Lmodel para armazenar o modelo treinado nele e classes auxiliares.

Depois de treinar o modelo, ele é testado e exibido na janela do otimizador como um gráfico de saldo. Isso é feito para maior clareza, para ver como o modelo foi treinado com base num conjunto de aprendizado e não é analisado por algoritmos.

O otimizador virtual é chamado pelo seguinte método:

//+------------------------------------------------------------------+
//|Get trade signal                                                  |
//+------------------------------------------------------------------+
double CAuto_optimizer::getTradeSignal() {
   if(this.relearnCounter==0)
      this.virtual_optimizer();
   relearnCounter++;
   if(this.relearnCounter>=this.relearn_timout) this.relearnCounter=0;
   
   double in[], in1[];
   CopyBuffer(hnd, 0, 0, 1, in); CopyBuffer(hnd1, 0, 0, 1, in1);
   double inn[3]; inn[0] = in[0]; inn[1] = in1[0]; inn[2] = relearnCounter + this.number_of_samples - 1;         
   CLogit::MNLProcess(Lmodel, inn, Lout);
   return Lout[0];
}

Ele verifica o número de barras que passaram desde o último aprendizado. Se exceder o limite definido nas configurações, o modelo será treinado novamente. Depois disso, é copiado o último valor dos indicadores e das unidades de tempo que passaram desde o último treinamento e é alimentado no modelo através do método MNLProcess(), que retorna a associação a uma classe 0:1 específica, o que é um sinal de negociação.

Criando um Expert Advisor para testar o desempenho da biblioteca

Resta inserir a biblioteca num EA e especificar o manipulador de sinais:

#include <MT4Orders.mqh>
#include <Math\Stat\Math.mqh>
#include <Trade\AccountInfo.mqh>
#include <Auto optimizer.mqh>

input int       History_depth = 1000;
input double    FracDiff = 0.5;
input int       Entropy_window = 50;
input int       Recalc_period = 100;
sinput double   MaximumRisk=0.01;
sinput double   CustomLot=0;
input int       Stop_loss = 500;           //Stop loss, positions protection
input int       BreakEven = 300;           //Break even
sinput int      OrderMagic=666;

static datetime last_time=0;

CAuto_optimizer *optimizer = new CAuto_optimizer(History_depth, Recalc_period, FracDiff, Entropy_window);
double sig1;

As configurações do EA são muito simples: tamanho da janela deslizante History_depth, ou seja, o número de exemplos de aprendizado para o otimizador automático. Grau de diferenciação Fracdiff e o número de barras que chegaram Recalc_period, após o qual o modelo será retreinado. Também adicionada configuração Entropy_window permitindo ajustar a janela para calcular a entropia.

A função restante recebe um sinal do modelo treinado e realiza operações de negociação:

void placeOrders(){
   if(countOrders(0)!=0 || countOrders(1)!=0)   {
      for(int b=OrdersTotal()-1; b>=0; b--)
         if(OrderSelect(b,SELECT_BY_POS)==true) {
          if(OrderType()==0 && sig1 < 0.5) if(OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,Red)) {};
          if(OrderType()==1 && sig1 > 0.5) if(OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,Red)) {};
      }
    }
   
   if(countOrders(0)!=0 || countOrders(1)!=0) return;
   if(sig1 > 0.5 && (OrderSend(Symbol(),OP_BUY,lotsOptimized(),SymbolInfoDouble(_Symbol,SYMBOL_ASK),0,0,0,NULL,OrderMagic,INT_MIN)>0)) { return; }
   if(sig1 < 0.5 && (OrderSend(Symbol(),OP_SELL,lotsOptimized(),SymbolInfoDouble(_Symbol,SYMBOL_BID),0,0,0,NULL,OrderMagic,INT_MIN)>0)) {}
  }

 Se a probabilidade de compra for superior a 0,5, este é um sinal para comprar e/ou um sinal para fechar as posições para venda. e vice versa.

Testando um EA otimizado automaticamente e conclusões

Passamos para o mais interessante, para os testes. 

O EA foi iniciado com os hiperparâmetros indicados sem otimização genética, ou seja, quase ao acaso, no par EURUSD durante 15 minutos, a preços de abertura.

Figura 5. Configurações do EA testado

Fig. 6. Resultado do teste com configurações especificadas

Fig. 7. Exibindo os resultados do testador virtual com base num conjunto de treinamento

Nesta área, esta implementação mostrou um crescimento bastante constante, o que sugere que, no geral, a abordagem pode ser interessante para estudos posteriores.

Como resultado, tentamos matar três coelhos com uma cajadada:

• entendimos o conceito de "memória" do mercado;
• aprendimos a avaliá-lo em termos de entropia;
• e escrevemos um EA otimizado automaticamente.