Comprendemos la "memoria" del mercado usando la diferenciación y el análisis entrópico

Maxim Dmitrievsky | 5 agosto, 2019

Motivación de la aplicación del enfoque y prehistoria breve

La característica común de los diagramas de precios es la existencia de no estacionariedad, o sea, de una larga historia de los niveles de precios que desplazan el precio medio en el tiempo. Para realizar el análisis estadístico, los analistas tienen que trabajar con incrementos de los precios (o logaritmos de incrementos), cambios de la rentabilidad o de la volatilidad. Estas transformaciones hacen que la serie temporal sea estacionaria, eliminando toda la memoria de las secuencias de precios. A pesar de que la estacionariedad es una propiedad obligatoria para las conclusiones estadísticas, no siempre es necesario eliminar la memoria entera, porque es la base para las propiedades predictoras de los modelos. Por ejemplo, los modelos de equilibrio (estacionarios) tienen que contener un poco de memoria para evaluar hasta que grado el precio se ha alejado de su valor esperado.

El problema es que los incrementos de los precios son estacionarios, pero no contienen la memoria sobre el pasado, mientras que la serie de precios contiene el volumen completo de la memoria disponible pero no es estacionario. Surge la pregunta, ¿cómo es necesario diferenciar la serie temporal para que sea estacionario y, al mismo tiempo, contenga la memoria máxima posible? Por tanto, nos gustaría generalizar el concepto de los incrementos de precios para la consideración de las series estacionarias en las que no se borra toda la memoria. En este caso, los incrementos de precios no representan una solución óptima para la transformación de los precios, entre otros métodos disponibles.

De esta manera, vamos a introducir el concepto de la diferenciación fraccionada. Existe un amplio rango de posibilidades entre dos extremos: diferenciación unitaria y diferenciación cero. Los precios diferenciados completamente están por un lado, los no diferenciados están por otro.

El área de la aplicación de la diferenciación fraccionada es bastante amplia. Por ejemplo, los algoritmos del aprendizaje automático normalmente reciben una serie diferencial en la entrada. El problema es que es necesario mostrar los datos nuevos de acuerdo con la historia existente para que el modelo del aprendizaje automático pueda reconocerlos. En caso de una serie no estacionaria, los datos nuevos pueden estar fuera del rango de valores conocido, lo que llevará a un funcionamiento incorrecto del modelo.

Concepto de la diferenciación fraccionada

//+------------------------------------------------------------------+
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; // mostrar los valores de entropía o incremento
input double diff_degree = 0.3;   // grado de diferenciación de serie temporal
input double treshhold = 1e-5;    // umbral para cortar los pesos sobrantes (se puede establecer valores predefinidos)
input int    hist_display = 5000; // profundidad de historia visualizada
input int    entropy_window = 50; // ventana para estimar entropía del proceso

Fig. 4. Curva logística (sigmoidea). Fuente: Wikipedia.

No vamos a describir en detalle el algoritmo de la regresión logística, ya que es ampliamente conocido. Usaremos la clase hecha CLogitModel de la 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();
  };

Aquí, en la sección //Logit regression model// se crea una matriz para los valores x y y, el modelo logístico Lmodel y sus clases auxiliares. Después de entrenar el modelo, el array Lout[] va a recibir las probabilidades de la pertenencia de la señal a una de las clases, 0:1. 

El constructor recibe el tamaño de la ventana del aprendizaje number_of_samples, el período pasado el cual el modelo será reoptimizado relearn_timout, y el grado del diferenciación diferenciada para el indicador diff_degree, así como, la ventana para calcular la entropía entropy_window.

Hablaremos sobre el método virtual_optimizer() con más detalle:

//+------------------------------------------------------------------+
//|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);
}

Obviamente, es muy simple y, por eso, es rápido. La primera columna de la matriz LRPM se rellena cíclicamente con valores del indicador y valores de la tendencia lineal (ha sido añadido). En el siguiente ciclo, el precio de cierre actual se compara con el precio anterior para precisar la probabilidad de la transacción (compra o venta). Si el valor actual es más grande que el anterior, entonces, se trataba de una señal de compra, de lo contrario, era de venta. Por tanto, las siguientes columnas se rellenan con valores 0 y 1.

Así, es un Simulador muy simple, que no pretende a una selección óptima de señales, sino las lee en cada barra nueva. El simulador puede ser mejorado a través del método de sobrecarga, lo cual sale fuera de la consideración de este artículo.

Después de eso, se realza el entrenamiento de la regresión logística usando el método MNLTrain(), que recibe la matriz, su tamaño, el número de variables x (nosotros pasamos sólo una variable para cada caso específico), el objeto de la clase Lmodel para guardar el modelo entrenado, y las clases auxiliares.

Después del entrenamiento, el modelo se testea y se visualiza en la ventana del optimizador como gráfico del balance. Eso se hace con fines ilustrativos, para ver cómo el modelo ha sido entrenado en la muestra de aprendizaje, pero no se analiza desde el punto de vista algorítmico.

El optimizador virtual se invoca del siguiente 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];
}

Él comprueba el número de las barras pasadas desde el último entrenamiento. Si excede el límite especificado en los ajustes, el modelo vuelve a entrenarse. Después de eso, se copia el último valor de los indicadores y unidades de tiempo transcurridas después del último entrenamiento, y se pasa al modelo a través del método MNLProcess() que devuelve la pertinencia a una determinada clase 0:1, lo cual representa una señal comercial.

Creando el EA para comprobar el trabajo de la biblioteca

Ahora, necesitamos conectar la biblioteca al EA y añadir el manejador de señales:

#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;

Los ajustes del EA son muy simples e incluyen el tamaño de la ventana History_depth, o sea, el número de los ejemplos de entrenamiento para el optimizador automático. Además, es el grado de diferenciación FracDiff y el número de barras recibidas Recalc_period, después del cual el modelo será reentrenado. Además, hemos añadido el ajuste Entropy_window que permite ajustar la ventana para calcular la entropía.

La última función recibe una señal del modelo entrenado y realiza operaciones comerciales:

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)) {}
  }

 Si la probabilidad de la compra es más de 0,5, es la señal de compra y/o la señal para cerrar una posición sell. Y viceversa.

Testeando el EA de optimización automática y conclusiones

Vamos a proceder a lo más interesante, es decir al testeo. 

El EA fue iniciado con los hiperparámetros especificados sin optimización genética, es decir, prácticamente, a ojo, usando el par EURUSD, en M15, a base de los precios de apertura.

Fig. 5. Ajustes del EA

Fig. 6. Resultado del testeo con parámetros especificados

Fig. 7. Visualización de los resultados del Simulador virtual en la muestra de aprendizaje

En este intervalo, la implementación ha mostrado un crecimiento bastante estable. Eso quiere decir que el enfoque puede ser interesante para el futuro análisis.

Como resultado, hemos intentado matar tres pájaros de un tiro:

• hemos entendido la «memoria» de mercado,
• hemos aprendido estimarla en términos de la entropía,
• y desarrollar el EA auto-optimizable.