Regresión neta elástica mediante descenso de coordenadas en MQL5

Introducción

La regresión neta elástica combina las mejores características de las técnicas de cresta y lazo para construir modelos lineales generales. Su uso nos permitirá minimizar una de las principales desventajas de la regresión: el sobreajuste. Esto resulta especialmente cierto para el desarrollo de una estrategia comercial, pues sabemos que la razón más común del mal desempeño o del fracaso de una estrategia es que se toma el ruido como modelo. Este artículo presentaremos una implementación de la regresión neta elástica que utilizará el método de optimización mediante el descenso de coordenadas (coordinate descent) en MQL5 puro. Hacia el final del artículo, demostraremos la aplicación práctica de este método mediante el desarrollo de una estrategia de pronóstico simple basada en una media móvil.

Regularización

Al construir modelos predictivos, el objetivo consistirá en crear una muestra que pueda reconocer algún patrón único que usar luego en el mundo real. Para hacer esto de manera efectiva, deberemos asegurarnos de que el modelo "aprenda" los patrones correspondientes de los datos de entrenamiento. Obviamente, resulta más sencillo decirlo que hacerlo. Por lo común, el modelo recibe información innecesaria (ruido), lo cual finalmente degradará su rendimiento en el uso. La regularización es un proceso que se usa para minimizar los efectos del sobreajuste.

El método Lasso (LASSO, Least Absolute Shrinkage and Selection Operator, operador de selección y contracción mínima absoluta) ayuda a reducir el desplazamiento o sesgo de entrenamiento al suprimir los predictores redundantes cuando el modelo está definido por demasiadas variables optimizadas. Esto simplificará el modelo.

En la regresión de crestas, los coeficientes de la ecuación de regresión se minimizan para alejarlos del óptimo. Esto ayudará a generalizar el modelo preservando todos los predictores.

Tanto la regresión de lazo como la de cresta se distinguen en la naturaleza del término de penalización (penalty term) usado. El término de penalización de la regresión neta elástica supone una combinación del valor absoluto y el cuadrado de los coeficientes ponderados por dos hiperparámetros: alfa y lambda.

Entonces alfa controlará el tipo de regularización. Cuando alfa sea cero, el término de penalización se reducirá a la norma l2. Cuando alfa sea 1, la función de penalización se convertirá en la norma l1. La especificación de alfa de 0 a 1 nos permitirá construir modelos lineales que, hasta cierto punto, combinarán las cualidades de la regresión de cresta y lazo según lo determinado por el hiperparámetro lambda, que controlará el grado de regularización.

Estos modelos pueden resultar útiles a la hora de desarrollar estrategias comerciales en las que aplicamos con frecuencia y a ciegas muchos predictores con la esperanza de encontrar alguna combinación que genere beneficios. Usando la regresión neta elástica, podremos minimizar el sobreajuste y también separar los indicadores inútiles de aquellos que tienen un potencial de pronóstico significativo. Y podemos hacerlo sin preocuparnos de cómo se relacionarán los indicadores entre sí. Suena casi demasiado bueno para ser verdad.

Descenso de coordenadas

El descenso de coordenadas (coordinate descent) es un método de optimización muy adecuado para la optimización de parámetros múltiples. Así, un problema complejo de optimización multidimensional se reducirá a un conjunto de problemas unidimensionales. Esto se logrará minimizando iterativamente cada dimensión individual de una función mientras se mantienen los valores estáticos de la función en otras dimensiones. Hay muchos recursos en línea que pueden ofrecer explicaciones más detalladas. Aquí nos interesa su aplicación al desarrollo de estrategias.
 
Para nuestros objetivos, el descenso de coordenadas se utilizará de dos maneras al implementar la regresión de red elástica. Primero lo utilizaremos para determinar la lambda óptima en función del alfa fijo especificado por el usuario. Una vez hecho esto, volveremos a llamar al método de optimización para operar sobre los coeficientes beta de la ecuación de regresión. Vamos a profundizar en el código para ver cómo se logra esto.

La clase CCoordinateDescent

//+------------------------------------------------------------------+
//| Coordinate Descent optimization class                            |
//+------------------------------------------------------------------+
class CCoordinateDescent
  {

private:
   bool              m_initialized;   // Was everything legal and allocs successful?
   double            m_beta[];        // Beta coefs (m_nvars of them)
   double            m_explained;     // Fraction of variance m_explained by model; computed by Train()
   double            m_xmeans[];      // Mean of each X predictor
   double            m_xscales[];     // And standard deviation
   double            m_ymean;         // Intercept (mean of Y)
   double            m_yscale;        // Standard deviation of Y

   int               m_nvars ;        // Number of variables
   int               m_observs ;      // Number of cases
   bool              m_covarupdates ; // Does user want (often faster) covariance update method?
   int               m_nlambda ;      // Reserve space for this many m_beta sets for saving by TrainLambda() (may be zero)
   double            m_lambdabeta_matrix[];  // Saved m_beta coefs (m_nlambda sets of m_nvars of them)
   double            m_lambdas[];     // Lambdas tested by TrainLambda()
   double            m_x_matrix[];           // Normalized (mean=0, std=1) X; m_observs by m_nvars
   double            m_y[];           // Normalized (mean=0, std=1) Y
   double            m_resid[];       // Residual
   double            m_xinner_matrix[];      // Nvars square inner product matrix if m_covarupdates
   double            m_yinner[];      // Nvars XY inner product vector if m_covarupdates

public:
                     //constructor
                     CCoordinateDescent(const int num_predictors, const int num_observations, const bool use_covariance_updates, const int num_lambdas_to_trial) ;
                     //desctructor
                    ~CCoordinateDescent(void) ;
                    
                     //Accessor methods for private properties
   double            GetYmean(void)                     { return m_ymean; }
   double            GetYscale(void)                    { return m_yscale;}
   double            GetExplainedVariance(void)         { return m_explained;}

   double            GetXmeansAt(const int index)       { if(index>=0 && index<ArraySize(m_xmeans)) return m_xmeans[index]; else return 0;}
   double            GetXscalesAt(const int index)      { if(index>=0 && index<ArraySize(m_xscales)) return m_xscales[index]; else return 0;}
   double            GetBetaAt(const int index)         { if(index>=0 && index<ArraySize(m_beta)) return m_beta[index]; else return 0;}
   double            GetLambdaAt(const int index)       { if(index>=0 && index<ArraySize(m_lambdas)) return m_lambdas[index]; else return 0;}
   double            GetLambdaBetaAt(const int index)   { if(index>=0 && index<ArraySize(m_lambdabeta_matrix)) return m_lambdabeta_matrix[index]; else return 0;}
   double            GetLambdaThreshold(const double alpha) ;
                     //Set model parameters and raw input data
   bool              SetData(const int begin, const int num_observations, double &xx_matrix[], double &yy[]) ;
                     //Training routines
   void              Train(const double alpha, const double lambda, const int maxits, const double convergence_criterion, const bool fast_test, const bool warm_start) ;
   void              TrainLambda(const double alpha, const int maxits, const double convergence_criterion, const bool fast_test, const double maxlambda, const bool print_steps) ;
  } ;

La clase CCordinateDescent se define en el archivo COordinateDescent.mqh. Su constructor es paramétrico y se usa para especificar características importantes del modelo; pero antes de profundizar en este tema, existen algunas cuestiones importantes que deben abordarse respecto al diseño específico de los datos que se utilizan.

La biblioteca que indicaremos no utilizará ningún tipo de datos único, como los tipos matriciales y vectoriales de MQL5. Esto se hace así para garantizar la compatibilidad con mql4. Como no hay forma de definir dinámicamente arrays multidimensionales, las matrices se representarán como arrays planos normales. Un ejemplo será la mejor manera de ilustrar el diseño.
 
Digamos que queremos definir una matriz con 4 filas y 3 columnas. Crearemos una matriz de tamaño 4 por 3, que nos dará 12. Los miembros de esta matriz se organizarán como aparecerían al usar el tipo de datos de matriz integrado. Es decir, en nuestro ejemplo, los miembros de la primera línea se especificarán primero, luego se indicarán los de la segunda y así sucesivamente. El siguiente fragmento de código ilustra la creación de una matriz de 4 por 3 donde cada valor de la columna es el mismo.

int rows=4,
       columns=3;

   double our_matrix[];

   ArrayResize(our_matrix,rows*columns);

   /*
     Creating matrix with columns of 1s,2s,3s
   */

   for(int i = 0; i<rows; i++)
      for(int j=0; j<columns; j++)
         our_matrix[i*columns+j]=j+1;

   ArrayPrint(our_matrix);

Muestra de ArrayPrint.

KP 0  13:01:32.445   Construct(GBPUSD,D1)   1.00000 2.00000 3.00000 1.00000 2.00000 3.00000 1.00000 2.00000 3.00000 1.00000 2.00000 3.00000 

Al recorrer la matriz de forma matricial, tenemos el índice de fila * el número de columnas + el índice de columna. Todos los casos en los que se requieren dichas construcciones de matriz, se indicarán con el sufijo _matrix aplicado al nombre de la variable de clase o al nombre del parámetro de función.

El uso de esta construcción implicará que al pasar matrices a funciones, se deberán reservar varios parámetros de función para especificar las dimensiones de una matriz en particular. Estoy seguro de que todo esto quedará más claro cuando comencemos a usar la clase hacia el final del artículo. Los usuarios son libres de crear bibliotecas secundarias si no están interesados ​​en la portabilidad multiplataforma. Regresemos a la descripción de la clase.

//+------------------------------------------------------------------+
//|Constructor                                                       |
//+------------------------------------------------------------------+
CCoordinateDescent::CCoordinateDescent(
   const int  num_predictors,   // Number of predictor variables
   const int num_observations,    // Number of cases we will be training
   const bool use_covariance_updates,    // Use fast covariance updates rather than slow naive method
   const int num_lambdas_to_trial     // Number of m_lambdas we will be using in training
)

El constructor paramétrico necesita 4 parámetros:

• num_predictors indica la cantidad de variables, este es el número de predictores o indicadores; cada conjunto de indicadores ocupará una columna en la matriz de datos interna.

• num_observations especificará el número de datos que deberá esperar el objeto. Este podría ser el número de filas o el número exacto de elementos disponibles en cada conjunto de variables/predictores/indicadores.

• use_covariance_updates es una opción booleana que, de forma ideal, debería usarse cuando el número num_observations supere el número num_predictors. Establecerlo en true proporcionará una mejora significativa en el tiempo de ejecución. Esta opción solo debe considerarse si num_observations > num_predictors.

• num_lambdas_to_trial establece el número máximo de variantes lambda que se probarán durante el proceso de entrenamiento.

El constructor simplemente preparará las estructuras de datos internas para obtener todos los datos necesarios.

 {
   m_nvars = num_predictors ;
   m_observs = num_observations ;
   m_covarupdates = use_covariance_updates ;
   m_nlambda = num_lambdas_to_trial ;
   m_initialized=true;
   m_ymean=m_yscale=m_explained=0;
   
   if(m_nvars<0 || m_observs<0 || m_nlambda<0)
     {
       m_initialized=false;
       Print("Invalid parameter value, neither num_predictors ,num_observations, nor num_lambdas_to_trial can be negative");
       return;
     }  
      
   if(ArrayResize(m_x_matrix,m_observs*m_nvars)<m_observs*m_nvars    ||
      ArrayResize(m_y,m_observs)<m_observs                ||
      ArrayResize(m_xmeans,m_nvars)<m_nvars             ||
      ArrayResize(m_xscales,m_nvars)<m_nvars            ||
      ArrayResize(m_beta,m_nvars)<m_nvars               ||
      ArrayResize(m_resid,m_observs)<m_observs)
      m_initialized=false;
//---conditional allocation
   if(m_covarupdates)
     {
      if(ArrayResize(m_xinner_matrix,m_nvars*m_nvars)<m_nvars*m_nvars||
         ArrayResize(m_yinner,m_nvars)<m_nvars)
         m_initialized=false;
     }
//---
   if(m_nlambda>0)
     {
      if(ArrayResize(m_lambdabeta_matrix,m_nlambda*m_nvars)<m_nlambda*m_nvars ||
         ArrayResize(m_lambdas,m_nlambda)<m_nlambda)
         m_initialized=false;
     }
//---return immediately if any error
   if(!m_initialized)
      Print("Memory allocation error ", GetLastError());

  }

Tras crear un ejemplar de CCordinateDescent, deberemos recopilar todos los predictores y valores objetivo para el preprocesamiento. Esto se hará con el método SetData. Su primer parámetro será un índice inicial que indicará en qué parte de los arrays que se transmitirán a este método deberemos comenzar a recopilar datos. Este método ayudará a realizar más comprobaciones cruzadas.

//+------------------------------------------------------------------+
//|Get and standardize the data                                      |
//|   Also compute inner products if covar_update                    |
//+------------------------------------------------------------------+
bool CCoordinateDescent::SetData(
   const int begin,    // Starting index in full database for getting m_observs of training set
   const int num_observations,// Number of cases in full database (we wrap back to the start if needed)
   double  &xx_matrix[],    // Full database (num_observations rows, m_nvars columns)
   double  &yy[]   // Predicted variable vector, num_observations long
)

num_observations es el nombre del parámetro que ya aparece en el constructor. Aquí se usará de una forma un poco distinta. Si aquí establecemos un valor inferior al utilizado al crear el ejemplar del objeto, podremos volver al primer valor del array tras alcanzar esa posición de índice. Si dicha funcionalidad no resulta necesaria, la configuraremos en el mismo valor que se utilizó al llamar al constructor. Simplemente no la ponga en cero o menos. Esto provocará un error.

El siguiente parámetro requerido, xx_matrix, será un array con la disposición especial de matrices ya mencionada. Aquí es donde introduciremos las métricas sin procesar. Deberemos tener el tamaño especificado al llamar al constructor, es decir, num_observations * num_predictors.

El último parámetro yy será un array de valores objetivo correspondientes.

El método estandarizará ambos arrays de entrada antes de copiarlos en los búferes de objetos internos.

 {
   if(!m_initialized)
      return false;
   // parameter checks   
   if(begin<0 || num_observations<0)
     {
      Print("Invalid parameter value: neither begin nor num_observations can be negative");
      return false;
     }
   //--- invalid a    
   if(ArraySize(xx_matrix)<(m_observs*m_nvars) || ArraySize(yy)<m_observs)
     {
      Print("Insufficient data supplied relative to object specification");
      return false;
     }
   //---  
   int icase, ivar, jvar, k,xptr;
   double sum, xm, xs, diff;

   /*
      Standardize X
   */

   for(ivar=0 ; ivar<m_nvars ; ivar++)
     {

      xm = 0.0 ;
      for(icase=0 ; icase<m_observs ; icase++)
        {
         k = (icase + begin) % num_observations ;
         xm += xx_matrix[k*m_nvars+ivar] ;
        }
      xm /= m_observs ;
      m_xmeans[ivar] = xm ;

      xs = 1.e-60 ;  // Prevent division by zero later
      for(icase=0 ; icase<m_observs ; icase++)
        {
         k = (icase + begin) % num_observations ;
         diff = xx_matrix[k*m_nvars+ivar] - xm ;
         xs += diff * diff ;
        }
      xs = sqrt(xs / m_observs) ;
      m_xscales[ivar] = xs ;

      for(icase=0 ; icase<m_observs ; icase++)
        {
         k = (icase + begin) % num_observations ;
         m_x_matrix[icase*m_nvars+ivar] = (xx_matrix[k*m_nvars+ivar] - xm) / xs ;
        }
     }

   /*
      Standardize Y
   */

   m_ymean = 0.0 ;
   for(icase=0 ; icase<m_observs ; icase++)
     {
      k = (icase + begin) % num_observations ;
      m_ymean += yy[k] ;
     }
   m_ymean /= m_observs ;

   m_yscale = 1.e-60 ;  // Prevent division by zero later
   for(icase=0 ; icase<m_observs ; icase++)
     {
      k = (icase + begin) % num_observations ;
      diff = yy[k] - m_ymean ;
      m_yscale += diff * diff ;
     }
   m_yscale = sqrt(m_yscale / m_observs) ;

   for(icase=0 ; icase<m_observs ; icase++)
     {
      k = (icase + begin) % num_observations ;
      m_y[icase] = (yy[k] - m_ymean) / m_yscale ;
     }

   

   /*
      If user requests covariance updates, compute required inner products
      We store the full m_xinner_matrix matrix for faster addressing later,
      even though it is symmetric.
      We handle both unweighted and weighted cases here.
   */

   if(m_covarupdates)
     {
      for(ivar=0 ; ivar<m_nvars ; ivar++)
        {
         xptr = ivar ;

         // Do XiY
         sum = 0.0 ;
         
            for(icase=0 ; icase<m_observs ; icase++)
               sum += m_x_matrix[xptr+icase*m_nvars] * m_y[icase] ;
            m_yinner[ivar] = sum / m_observs ;

         // Do XiXj
         
            for(jvar=0 ; jvar<m_nvars ; jvar++)
              {
               if(jvar == ivar)
                  m_xinner_matrix[ivar*m_nvars+jvar] = 1.0 ;      // Recall that X is standardized
               else
                  if(jvar < ivar)                    // Matrix is symmetric, so just copy
                     m_xinner_matrix[ivar*m_nvars+jvar] = m_xinner_matrix[jvar*m_nvars+ivar] ;
                  else
                    {
                     sum = 0.0 ;
                     for(icase=0 ; icase<m_observs ; icase++)
                        sum += m_x_matrix[xptr+icase*m_nvars] * m_x_matrix[icase*m_nvars+jvar] ;
                     m_xinner_matrix[ivar*m_nvars+jvar] = sum / m_observs ;
                    }
              }
        } // For ivar
     }
//---
   return true;     
  }

Si SetData tiene éxito y retorna true, el usuario podrá llamar a Train() o TrainLambda() dependiendo de lo que quiera hacer.

//+------------------------------------------------------------------+
//|Core training routine                                             |
//+------------------------------------------------------------------+
void CCoordinateDescent::Train(
   const double alpha,     // User-specified alpha, (0,1) (0 problematic for descending lambda)
   const double lambda,    // Can be user-specified, but usually from TrainLambda()
   const int maxits,       // Maximum iterations, for safety only
   const double convergence_criterion,       // Convergence criterion, typically 1.e-5 or so
   const bool fast_test,    // Base convergence on max m_beta change vs m_explained variance?
   const bool warm_start    // Start from existing m_beta, rather than zero?
)

La optimización principal tendrá lugar en el método Train(). Aquí se especificará el tipo de regularización (alfa) y el grado de regularización (lambda), así como el tipo de prueba de convergencia a realizar (fast_test) y la precisión requerida para lograr la convergencia (convergence_criterion).

• El parámetro maxits será tolerante a fallos y evitará que el procedimiento se ejecute innecesariamente. Deberemos establecerlo en un valor bastante grande, como 1000 o más.

• Warm_start especificará si debemos comenzar a entrenar con pesos beta inicializados a cero o no.

{
   if(!m_initialized)
      return;
   
   if(alpha<0 || alpha>1)
    { 
     Print("Invalid parameter value: Legal values for alpha are between 0 and 1 inclusive");
     return;
    }
   
   if(lambda<0)
    {
     Print("Invalid parameter value: lambda accepts only positive values");
     return;
    }
    
   if(maxits<=0)
    {
     Print("Invalid parameter value: maxist accepts only non zero positive values");
     return;
    } 
    
   int i, iter, icase, ivar, kvar, do_active_only, active_set_changed, converged,xptr ;
   double residual_sum, S_threshold, argument, new_beta, correction, update_factor ;
   double sum, explained_variance, crit, prior_crit, penalty, max_change, Xss, YmeanSquare ;


   /*
      Initialize
   */

   S_threshold = alpha * lambda ;   // Threshold for the soft-thresholding operator S()
   do_active_only = 0 ;             // Begin with a complete pass
   prior_crit = 1.0e60 ;            // For convergence test

   if(warm_start)                   // Pick up with current betas?
     {
      if(! m_covarupdates)           // If not using covariance updates, must recompute residuals
        {
         for(icase=0 ; icase<m_observs ; icase++)
           {
            xptr = icase * m_nvars ;
            sum = 0.0 ;
            for(ivar=0 ; ivar<m_nvars ; ivar++)
               sum += m_beta[ivar] * m_x_matrix[xptr+ivar] ;
            m_resid[icase] = m_y[icase] - sum ;
           }
        }
     }

   else                             // Not warm start, so initial betas are all zero
     {
      for(i=0 ; i<m_nvars ; i++)
         m_beta[i] = 0.0 ;
      for(i=0 ; i<m_observs ; i++)     // Initial residuals are just the Y variable
         m_resid[i] = m_y[i] ;
     }

// YmeanSquare will remain fixed throughout training.
// Its only use is for computing m_explained variance for the user's edification.

   YmeanSquare = 1.0 ;


   /*
      Outmost loop iterates until converged or user's maxits limit hit

   */

   for(iter=0 ; iter<maxits ; iter++)
     {

      /*
         Pass through variables
      */

      active_set_changed = 0 ;  // Did any betas go to/from 0.0?
      max_change = 0.0 ;        // For fast convergence test

      for(ivar=0 ; ivar<m_nvars ; ivar++)     // Descend on this m_beta
        {

         if(do_active_only  &&  m_beta[ivar] == 0.0)
            continue ;

          Xss = 1 ;        // X was standardized
         update_factor = Xss + lambda * (1.0 - alpha) ;

         if(m_covarupdates)      // Any sensible user will specify this unless m_observs < m_nvars
           {
            sum = 0.0 ;
            for(kvar=0 ; kvar<m_nvars ; kvar++)
               sum += m_xinner_matrix[ivar*m_nvars+kvar] * m_beta[kvar] ;
            residual_sum = m_yinner[ivar] - sum ;
            argument = residual_sum + Xss * m_beta[ivar] ;   // Argument to S() [MY FORMULA]
           }

         else
        // Use slow definitional formula (okay if m_observs < m_nvars)
             {
               residual_sum = 0.0 ;
               xptr = ivar ;    // Point to column of this variable
               for(icase=0 ; icase<m_observs ; icase++)
                  residual_sum += m_x_matrix[xptr+icase*m_nvars] * m_resid[icase] ;  // X_ij * RESID_i
               residual_sum /= m_observs ;
               argument = residual_sum + m_beta[ivar] ;  // Argument to S() ;    (Eq 8)
              }

         // Apply the soft-thresholding operator S()

         if(argument > 0.0  &&  S_threshold < argument)
            new_beta = (argument - S_threshold) / update_factor ;
         else
            if(argument < 0.0  &&  S_threshold < -argument)
               new_beta = (argument + S_threshold) / update_factor ;
            else
               new_beta = 0.0 ;

         // Apply the update, if changed, and adjust the residual if using naive or weighted updates
         // This is also used to update the fast convergence criterion

         correction = new_beta - m_beta[ivar] ;  // Will use this to adjust residual if using naive updates
         if(fabs(correction) > max_change)
            max_change = fabs(correction) ;    // Used for fast convergence criterion

         if(correction != 0.0)      // Did this m_beta change?
           {
            if(! m_covarupdates)     // Must we update the residual vector (needed for naive methods)?
              {
               xptr = ivar ;    // Point to column of this variable
               for(icase=0 ; icase<m_observs ; icase++)             // Update residual for this new m_beta
                  m_resid[icase] -= correction * m_x_matrix[xptr+icase*m_nvars] ;
              }
            if((m_beta[ivar] == 0.0  &&  new_beta != 0.0)  || (m_beta[ivar] != 0.0  &&  new_beta == 0.0))
               active_set_changed = 1 ;
            m_beta[ivar] = new_beta ;
           }

        } // For all variables; a complete pass

      /*
         A pass (complete or active only) through variables has been done.
         If we are using the fast convergence test, it is simple.  But if using the slow method...
           Compute m_explained variance and criterion; compare to prior for convergence test
           If the user requested the covariance update method, we must compute residuals for these.
      */

      if(fast_test)               // Quick and simple test
        {
         if(max_change < convergence_criterion)
            converged = 1 ;
         else
            converged = 0 ;
        }

      else     // Slow test (change in m_explained variance) which requires residual
        {
         if(m_covarupdates)     // We have until now avoided computing residuals
           {
            for(icase=0 ; icase<m_observs ; icase++)
              {
               xptr = icase * m_nvars ;
               sum = 0.0 ;
               for(ivar=0 ; ivar<m_nvars ; ivar++)
                  sum += m_beta[ivar] * m_x_matrix[xptr+ivar] ; // Cumulate predicted value
               m_resid[icase] = m_y[icase] - sum ;     // Residual = true - predicted
              }
           }

         sum = 0.0 ;       // Will cumulate squared error for convergence test
         
            for(i=0 ; i<m_observs ; i++)
               sum += m_resid[i] * m_resid[i] ;
            crit = sum / m_observs ;               // MSE component of optimization criterion

         explained_variance = (YmeanSquare - crit) / YmeanSquare ; // Fraction of Y m_explained

         penalty = 0.0 ;
         for(i=0 ; i<m_nvars ; i++)
            penalty += 0.5 * (1.0 - alpha) * m_beta[i] * m_beta[i]  +  alpha * fabs(m_beta[i]) ;
         penalty *= 2.0 * lambda ;           // Regularization component of optimization criterion

         crit += penalty ;                   // This is what we are minimizing

         if(prior_crit - crit < convergence_criterion)
            converged = 1 ;
         else
            converged = 0 ;

         prior_crit = crit ;
        }

      /*
            After doing a complete (all variables) pass, we iterate on only
            the active set (m_beta != 0) until convergence.  Then we do a complete pass.
            If the active set does not change, we are done:
            If a m_beta goes from zero to nonzero, by definition the active set changed.
            If a m_beta goes from nonzero to another nonzero, then this is a theoretical flaw
            in this process.  However, if we just iterated the active set to convergence,
            it is highly unlikely that we would get anything other than a tiny move.
      */

      if(do_active_only)         // Are we iterating on the active set only?
        {
         if(converged)           // If we converged
            do_active_only = 0 ; // We now do a complete pass
        }

      else                       // We just did a complete pass (all variables)
        {
         if(converged  &&  ! active_set_changed)
            break ;
         do_active_only = 1 ;    // We now do an active-only pass
        }

     } // Outer loop iterations

   /*
      We are done.  Compute and save the m_explained variance.
      If we did the fast convergence test and covariance updates,
      we must compute the residual in order to get the m_explained variance.
      Those two options do not require regular residual computation,
      so we don't currently have the residual.
   */

   if(fast_test  &&  m_covarupdates)     // Residuals have not been maintained?
     {
      for(icase=0 ; icase<m_observs ; icase++)
        {
         xptr = icase * m_nvars ;
         sum = 0.0 ;
         for(ivar=0 ; ivar<m_nvars ; ivar++)
            sum += m_beta[ivar] * m_x_matrix[xptr+ivar] ;
         m_resid[icase] = m_y[icase] - sum ;
        }
     }

   sum = 0.0 ;
   
      for(i=0 ; i<m_observs ; i++)
         sum += m_resid[i] * m_resid[i] ;
      crit = sum / m_observs ;               // MSE component of optimization criterion

   m_explained = (YmeanSquare - crit) / YmeanSquare ;  // This variable is a member of the class
  }

A medida que se vayan dando las observaciones, también calcularemos la proporción de la varianza objetivo explicada. Al utilizar una prueba de convergencia lenta (fast_test se establecerá en false), la convergencia se logrará cuando el cambio de una iteración a la siguiente sea inferior al valor del criterio de convergencia especificado.

De lo contrario, si utilizamos el método rápido, la convergencia se logrará cuando el cambio máximo en el ajuste beta entre todas las betas sea inferior al criterio de convergencia.

//+------------------------------------------------------------------+
//|Compute minimum lambda such that all betas remain at zero         |
//+------------------------------------------------------------------+
double CCoordinateDescent::GetLambdaThreshold(const double alpha)
  {

   if(!m_initialized)
      return 0;
   
   if(alpha>1 || alpha<0)
    {
     Print("Invalid parameter for Alpha, legal values are between 0 and 1 inclusive");
     return 0;
    }
    
   int ivar, icase,xptr ;
   double thresh, sum;

   thresh = 0.0 ;
   for(ivar=0 ; ivar<m_nvars ; ivar++)
     {
      xptr = ivar ;
      sum = 0.0 ;
      
      for(icase=0 ; icase<m_observs ; icase++)
           sum += m_x_matrix[xptr+icase*m_nvars] * m_y[icase] ;
      sum /= m_observs ;

      sum = fabs(sum) ;
      if(sum > thresh)
         thresh = sum ;
     }

   return thresh / (alpha + 1.e-60) ;
  }

GetLambdaThreshold() requerirá un parámetro de entrada que especifique el tipo de regularización. Este método retornará el valor lambda calculado para el cual todas las betas correspondientes son cero. La idea es que ese valor sería un buen comienzo para encontrar el hiperparámetro lambda óptimo para un alfa determinado.

La optimización lambda real se realizará mediante TrainLambda(). Este tiene parámetros de función similares a Train(). El usuario podrá especificar el valor inicial de lambda a través de maxlambda. Establecer el valor en 0 o menos usará automáticamente GetlambdaThreshold() para establecer el valor inicial en true. El ciclo principal llamará a Train() repetidamente y almacenará betas para cada lambda para las iteraciones máximas de m_nlambda especificadas en la llamada al constructor.

//+----------------------------------------------------------------------------------------+
//| Multiple-lambda training routine calls Train() repeatedly, saving each m_beta vector   |                                                                 |
//+----------------------------------------------------------------------------------------+
void CCoordinateDescent::TrainLambda(
   const double alpha,       // User-specified alpha, (0,1) (0 problematic for descending lambda)
   const int maxits,         // Maximum iterations, for safety only
   const double convergence_criterion,         // Convergence criterion, typically 1.e-5 or so
   const bool fast_test,      // Base convergence on max m_beta change vs m_explained variance?
   const double maxlambda,  // Starting lambda, or negative for automatic computation
   const bool print_steps     // Print lambda/m_explained table?
)
  {
   if(!m_initialized)
      return;

   int ivar, ilambda, n_active ;
   double lambda, min_lambda, lambda_factor,max_lambda=maxlambda;
   string fprint ;

   if(m_nlambda <= 1)
      return ;

   /*
      Compute the minimum lambda for which all m_beta weights remain at zero
      This (slightly decreased) will be the lambda from which we start our descent.
   */

   if(max_lambda <= 0.0)
      max_lambda = 0.999 * GetLambdaThreshold(alpha) ;
   min_lambda = 0.001 * max_lambda ;
   lambda_factor = exp(log(min_lambda / max_lambda) / (m_nlambda-1)) ;

   /*
      Repeatedly train with decreasing m_lambdas
   */

   if(print_steps)
     {
      fprint+="\nDescending lambda path...";
     }

   lambda = max_lambda ;
   for(ilambda=0 ; ilambda<m_nlambda ; ilambda++)
     {
      m_lambdas[ilambda] = lambda ;   // Save in case we want to use later
      Train(alpha, lambda, maxits, convergence_criterion, fast_test,(bool)ilambda) ;
      for(ivar=0 ; ivar<m_nvars ; ivar++)
         m_lambdabeta_matrix[ilambda*m_nvars+ivar] = m_beta[ivar] ;
      if(print_steps)
        {
         n_active = 0 ;
         for(ivar=0 ; ivar<m_nvars ; ivar++)
           {
            if(fabs(m_beta[ivar]) > 0.0)
               ++n_active ;
           } 
         fprint+=StringFormat("\n %8.4lf %4d %12.4lf", lambda, n_active, m_explained) ;
        }
      lambda *= lambda_factor ;
     }

   if(print_steps)
      Print(fprint);
  }

Nuestra clase de descenso de coordenadas ya está completa. A continuación, necesitaremos una herramienta para realizar la validación cruzada para ajustar el hiperparámetro lambda.

Función OptimizeLambda

//+------------------------------------------------------------------------------------------+
//|   Cross-validation training routine calls TrainLambda() repeatedly to optimize lambda    |
//+------------------------------------------------------------------------------------------+
double OptimizeLambda(
   int n_observations,               // Number of cases in full database
   int n_predictors,                 // Number of variables (columns in database)
   int n_folds,                      // Number of folds
   bool covar_updates,               // Does user want (usually faster) covariance update method?
   int n_lambda,                     // This many out_lambdas tested by lambda_train() (must be at least 2)
   double alpha,                     // User-specified alpha, (0,1) (0 problematic for descending lambda)
   int maxits,                       // Maximum iterations, for safety only
   double convergence_criterion,     // Convergence criterion, typically 1.e-5 or so
   bool fast_test,                   // Base convergence on max beta change vs explained variance?
   double &in_matrix[],              // Full database (n_observations rows, n_predictors columns)
   double &in_targets[],             // Predicted variable vector, n_observations long
   double &out_lambdas[],            // Returns out_lambdas tested by lambda_train()
   double &out_lambda_OOS[],         // Returns OOS explained for each of above out_lambdas
   bool print_output = false         // show full output
)

Su objetivo principal será implementar el entrenamiento de la validación cruzada para la selección automática de hiperparámetros lambda. La mayoría de los parámetros de entrada tienen nombres familiares porque el procedimiento utilizará la optimización de descenso de coordenadas.

Esta función también se puede utilizar cuando el usuario no está seguro de qué valor lambda usar. La validación cruzada es una técnica de ajuste de hiperparámetros. Para usarla, obviamente necesitaremos transmitir los mismos datos de entrenamiento que eventualmente se usarán para construir el modelo de regresión completo.

in_matrix son los datos de entrada para la matriz de predictores, in_targets serán los objetivos correspondientes. Además de estos arrays de entrada, también deberemos proporcionar dos matrices más. out_lambdas y out_lambda_OOS serán arrays que contendrán información más detallada sobre el proceso de validación cruzada.

El último parámetro especificará si los resultados deben mostrarse en la terminal.

 {
   int i_IS, n_IS, i_OOS, n_OOS, n_done, ifold  ;
   int icase, ivar, ilambda, ibest, k,coefs ;
   double pred, sum, diff, max_lambda, Ynormalized, YsumSquares, best,work[] ;
   CCoordinateDescent *cd ;

   if(n_lambda < 2)
      return 0.0 ;

   /*
      Use the entire dataset to find the max lambda that will be used for all descents.
      Also, copy the normalized case weights if there are any.
   */

   cd = new CCoordinateDescent(n_predictors, n_observations, covar_updates, n_lambda) ;
   cd.SetData(0, n_observations, in_matrix, in_targets) ;                           // Fetch the training set for this fold
   max_lambda = cd.GetLambdaThreshold(alpha) ;
   delete cd ;

   if(print_output)
      PrintFormat("%s starting for %d folds with max lambda=%.9lf",__FUNCTION__, n_folds, max_lambda) ;

   i_IS = 0 ;        // Training data starts at this index in complete database
   n_done = 0 ;      // Number of cases treated as OOS so far

   for(ilambda=0 ; ilambda<n_lambda ; ilambda++)
      out_lambda_OOS[ilambda] = 0.0 ;  // Will cumulate across folds here

   YsumSquares = 0.0 ;    // Will cumulate to compute explained fraction

   /*
      Process the folds
   */

   for(ifold=0 ; ifold<n_folds ; ifold++)
     {

      n_OOS = (n_observations - n_done) / (n_folds - ifold) ;  // Number OOS  (test set)
      n_IS = n_observations - n_OOS ;                         // Number IS (training set)
      i_OOS = (i_IS + n_IS) % n_observations ;                // OOS starts at this index

      // Train the model with this IS set

      cd = new CCoordinateDescent(n_predictors, n_IS, covar_updates, n_lambda) ;
      cd.SetData(i_IS, n_observations, in_matrix, in_targets) ;                                        // Fetch the training set for this fold
      cd.TrainLambda(alpha, maxits, convergence_criterion, fast_test, max_lambda,print_output) ;        // Compute the complete set of betas (all out_lambdas)

      // Compute OOS performance for each lambda and sum across folds.
      // Normalization of X and Y is repeated, when it could be done once and saved.
      // But the relative cost is minimal, and it is simpler doing it this way.

      for(ilambda=0 ; ilambda<n_lambda ; ilambda++)
        {
         out_lambdas[ilambda] = cd.GetLambdaAt(ilambda) ;  // This will be the same for all folds
         coefs = ilambda * n_predictors ;
         sum = 0.0 ;
         for(icase=0 ; icase<n_OOS ; icase++)
           {
            k = (icase + i_OOS) % n_observations ;
            pred = 0.0 ;
            for(ivar=0 ; ivar<n_predictors ; ivar++)
               pred += cd.GetLambdaBetaAt(coefs+ivar) * (in_matrix[k*n_predictors+ivar] - cd.GetXmeansAt(ivar)) / cd.GetXscalesAt(ivar) ;
            Ynormalized = (in_targets[k] - cd.GetYmean()) / cd.GetYscale() ;
            diff = Ynormalized - pred ;
            
            if(ilambda == 0)
               YsumSquares += Ynormalized * Ynormalized ;
            sum += diff * diff ;
           }
         out_lambda_OOS[ilambda] += sum ;  // Cumulate for this fold
        }  // For ilambda

      delete cd ;

      n_done += n_OOS ;                           // Cumulate OOS cases just processed
      i_IS = (i_IS + n_OOS) % n_observations ;                 // Next IS starts at this index

     }  // For ifold

   /*
      Compute OOS explained variance for each lambda, and keep track of the best
   */

   best = -1.e60 ;
   for(ilambda=0 ; ilambda<n_lambda ; ilambda++)
     {
      out_lambda_OOS[ilambda] = (YsumSquares - out_lambda_OOS[ilambda]) / YsumSquares ;
      if(out_lambda_OOS[ilambda] > best)
        {
         best = out_lambda_OOS[ilambda] ;
         ibest = ilambda ;
        }
     }

   if(print_output)
      PrintFormat("\n%s ending with best lambda=%9.9lf  explained=%9.9lf",__FUNCTION__, out_lambdas[ibest], best) ;

   return out_lambdas[ibest] ;
  }
//+------------------------------------------------------------------+

La función utilizará un ejemplar CCordinateDescent local para probar un conjunto de expresiones lambda. El número de lambdas que se probarán se especificará mediante el parámetro de función n_lambda. Las lambdas probadas comenzarán desde el máximo calculado llamando a GetLambdaThreshold(). Después de cada iteración de prueba, el valor lambda anterior disminuirá ligeramente. Cada prueba lambda generará nuevos coeficientes beta, que se utilizarán para calcular la proporción de varianza explicada. Todo esto se hará para cada convolución. Así se analizarán los resultados de todas las convoluciones y se seleccionará la mejor. La lambda que ha ofrecido el mejor resultado se retornará como óptima.  
 
Ya hemos descrito todas las utilidades del código. Es hora de ponerlos a trabajar.

Ejemplo

Para demostrar la aplicación práctica de este método, lo usaremos para construir un modelo que pronostique el cambio de precio de la siguiente barra basándose en una combinación de medias móviles largas y cortas. Queremos encontrar un conjunto de medias móviles que resulten más útiles para predecir el cambio de precio de la siguiente barra.  

Por nuestra parte, suministraremos al modelo indicadores calculados a partir de precios brutos transformados logarítmicamente cuyos valores objetivo serán las diferencias logarítmicas. Necesitaremos un indicador que transforme los precios brutos para que otros indicadores (en este caso la media móvil) puedan hacer referencia a él. El indicador de precio logarítmico se muestra más abajo.

//+------------------------------------------------------------------+
//|                                                    LogPrices.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_plots   1
//--- plot Log
#property indicator_label1  "Log"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrTurquoise
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
double         LogBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,LogBuffer,INDICATOR_DATA);

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
//---
   for(int i=(prev_calculated>0)?prev_calculated-1:0; i<rates_total; i++)
      LogBuffer[i]=(price[i]>0)?log(price[i]):0;
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

El programa de entrenamiento se implementará en forma de script. Comenzaremos especificando los archivos de inclusión principales y las entradas del script. Las entradas permitirán al usuario personalizar varios aspectos del programa para satisfacer sus necesidades. Esto incluirá la capacidad de establecer fechas para los periodos de entrenamiento y prueba.

//+------------------------------------------------------------------+
//|                                 ElasticNetRegressionModel_MA.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#resource "\\Indicators\\LogPrices.ex5"
#include<CoordinateDescent.mqh>
#include<ErrorDescription.mqh>
#property script_show_inputs
//--- input parameters
input uint     MA_period_inc=2;        //MA lookback increment
input uint     Num_MA_periods=30;    //Num of lookbacks
input double   Alpha=0.5;
input int      AppliedPrice=PRICE_CLOSE;
input ENUM_MA_METHOD MaMethod=MODE_EMA;
input ENUM_TIMEFRAMES tf=PERIOD_D1;    //time frame
input uint     BarsLookAhead=1;
input uint     Num_Folds = 10;         //Num of Folds for cross validation
input uint     MaximumIterations=1000;
input datetime TrainingSampleStartDate=D'2019.12.31';
input datetime TrainingSampleStopDate=D'2022.12.31';
input datetime TestingSampleStartDate=D'2023.01.02';
input datetime TestingSampleStopDate=D'2023.06.30';
input string   SetSymbol="";
input bool     UseCovarUpdates=true;
input bool     UseFastTest=true;
input bool     UseWarmStart=false;
input int      NumLambdasToTest=50;
input bool     ShowFullOutPut=false;     //print full output to terminal

Las opciones de entrada del usuario esenciales serán la entrada MA_period_inc, que establecerá los incrementos del periodo. Num_Ma_ period determina el número de medias móviles que se introducirán en el algoritmo. Los valores de indicador que se usan como predictores serán la diferencia entre la media móvil larga y corta. La media móvil corta se calculará como la mitad del periodo de la media móvil larga resultante. La media móvil larga se determinará aumentando MA_period_inc en Num_MA_period veces.
Num_Folds determinará el número de envoltorios que utilizará la función Optimizelambda durante la validación cruzada.  
Los nombres de las otras entradas se explican por sí solos.

El script comenzará enumerando los conjuntos de datos de entrenamiento y prueba. El tamaño de los búferes locales cambiará dependiendo de la selección de datos por parte del usuario.

//+------------------------------------------------------------------+
//|global integer variables                                          |
//+------------------------------------------------------------------+
int size_insample,                 //training set size
    size_outsample,                //testing set size
    size_observations,             //size of of both training and testing sets combined
    size_lambdas,                  //number of lambdas to be tested
    size_predictors,               //number of predictors
    maxperiod,                     //maximum lookback
    price_handle=INVALID_HANDLE,   //log prices indicator handle
    long_ma_handle=INVALID_HANDLE, //long moving average indicator handle
    short_ma_handle=INVALID_HANDLE;//short moving average indicator handle
//+------------------------------------------------------------------+
//|double global variables                                           |
//+------------------------------------------------------------------+

double prices[],                   //array for log transformed prices
       targets[],                  //differenced prices kept here
       predictors_matrix[],               //flat array arranged as matrix of all predictors_matrix ie size_observations by size_predictors
       longma[],                   //long ma indicator values
       Lambdas[],                  //calculated lambdas kept here
       Lambdas_OOS[],              //calculated out of sample lambdas are here
       shortma[],                  //short ma indicator values
       Lambda;                     //initial optimal lambda value
//+------------------------------------------------------------------+
//| Coordinate descent pointer                                       |
//+------------------------------------------------------------------+
CCoordinateDescent *cdmodel;       //coordinate descent pointer
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//get relative shift of is and oos sets
   int teststart,teststop,trainstart,trainstop;
   teststart=iBarShift(SetSymbol!=""?SetSymbol:NULL,tf,TestingSampleStartDate);
   teststop=iBarShift(SetSymbol!=""?SetSymbol:NULL,tf,TestingSampleStopDate);
   trainstart=iBarShift(SetSymbol!=""?SetSymbol:NULL,tf,TrainingSampleStartDate);
   trainstop=iBarShift(SetSymbol!=""?SetSymbol:NULL,tf,TrainingSampleStopDate);
//check for errors from ibarshift calls
   if(teststart<0 || teststop<0 || trainstart<0 || trainstop<0)
     {
      Print(ErrorDescription(GetLastError()));
      return;
     }
//---set the size of the sample sets
   size_observations=(trainstart - teststop) + 1 ;
   size_outsample=(teststart - teststop) + 1;
   size_insample=(trainstart - trainstop) + 1;
   maxperiod=int(Num_MA_periods*MA_period_inc);
   size_insample-=maxperiod;
   size_lambdas=NumLambdasToTest;
   size_predictors=int(Num_MA_periods);
//---check for input errors
   if(size_lambdas<=0 || size_insample<=0 || size_outsample<=0 || size_predictors<=0 || maxperiod<=0 || BarsLookAhead<=0)
     {
      Print("Invalid inputs ");
      return;
     }
//---
   Comment("resizing buffers...");

Los arrays que se transmitirán al ejemplar CCordinateDescent serán preparados y rellenados: la matriz de destino y la matriz de predictores.

//---allocate memory
   if(ArrayResize(targets,size_observations)<(int)size_observations ||
      ArrayResize(predictors_matrix,size_observations*size_predictors)<int(size_observations*size_predictors) ||
      ArrayResize(Lambdas,size_lambdas)<(int)size_lambdas ||
      ArrayResize(Lambdas_OOS,size_lambdas)<(int)size_lambdas ||
      ArrayResize(shortma,size_observations)<(int)size_observations ||
      ArrayResize(longma,size_observations)<(int)size_observations ||
      ArrayResize(prices,size_observations+BarsLookAhead)<int(size_observations+BarsLookAhead))
     {
      Print("ArrayResize error ",ErrorDescription(GetLastError()));
      return;
     }

//---
   Comment("getting price predictors_matrix...");
//---set prices handle
   price_handle=iCustom(SetSymbol!=""?SetSymbol:NULL,tf,"::Indicators\\LogPrices.ex5",AppliedPrice);
   if(price_handle==INVALID_HANDLE)
     {
      Print("invalid logprices handle ",ErrorDescription(GetLastError()));
      return;
     }
//---
   Comment("getting indicators...");
//----calculate the full collection of predictors_matrix
   int longmaperiod,shortmaperiod,prevshort,prevlong;
   int k=0;
//---
   prevlong=prevshort=0;
//---
   for(uint iperiod=0; iperiod<Num_MA_periods; iperiod++)
     {
      longmaperiod=(int)(iperiod+1)*int(MA_period_inc);
      shortmaperiod = (longmaperiod>=2)?int(longmaperiod/2):longmaperiod;
      ResetLastError();
      int try=10;
      while(try)
        {
          long_ma_handle=iMA(SetSymbol!=""?SetSymbol:NULL,tf,longmaperiod,0,MaMethod,price_handle);
          short_ma_handle=iMA(SetSymbol!=""?SetSymbol:NULL,tf,shortmaperiod,0,MaMethod,price_handle);
          
          if(long_ma_handle==INVALID_HANDLE || short_ma_handle==INVALID_HANDLE)
             try--;
          else
             break;
        }
      Comment("copying buffers for short ",shortmaperiod," long ",longmaperiod);

     if(CopyBuffer(long_ma_handle,0,teststop,size_observations,longma)<=0 ||
        CopyBuffer(short_ma_handle,0,teststop,size_observations,shortma)<=0)
         {
          Print("error copying to ma buffers  ",GetLastError());
          return;
         }

     for(int i=0 ; i<int(size_observations) ; i++)
          predictors_matrix[i*size_predictors+k] = shortma[i]-longma[i];
     ++k ;

     if(long_ma_handle!=INVALID_HANDLE && short_ma_handle!=INVALID_HANDLE && IndicatorRelease(long_ma_handle) && IndicatorRelease(short_ma_handle))
       {
        long_ma_handle=short_ma_handle=INVALID_HANDLE;
        prevlong=longmaperiod;
        prevshort=shortmaperiod;
       }
    }
//---
   Comment("filling target buffer...");
//---
   ResetLastError();
   if(CopyBuffer(price_handle,0,teststop,size_observations+BarsLookAhead,prices)<int(size_observations+BarsLookAhead))
     {
      Print("error copying to price buffer , ",ErrorDescription(GetLastError()));
      return;
     }
//---
   for(int i=0 ; i<int(size_observations); i++)
      targets[i] = prices[i+BarsLookAhead]-prices[i];
//---

Lambda se ajustará en función del valor Alpha. Cuando alfa sea menor o igual a cero, no se calculará la lambda óptima. El resultado será un modelo similar a la regresión lineal estándar sin ninguna regularización.

//---
   Comment("optional lambda tuning...");
//---
   if(Alpha<=0)
      Lambda=0;
   else //train
      Lambda=OptimizeLambda(size_insample,size_predictors,(int)Num_Folds,UseCovarUpdates,size_lambdas,Alpha,(int)MaximumIterations,1.e-9,UseFastTest,predictors_matrix,targets,Lambdas,Lambdas_OOS,ShowFullOutPut);
//---

Una vez que el objeto CCordinateDescent haya completado el entrenamiento, los resultados se podrán enviar opcionalmente al terminal.

Comment("coordinate descent engagement...");
//---initialize CD object
   cdmodel=new CCoordinateDescent(size_predictors,size_insample,UseCovarUpdates,0);
//---
   if(cdmodel==NULL)
     {
      Print("error creating Coordinate Descent object ");
      return;
     }
//---set the parameters and data
   cdmodel.SetData(0,size_insample,predictors_matrix,targets);
//---
   Print("optimal lambda ",DoubleToString(Lambda));
//---train the model
   cdmodel.Train(Alpha,Lambda,(int)MaximumIterations,1.e-7,UseFastTest,UseWarmStart);
//---
   Print("explained variance ",cdmodel.GetExplainedVariance());
//---optionally output results of training here
   if(ShowFullOutPut)
     {
      k=0;
      string output;
      for(uint iperiod=0; iperiod<Num_MA_periods; iperiod++)
        {
         longmaperiod=(int)(iperiod+1)*int(MA_period_inc);
         output+=StringFormat("\n%5d ", longmaperiod) ;
         shortmaperiod = (longmaperiod>=2)?int(longmaperiod/2):longmaperiod;
         output+=StringFormat(",%5d ,%9.9lf ", shortmaperiod,cdmodel.GetBetaAt(k));
         ++k;
        }
      Print(output);
     }
//---

El resultado del programa se mostrará en columnas: la primera columna mostrará el periodo de la media móvil larga, la segunda mostrá la media móvil corta correspondiente y, finalmente, se indicará el valor beta para ese predictor en particular. Si se muestra cero, esto significará que el predictor ha sido descartado.

double sum=0.0;                //cumulated predictions
   double pred;                   //a prediction
   int xptr;
   k=size_observations - (size_insample+maxperiod) - 1;
//---
   Comment("test the model...");
//---do the out of sample test
   for(int i=k ; i<size_observations ; i++)
     {
      xptr = i*size_predictors ;
      pred = 0.0 ;
      for(int ivar=0 ; ivar<int(size_predictors) ; ivar++)
         pred += cdmodel.GetBetaAt(ivar) * (predictors_matrix[xptr+ivar] - cdmodel.GetXmeansAt(ivar)) / cdmodel.GetXscalesAt(ivar) ;
      pred = pred * cdmodel.GetYscale() + cdmodel.GetYmean() ; // Unscale prediction to get it back in original Y domain
      if(pred > 0.0)
         sum += targets[i] ;
      else
         if(pred < 0.0)
            sum -= targets[i] ;
     }
//---
   PrintFormat("OOS total return = %.5lf (%.3lf percent)",sum, 100.0 * (exp(sum) - 1.0)) ;
//---
   delete cdmodel;
//---
   Comment("");

El programa finalizará después de comprobar el rendimiento durante el periodo de prueba seleccionado. Los usuarios deberán tener en cuenta que el valor de rendimiento mostrado al final del programa no supondrá una indicación del rendimiento real, ya que no se tendrá en cuenta una parte significativa. Estas cifras deberán usarse en comparación con otros resultados obtenidos usando diferentes conjuntos de parámetros del programa.

El siguiente resultado mostrará los resultados cuando Alfa es igual a 0. Como hemos anteriormente, cuando alfa es 0, no habrá regularización, el modelo se construirá utilizando todos los predictores proporcionados y no se excluirá ninguno.

DH      0       19:58:47.521    ELN_MA (GBPUSD,D1)      optimal lambda 0.00000000
HP      0       19:58:47.552    ELN_MA (GBPUSD,D1)      explained variance 0.9914167039554915
ID      0       19:58:47.552    ELN_MA (GBPUSD,D1)      
FF      0       19:58:47.552    ELN_MA (GBPUSD,D1)          2 ,    1 ,1.85143599128379721108e+00 
JJ      0       19:58:47.552    ELN_MA (GBPUSD,D1)          4 ,    2 ,-2.44139247803866465958e+00 
MR      0       19:58:47.552    ELN_MA (GBPUSD,D1)          6 ,    3 ,2.32230838054034549600e+00 
HF      0       19:58:47.552    ELN_MA (GBPUSD,D1)          8 ,    4 ,-2.35763762038486313077e-01 
FJ      0       19:58:47.552    ELN_MA (GBPUSD,D1)         10 ,    5 ,-5.12822602346063693979e-01 
MP      0       19:58:47.552    ELN_MA (GBPUSD,D1)         12 ,    6 ,-2.63526268082343251287e-01 
CF      0       19:58:47.552    ELN_MA (GBPUSD,D1)         14 ,    7 ,-4.66454472659737495732e-02 
FN      0       19:58:47.552    ELN_MA (GBPUSD,D1)         16 ,    8 ,6.22551516067148258404e-02 
KP      0       19:58:47.552    ELN_MA (GBPUSD,D1)         18 ,    9 ,9.45364603399752728707e-02 
JK      0       19:58:47.552    ELN_MA (GBPUSD,D1)         20 ,   10 ,8.71627177974267641769e-02 
JM      0       19:58:47.552    ELN_MA (GBPUSD,D1)         22 ,   11 ,6.43970377784374714558e-02 
CG      0       19:58:47.552    ELN_MA (GBPUSD,D1)         24 ,   12 ,3.92137206481772693234e-02 
FI      0       19:58:47.552    ELN_MA (GBPUSD,D1)         26 ,   13 ,1.74528224486318189745e-02 
HS      0       19:58:47.552    ELN_MA (GBPUSD,D1)         28 ,   14 ,1.04642691815316421500e-03 
PG      0       19:58:47.552    ELN_MA (GBPUSD,D1)         30 ,   15 ,-9.98741520244338966406e-03 
RM      0       19:58:47.552    ELN_MA (GBPUSD,D1)         32 ,   16 ,-1.64348263919291276425e-02 
CS      0       19:58:47.552    ELN_MA (GBPUSD,D1)         34 ,   17 ,-1.93143258653755492404e-02 
QI      0       19:58:47.552    ELN_MA (GBPUSD,D1)         36 ,   18 ,-1.96075858211104264717e-02 
FO      0       19:58:47.552    ELN_MA (GBPUSD,D1)         38 ,   19 ,-1.81510403514190954422e-02 
RD      0       19:58:47.552    ELN_MA (GBPUSD,D1)         40 ,   20 ,-1.56082180218151990447e-02 
PJ      0       19:58:47.552    ELN_MA (GBPUSD,D1)         42 ,   21 ,-1.24793265043600110076e-02 
HP      0       19:58:47.552    ELN_MA (GBPUSD,D1)         44 ,   22 ,-9.12541199880392318866e-03 
MF      0       19:58:47.552    ELN_MA (GBPUSD,D1)         46 ,   23 ,-5.79584482050124645547e-03 
DL      0       19:58:47.552    ELN_MA (GBPUSD,D1)         48 ,   24 ,-2.65399377323665905393e-03 
PP      0       19:58:47.552    ELN_MA (GBPUSD,D1)         50 ,   25 ,2.00883928121427593472e-04 
RJ      0       19:58:47.552    ELN_MA (GBPUSD,D1)         52 ,   26 ,2.71594753051577000869e-03 
IL      0       19:58:47.552    ELN_MA (GBPUSD,D1)         54 ,   27 ,4.87097208116808733092e-03 
IF      0       19:58:47.552    ELN_MA (GBPUSD,D1)         56 ,   28 ,6.66787159270224374930e-03 
MH      0       19:58:47.552    ELN_MA (GBPUSD,D1)         58 ,   29 ,8.12292277995673578372e-03 
NR      0       19:58:47.552    ELN_MA (GBPUSD,D1)         60 ,   30 ,9.26111235731779183777e-03 
JG      0       19:58:47.568    ELN_MA (GBPUSD,D1)      OOS total return = 3.42660 (2977.187 percent)

A continuación le mostramos los datos de salida con Alfa igual a 0,1. Resultarán de especial interés los valores beta en comparación con la ejecución anterior. Los valores beta cero indicarán que se ha eliminado el predictor correspondiente.

NP      0       19:53:32.412    ELN_MA (GBPUSD,D1)      optimal lambda 0.00943815
HH      0       19:53:32.458    ELN_MA (GBPUSD,D1)      explained variance 0.9748473636648924
GL      0       19:53:32.458    ELN_MA (GBPUSD,D1)      
GN      0       19:53:32.458    ELN_MA (GBPUSD,D1)          2 ,    1 ,1.41004781317849103850e+00 
MR      0       19:53:32.458    ELN_MA (GBPUSD,D1)          4 ,    2 ,-6.98106822708694618740e-01 
DJ      0       19:53:32.458    ELN_MA (GBPUSD,D1)          6 ,    3 ,0.00000000000000000000e+00 
NL      0       19:53:32.458    ELN_MA (GBPUSD,D1)          8 ,    4 ,1.30221271072762545540e-01 
MG      0       19:53:32.458    ELN_MA (GBPUSD,D1)         10 ,    5 ,1.13824982442231326107e-01 
DI      0       19:53:32.458    ELN_MA (GBPUSD,D1)         12 ,    6 ,0.00000000000000000000e+00 
IS      0       19:53:32.458    ELN_MA (GBPUSD,D1)         14 ,    7 ,0.00000000000000000000e+00 
NE      0       19:53:32.458    ELN_MA (GBPUSD,D1)         16 ,    8 ,0.00000000000000000000e+00 
GO      0       19:53:32.458    ELN_MA (GBPUSD,D1)         18 ,    9 ,0.00000000000000000000e+00 
JP      0       19:53:32.458    ELN_MA (GBPUSD,D1)         20 ,   10 ,0.00000000000000000000e+00 
DH      0       19:53:32.458    ELN_MA (GBPUSD,D1)         22 ,   11 ,-3.69006880128594713653e-02 
OM      0       19:53:32.458    ELN_MA (GBPUSD,D1)         24 ,   12 ,-2.43715386443472993572e-02 
LS      0       19:53:32.458    ELN_MA (GBPUSD,D1)         26 ,   13 ,-3.50967791710741789518e-03 
DK      0       19:53:32.458    ELN_MA (GBPUSD,D1)         28 ,   14 ,0.00000000000000000000e+00 
LM      0       19:53:32.458    ELN_MA (GBPUSD,D1)         30 ,   15 ,0.00000000000000000000e+00 
KG      0       19:53:32.458    ELN_MA (GBPUSD,D1)         32 ,   16 ,0.00000000000000000000e+00 
RI      0       19:53:32.458    ELN_MA (GBPUSD,D1)         34 ,   17 ,0.00000000000000000000e+00 
ES      0       19:53:32.458    ELN_MA (GBPUSD,D1)         36 ,   18 ,0.00000000000000000000e+00 
PE      0       19:53:32.458    ELN_MA (GBPUSD,D1)         38 ,   19 ,0.00000000000000000000e+00 
KO      0       19:53:32.458    ELN_MA (GBPUSD,D1)         40 ,   20 ,0.00000000000000000000e+00 
NQ      0       19:53:32.458    ELN_MA (GBPUSD,D1)         42 ,   21 ,0.00000000000000000000e+00 
QK      0       19:53:32.458    ELN_MA (GBPUSD,D1)         44 ,   22 ,0.00000000000000000000e+00 
PM      0       19:53:32.458    ELN_MA (GBPUSD,D1)         46 ,   23 ,0.00000000000000000000e+00 
GG      0       19:53:32.458    ELN_MA (GBPUSD,D1)         48 ,   24 ,0.00000000000000000000e+00 
OI      0       19:53:32.458    ELN_MA (GBPUSD,D1)         50 ,   25 ,0.00000000000000000000e+00 
PS      0       19:53:32.458    ELN_MA (GBPUSD,D1)         52 ,   26 ,0.00000000000000000000e+00 
RE      0       19:53:32.458    ELN_MA (GBPUSD,D1)         54 ,   27 ,1.14149417738317331301e-03 
FO      0       19:53:32.458    ELN_MA (GBPUSD,D1)         56 ,   28 ,3.18638349345921325848e-03 
IQ      0       19:53:32.458    ELN_MA (GBPUSD,D1)         58 ,   29 ,3.87574752936066481077e-03 
KK      0       19:53:32.458    ELN_MA (GBPUSD,D1)         60 ,   30 ,3.16472282935538083357e-03 
QN      0       19:53:32.474    ELN_MA (GBPUSD,D1)      OOS total return = 3.40954 (2925.133 percent)

A continuación, observaremos el resultado cuando Alpha es igual a 0,9. Esta vez destacaremos el resultado de LambdaOptimize. La primera columna mostrará el valor lambda probado, la segunda columna mostrará el número de predictores incluidos en el modelo, mientras que la última columna mostrará la proporción de varianza explicada de la prueba para una convolución particular. En el script especificaremos 10 convoluciones, lo cual significa que habrá diez recuadros con estos datos.

ME      0       19:57:21.630    ELN_MA (GBPUSD,D1)      OptimizeLambda starting for 10 folds with max lambda=1.048683301
JE      0       19:57:21.833    ELN_MA (GBPUSD,D1)      
RO      0       19:57:21.833    ELN_MA (GBPUSD,D1)      Descending lambda path...
RE      0       19:57:21.833    ELN_MA (GBPUSD,D1)         1.0487    0       0.0000
NM      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.9108    1       0.2009
ND      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.7910    1       0.3586
RL      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.6870    1       0.4813
LD      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.5967    1       0.5764
OL      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.5182    1       0.6499
KG      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.4501    1       0.7065
LO      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.3909    1       0.7500
JG      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.3395    1       0.7833
QO      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.2949    1       0.8088
OF      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.2561    1       0.8282
CN      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.2224    1       0.8431
CF      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.1932    1       0.8544
HN      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.1678    1       0.8630
LI      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.1457    1       0.8695
GQ      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.1266    1       0.8744
LI      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.1099    2       0.8788
QQ      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0955    2       0.8914
PH      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0829    2       0.9019
IP      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0720    2       0.9098
EH      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0625    2       0.9159
RP      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0543    2       0.9205
EK      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0472    3       0.9325
HS      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0410    2       0.9424
NK      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0356    2       0.9467
HS      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0309    2       0.9500
KJ      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0268    2       0.9525
JR      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0233    3       0.9556
GJ      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0202    3       0.9586
NR      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0176    4       0.9610
CM      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0153    3       0.9635
CE      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0133    4       0.9656
OM      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0115    3       0.9677
PE      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0100    3       0.9689
QL      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0087    5       0.9707
CD      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0075    4       0.9732
RL      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0066    5       0.9745
ND      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0057    5       0.9756
NO      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0049    4       0.9767
HG      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0043    4       0.9776
IO      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0037    5       0.9784
EG      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0032    6       0.9793
KN      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0028    6       0.9808
DF      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0024    8       0.9825
HN      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0021    6       0.9840
PF      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0018    7       0.9847
OQ      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0016    7       0.9855
OI      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0014    5       0.9862
DQ      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0012    7       0.9867
MI      0       19:57:21.833    ELN_MA (GBPUSD,D1)         0.0010    8       0.9874
KS      0       19:57:22.068    ELN_MA (GBPUSD,D1)      
OF      0       19:57:22.068    ELN_MA (GBPUSD,D1)      Descending lambda path...
OL      0       19:57:22.068    ELN_MA (GBPUSD,D1)         1.0487    0       0.0000
RG      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.9108    1       0.2006
PO      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.7910    1       0.3583
JG      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.6870    1       0.4810
RO      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.5967    1       0.5761
NF      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.5182    1       0.6495
RN      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.4501    1       0.7061
OF      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.3909    1       0.7496
RN      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.3395    1       0.7829
LI      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.2949    1       0.8084
NQ      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.2561    1       0.8279
OI      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.2224    1       0.8427
JQ      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.1932    1       0.8540
LH      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.1678    1       0.8626
QP      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.1457    1       0.8691
MH      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.1266    1       0.8741
IP      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.1099    3       0.8794
NK      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0955    2       0.8929
PS      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0829    2       0.9029
NK      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0720    2       0.9106
RS      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0625    2       0.9164
JJ      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0543    3       0.9225
MR      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0472    3       0.9348
KJ      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0410    2       0.9433
MR      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0356    2       0.9474
KM      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0309    2       0.9506
JE      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0268    2       0.9529
FM      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0233    3       0.9559
KE      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0202    3       0.9589
DL      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0176    3       0.9616
CD      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0153    3       0.9636
ML      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0133    3       0.9663
CD      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0115    3       0.9678
KO      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0100    4       0.9691
EG      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0087    5       0.9719
RO      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0075    5       0.9737
KG      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0066    4       0.9751
IN      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0057    5       0.9763
MF      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0049    4       0.9774
FN      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0043    4       0.9784
EF      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0037    5       0.9792
QQ      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0032    6       0.9802
NI      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0028    7       0.9818
HQ      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0024    7       0.9834
EI      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0021    5       0.9847
HP      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0018    6       0.9854
KH      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0016    7       0.9861
FP      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0014    5       0.9866
GH      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0012    6       0.9871
PS      0       19:57:22.068    ELN_MA (GBPUSD,D1)         0.0010    7       0.9877
MH      0       19:57:22.318    ELN_MA (GBPUSD,D1)      
EL      0       19:57:22.318    ELN_MA (GBPUSD,D1)      Descending lambda path...
CF      0       19:57:22.318    ELN_MA (GBPUSD,D1)         1.0487    1       0.0003
HN      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.9108    1       0.2020
IF      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.7910    1       0.3597
QQ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.6870    1       0.4824
GI      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.5967    1       0.5775
LQ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.5182    1       0.6510
JI      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.4501    1       0.7076
OP      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.3909    1       0.7511
NH      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.3395    1       0.7845
MP      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.2949    1       0.8100
IH      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.2561    1       0.8294
CS      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.2224    1       0.8443
QK      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.1932    1       0.8556
IS      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.1678    1       0.8641
QK      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.1457    1       0.8707
ER      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.1266    1       0.8756
QJ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.1099    2       0.8805
GR      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0955    2       0.8928
LJ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0829    2       0.9032
FE      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0720    2       0.9111
HM      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0625    2       0.9171
LE      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0543    2       0.9217
OM      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0472    3       0.9315
GD      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0410    3       0.9421
EL      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0356    2       0.9472
HD      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0309    2       0.9505
DL      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0268    2       0.9530
OG      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0233    3       0.9558
JO      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0202    3       0.9588
OG      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0176    4       0.9612
CO      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0153    3       0.9638
MF      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0133    4       0.9659
LN      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0115    3       0.9680
FF      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0100    4       0.9694
PN      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0087    5       0.9709
RI      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0075    4       0.9738
JQ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0066    5       0.9751
KI      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0057    5       0.9763
GQ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0049    4       0.9774
MH      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0043    4       0.9783
QP      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0037    4       0.9791
DH      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0032    5       0.9800
QP      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0028    6       0.9812
LK      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0024    7       0.9827
GS      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0021    8       0.9842
OK      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0018    6       0.9853
IS      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0016    7       0.9861
DJ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0014    6       0.9869
RR      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0012    6       0.9874
PJ      0       19:57:22.318    ELN_MA (GBPUSD,D1)         0.0010    7       0.9879
DQ      0       19:57:22.568    ELN_MA (GBPUSD,D1)      
PK      0       19:57:22.568    ELN_MA (GBPUSD,D1)      Descending lambda path...
KQ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         1.0487    1       0.0004
FI      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.9108    1       0.2021
IP      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.7910    1       0.3598
KH      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.6870    1       0.4825
LP      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.5967    1       0.5777
RH      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.5182    1       0.6511
IS      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.4501    1       0.7078
KK      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.3909    1       0.7512
JS      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.3395    1       0.7846
OK      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.2949    1       0.8101
KR      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.2561    1       0.8295
CJ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.2224    1       0.8444
CR      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.1932    1       0.8557
FJ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.1678    1       0.8643
QE      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.1457    1       0.8708
GM      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.1266    1       0.8757
OE      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.1099    2       0.8808
NM      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0955    2       0.8931
CD      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0829    2       0.9034
IL      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0720    2       0.9113
KD      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0625    2       0.9173
DL      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0543    2       0.9218
RG      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0472    3       0.9319
IO      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0410    3       0.9424
NG      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0356    2       0.9474
CO      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0309    2       0.9507
OF      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0268    2       0.9532
CN      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0233    3       0.9560
DF      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0202    3       0.9590
PN      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0176    3       0.9613
QI      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0153    3       0.9639
PQ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0133    4       0.9659
JI      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0115    3       0.9681
GQ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0100    4       0.9694
LH      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0087    6       0.9710
LP      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0075    5       0.9738
LH      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0066    4       0.9751
QP      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0057    4       0.9763
MK      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0049    5       0.9774
OS      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0043    5       0.9783
CK      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0037    5       0.9791
JS      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0032    5       0.9801
DJ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0028    7       0.9813
DR      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0024    7       0.9828
HJ      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0021    7       0.9843
NR      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0018    6       0.9853
KM      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0016    7       0.9860
NE      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0014    5       0.9867
IM      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0012    6       0.9872
GE      0       19:57:22.568    ELN_MA (GBPUSD,D1)         0.0010    8       0.9878
JO      0       19:57:22.740    ELN_MA (GBPUSD,D1)      
RQ      0       19:57:22.740    ELN_MA (GBPUSD,D1)      Descending lambda path...
PK      0       19:57:22.740    ELN_MA (GBPUSD,D1)         1.0487    1       0.0003
DS      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.9108    1       0.2021
GK      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.7910    1       0.3598
MS      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.6870    1       0.4825
MJ      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.5967    1       0.5776
PR      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.5182    1       0.6511
NJ      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.4501    1       0.7077
MR      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.3909    1       0.7512
IM      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.3395    1       0.7845
RE      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.2949    1       0.8100
MM      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.2561    1       0.8295
HE      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.2224    1       0.8443
FL      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.1932    1       0.8556
CD      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.1678    1       0.8642
OL      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.1457    1       0.8708
ID      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.1266    1       0.8757
DO      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.1099    2       0.8807
DG      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0955    2       0.8928
GO      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0829    2       0.9032
HG      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0720    2       0.9112
NN      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0625    2       0.9172
FF      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0543    2       0.9218
JN      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0472    3       0.9313
MF      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0410    3       0.9419
RQ      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0356    2       0.9472
CI      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0309    2       0.9505
PQ      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0268    2       0.9531
LI      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0233    3       0.9558
PP      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0202    4       0.9588
QH      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0176    3       0.9612
PP      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0153    3       0.9638
DH      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0133    4       0.9657
GS      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0115    3       0.9680
IK      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0100    4       0.9694
DS      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0087    5       0.9708
GK      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0075    5       0.9737
MR      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0066    4       0.9750
PJ      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0057    4       0.9762
RR      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0049    5       0.9773
RJ      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0043    5       0.9782
FE      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0037    5       0.9790
GM      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0032    5       0.9800
FE      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0028    6       0.9812
OM      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0024    7       0.9827
ID      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0021    7       0.9842
KL      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0018    6       0.9852
ND      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0016    6       0.9860
LL      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0014    5       0.9867
GG      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0012    6       0.9872
IO      0       19:57:22.740    ELN_MA (GBPUSD,D1)         0.0010    7       0.9877
KD      0       19:57:23.052    ELN_MA (GBPUSD,D1)      
OH      0       19:57:23.052    ELN_MA (GBPUSD,D1)      Descending lambda path...
RR      0       19:57:23.052    ELN_MA (GBPUSD,D1)         1.0487    1       0.0002
DJ      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.9108    1       0.2019
LR      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.7910    1       0.3596
JM      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.6870    1       0.4823
ME      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.5967    1       0.5775
RM      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.5182    1       0.6509
LE      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.4501    1       0.7076
FL      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.3909    1       0.7510
GD      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.3395    1       0.7844
HL      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.2949    1       0.8099
RD      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.2561    1       0.8293
RO      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.2224    1       0.8442
FG      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.1932    1       0.8555
KO      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.1678    1       0.8641
DG      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.1457    1       0.8706
RN      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.1266    1       0.8755
DF      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.1099    2       0.8804
HN      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0955    2       0.8927
GF      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0829    2       0.9031
OQ      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0720    2       0.9110
MI      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0625    2       0.9170
IQ      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0543    2       0.9216
DI      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0472    3       0.9316
LP      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0410    3       0.9422
OH      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0356    2       0.9472
NP      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0309    2       0.9505
RH      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0268    2       0.9530
ES      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0233    3       0.9558
LK      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0202    3       0.9588
ES      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0176    4       0.9612
DK      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0153    3       0.9637
HR      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0133    4       0.9658
JJ      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0115    3       0.9680
MR      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0100    4       0.9693
CJ      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0087    6       0.9709
RE      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0075    5       0.9737
LM      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0066    4       0.9750
IE      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0057    4       0.9762
OM      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0049    5       0.9773
GD      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0043    5       0.9782
CL      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0037    5       0.9790
CD      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0032    5       0.9799
DL      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0028    7       0.9812
JG      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0024    7       0.9827
HO      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0021    6       0.9843
CG      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0018    5       0.9852
LO      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0016    7       0.9860
EF      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0014    5       0.9867
JN      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0012    6       0.9872
EF      0       19:57:23.052    ELN_MA (GBPUSD,D1)         0.0010    8       0.9877
KM      0       19:57:23.302    ELN_MA (GBPUSD,D1)      
CG      0       19:57:23.302    ELN_MA (GBPUSD,D1)      Descending lambda path...
EM      0       19:57:23.302    ELN_MA (GBPUSD,D1)         1.0487    1       0.0003
ID      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.9108    1       0.2021
NL      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.7910    1       0.3598
PD      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.6870    1       0.4825
HL      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.5967    1       0.5776
MG      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.5182    1       0.6511
GO      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.4501    1       0.7077
PG      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.3909    1       0.7512
MO      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.3395    1       0.7846
KF      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.2949    1       0.8100
HN      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.2561    1       0.8295
HF      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.2224    1       0.8444
PN      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.1932    1       0.8557
JI      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.1678    1       0.8642
FQ      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.1457    1       0.8708
DI      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.1266    1       0.8757
PQ      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.1099    2       0.8804
LH      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0955    2       0.8927
KP      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0829    2       0.9031
DH      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0720    2       0.9111
JP      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0625    2       0.9171
NK      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0543    2       0.9217
PS      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0472    3       0.9316
HK      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0410    3       0.9422
CS      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0356    2       0.9472
JJ      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0309    2       0.9505
ER      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0268    2       0.9531
RJ      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0233    3       0.9559
GR      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0202    3       0.9589
LM      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0176    3       0.9612
EE      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0153    3       0.9638
LM      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0133    4       0.9658
NE      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0115    3       0.9680
IL      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0100    4       0.9693
OD      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0087    6       0.9709
EL      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0075    4       0.9737
GD      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0066    4       0.9751
NO      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0057    4       0.9763
CG      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0049    5       0.9773
KO      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0043    5       0.9782
PG      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0037    4       0.9790
FN      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0032    5       0.9800
PF      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0028    7       0.9812
NN      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0024    7       0.9827
LF      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0021    7       0.9842
RQ      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0018    6       0.9852
HI      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0016    7       0.9860
PQ      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0014    6       0.9867
NI      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0012    6       0.9872
QP      0       19:57:23.302    ELN_MA (GBPUSD,D1)         0.0010    8       0.9877
EK      0       19:57:23.537    ELN_MA (GBPUSD,D1)      
QM      0       19:57:23.537    ELN_MA (GBPUSD,D1)      Descending lambda path...
PG      0       19:57:23.537    ELN_MA (GBPUSD,D1)         1.0487    1       0.0002
NO      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.9108    1       0.2019
NG      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.7910    1       0.3596
PO      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.6870    1       0.4823
KF      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.5967    1       0.5775
HN      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.5182    1       0.6509
KF      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.4501    1       0.7075
LN      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.3909    1       0.7510
II      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.3395    1       0.7844
RQ      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.2949    1       0.8099
PI      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.2561    1       0.8293
HQ      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.2224    1       0.8442
DH      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.1932    1       0.8555
FP      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.1678    1       0.8640
FH      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.1457    1       0.8706
HP      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.1266    1       0.8755
FK      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.1099    2       0.8804
RS      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0955    2       0.8927
IK      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0829    2       0.9031
IS      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0720    2       0.9110
KJ      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0625    2       0.9170
OR      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0543    2       0.9216
FJ      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0472    3       0.9316
CR      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0410    3       0.9421
QM      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0356    2       0.9472
DE      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0309    2       0.9505
PM      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0268    2       0.9530
KE      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0233    3       0.9558
NL      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0202    3       0.9588
KD      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0176    4       0.9612
FL      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0153    3       0.9637
RD      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0133    4       0.9658
HO      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0115    3       0.9680
CG      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0100    4       0.9693
EO      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0087    6       0.9709
HG      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0075    5       0.9737
NN      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0066    4       0.9750
OF      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0057    4       0.9762
QN      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0049    5       0.9773
QF      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0043    5       0.9782
EQ      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0037    5       0.9790
HI      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0032    5       0.9800
FQ      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0028    7       0.9812
PI      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0024    7       0.9827
JP      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0021    6       0.9843
MH      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0018    5       0.9852
MP      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0016    6       0.9860
KH      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0014    5       0.9867
HS      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0012    6       0.9872
KK      0       19:57:23.537    ELN_MA (GBPUSD,D1)         0.0010    8       0.9877
PP      0       19:57:23.880    ELN_MA (GBPUSD,D1)      
HD      0       19:57:23.880    ELN_MA (GBPUSD,D1)      Descending lambda path...
GN      0       19:57:23.880    ELN_MA (GBPUSD,D1)         1.0487    1       0.0000
DF      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.9108    1       0.2018
FQ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.7910    1       0.3595
JI      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.6870    1       0.4822
HQ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.5967    1       0.5773
RI      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.5182    1       0.6508
EP      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.4501    1       0.7074
MH      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.3909    1       0.7509
NP      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.3395    1       0.7842
MH      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.2949    1       0.8097
JS      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.2561    1       0.8292
OK      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.2224    1       0.8440
OS      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.1932    1       0.8553
IK      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.1678    1       0.8639
MR      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.1457    1       0.8704
RJ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.1266    1       0.8754
KR      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.1099    2       0.8804
NJ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0955    2       0.8928
PE      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0829    2       0.9031
PM      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0720    2       0.9110
FE      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0625    2       0.9170
GM      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0543    2       0.9215
ID      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0472    3       0.9318
LL      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0410    3       0.9423
HD      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0356    2       0.9472
ML      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0309    2       0.9505
IG      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0268    2       0.9530
FO      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0233    3       0.9558
CG      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0202    3       0.9588
FO      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0176    4       0.9612
KF      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0153    3       0.9637
HN      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0133    4       0.9659
KF      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0115    3       0.9679
NN      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0100    4       0.9693
DI      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0087    6       0.9710
QQ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0075    5       0.9737
CI      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0066    4       0.9750
JQ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0057    4       0.9762
HH      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0049    5       0.9773
HP      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0043    5       0.9782
LH      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0037    5       0.9790
DP      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0032    5       0.9799
KK      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0028    7       0.9812
LS      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0024    7       0.9828
OK      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0021    6       0.9843
DS      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0018    5       0.9852
DJ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0016    6       0.9860
ER      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0014    5       0.9866
RJ      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0012    7       0.9872
OR      0       19:57:23.880    ELN_MA (GBPUSD,D1)         0.0010    7       0.9877
EN      0       19:57:24.130    ELN_MA (GBPUSD,D1)      
IS      0       19:57:24.130    ELN_MA (GBPUSD,D1)      Descending lambda path...
EI      0       19:57:24.130    ELN_MA (GBPUSD,D1)         1.0487    1       0.0005
EP      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.9108    1       0.2023
RH      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.7910    1       0.3600
LP      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.6870    1       0.4827
PH      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.5967    1       0.5778
QS      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.5182    1       0.6513
OK      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.4501    1       0.7079
PS      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.3909    1       0.7514
PK      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.3395    1       0.7847
OR      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.2949    1       0.8102
DJ      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.2561    1       0.8297
ER      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.2224    1       0.8445
GJ      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.1932    1       0.8558
JE      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.1678    1       0.8644
GM      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.1457    1       0.8709
LE      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.1266    1       0.8759
JM      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.1099    2       0.8808
DD      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0955    2       0.8929
OL      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0829    2       0.9033
HD      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0720    2       0.9113
FL      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0625    2       0.9173
FG      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0543    2       0.9219
RO      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0472    3       0.9312
MG      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0410    3       0.9418
JO      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0356    2       0.9473
EF      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0309    2       0.9506
GN      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0268    2       0.9531
QF      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0233    4       0.9559
HN      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0202    4       0.9589
QI      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0176    3       0.9613
HQ      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0153    3       0.9639
RI      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0133    4       0.9658
OQ      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0115    3       0.9681
JH      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0100    5       0.9695
KP      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0087    4       0.9709
NH      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0075    4       0.9738
CP      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0066    5       0.9752
NK      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0057    5       0.9764
CS      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0049    4       0.9774
RK      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0043    5       0.9783
LS      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0037    4       0.9792
GJ      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0032    5       0.9801
NR      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0028    7       0.9812
PJ      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0024    7       0.9827
RR      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0021    7       0.9842
KM      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0018    6       0.9853
EE      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0016    7       0.9861
NM      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0014    6       0.9867
OE      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0012    6       0.9873
KL      0       19:57:24.130    ELN_MA (GBPUSD,D1)         0.0010    7       0.9878
HG      0       19:57:24.146    ELN_MA (GBPUSD,D1)      
PG      0       19:57:24.146    ELN_MA (GBPUSD,D1)      OptimizeLambda ending with best lambda=0.001048683  explained=0.987563916

Tenga en cuenta que cuando el valor lambda sea máximo, el número de predictores activos será cero y este valor aumentará a medida que lambda disminuya en cada iteración. El número de predictores seleccionados aumentará o disminuirá a medida que el algoritmo decida qué valor lambda será el mejor. El modelo resultante acabará descartando algunos valores de indicadores adicionales que considere innecesarios.

PE      0       19:57:24.177    ELN_MA (GBPUSD,D1)      optimal lambda 0.00104868
GM      0       19:57:24.287    ELN_MA (GBPUSD,D1)      explained variance 0.9871030095923066
DK      0       19:57:24.287    ELN_MA (GBPUSD,D1)      
NS      0       19:57:24.287    ELN_MA (GBPUSD,D1)          2 ,    1 ,1.70372722883263016946e+00 
RG      0       19:57:24.287    ELN_MA (GBPUSD,D1)          4 ,    2 ,-1.67483731989555195696e+00 
QO      0       19:57:24.287    ELN_MA (GBPUSD,D1)          6 ,    3 ,1.07905337481491181428e+00 
PQ      0       19:57:24.287    ELN_MA (GBPUSD,D1)          8 ,    4 ,0.00000000000000000000e+00 
HJ      0       19:57:24.287    ELN_MA (GBPUSD,D1)         10 ,    5 ,0.00000000000000000000e+00 
LN      0       19:57:24.287    ELN_MA (GBPUSD,D1)         12 ,    6 ,-1.81038986082938974098e-01 
DF      0       19:57:24.287    ELN_MA (GBPUSD,D1)         14 ,    7 ,0.00000000000000000000e+00 
OH      0       19:57:24.287    ELN_MA (GBPUSD,D1)         16 ,    8 ,0.00000000000000000000e+00 
FR      0       19:57:24.287    ELN_MA (GBPUSD,D1)         18 ,    9 ,0.00000000000000000000e+00 
CE      0       19:57:24.287    ELN_MA (GBPUSD,D1)         20 ,   10 ,0.00000000000000000000e+00 
FO      0       19:57:24.287    ELN_MA (GBPUSD,D1)         22 ,   11 ,0.00000000000000000000e+00 
IQ      0       19:57:24.287    ELN_MA (GBPUSD,D1)         24 ,   12 ,0.00000000000000000000e+00 
HK      0       19:57:24.287    ELN_MA (GBPUSD,D1)         26 ,   13 ,0.00000000000000000000e+00 
OM      0       19:57:24.287    ELN_MA (GBPUSD,D1)         28 ,   14 ,0.00000000000000000000e+00 
GG      0       19:57:24.287    ELN_MA (GBPUSD,D1)         30 ,   15 ,0.00000000000000000000e+00 
HI      0       19:57:24.287    ELN_MA (GBPUSD,D1)         32 ,   16 ,0.00000000000000000000e+00 
ES      0       19:57:24.287    ELN_MA (GBPUSD,D1)         34 ,   17 ,0.00000000000000000000e+00 
RE      0       19:57:24.287    ELN_MA (GBPUSD,D1)         36 ,   18 ,0.00000000000000000000e+00 
CO      0       19:57:24.287    ELN_MA (GBPUSD,D1)         38 ,   19 ,0.00000000000000000000e+00 
HQ      0       19:57:24.287    ELN_MA (GBPUSD,D1)         40 ,   20 ,0.00000000000000000000e+00 
IK      0       19:57:24.287    ELN_MA (GBPUSD,D1)         42 ,   21 ,0.00000000000000000000e+00 
FM      0       19:57:24.287    ELN_MA (GBPUSD,D1)         44 ,   22 ,0.00000000000000000000e+00 
CG      0       19:57:24.287    ELN_MA (GBPUSD,D1)         46 ,   23 ,0.00000000000000000000e+00 
LI      0       19:57:24.287    ELN_MA (GBPUSD,D1)         48 ,   24 ,0.00000000000000000000e+00 
DS      0       19:57:24.287    ELN_MA (GBPUSD,D1)         50 ,   25 ,0.00000000000000000000e+00 
CE      0       19:57:24.287    ELN_MA (GBPUSD,D1)         52 ,   26 ,0.00000000000000000000e+00 
JO      0       19:57:24.287    ELN_MA (GBPUSD,D1)         54 ,   27 ,0.00000000000000000000e+00 
MQ      0       19:57:24.287    ELN_MA (GBPUSD,D1)         56 ,   28 ,0.00000000000000000000e+00 
HK      0       19:57:24.287    ELN_MA (GBPUSD,D1)         58 ,   29 ,0.00000000000000000000e+00 
IM      0       19:57:24.287    ELN_MA (GBPUSD,D1)         60 ,   30 ,0.00000000000000000000e+00 
PD      0       19:57:24.287    ELN_MA (GBPUSD,D1)      OOS total return = 3.42215 (2963.528 percent)

Conclusión

La regresión neta elástica resulta bastante notable en cuanto a sus capacidades, pero no supone una solución mágica, ya que definir el modelo implicará una serie de variables críticas que requerirán clarificación. Además del tipo de regularización a elegir, el usuario aún deberá comprender otros aspectos como el criterio de convergencia. A pesar de estas deficiencias, no podemos negar que se trata de una herramienta útil.

Nombre del archivo	Descripción
MQL5\Indicators\LogPrices.mq5	Indicador de conversión logarítmica de precios brutos. Su identificador se puede transmitir al llamar a otro indicador.
MQL5\Include\CoordinateDescent.mqh	Archivo de inclusión que contiene la definición de la clase CCoordinateDescent así como la función OptimizeLambda().
MQL5\Scripts\ELN_MA.mq5	Script de ejemplo que utiliza una red elástica para construir un modelo predictivo basado en varios indicadores de media móvil.