Elastische Netzregression mit Koordinatenabstieg in MQL5

Einführung

Die Elastische Netzregression (elastic net regression) kombiniert die besten Eigenschaften der Ridge- und Lasso-Techniken, um allgemeine lineare Modelle zu erstellen. Die Anwendung dieser Methode ermöglicht es, einen der Hauptnachteile der Regression, die Überanpassung, zu minimieren. Dies ist besonders für die Entwicklung von Handelsstrategien von Bedeutung, da bekanntlich der häufigste Grund für eine schlechte Leistung oder das Scheitern einer Strategie darin besteht, dass beim Training Rauschen mit Mustern verwechselt wird. In diesem Artikel wird die Implementierung der elastischen Netzregression vorgestellt, die die Koordinatenabstiegsmethode der Optimierung in reinem MQL5 verwendet.  Gegen Ende des Artikels werden wir eine praktische Anwendung dieser Technik anhand der Entwicklung einer einfachen, auf dem gleitenden Durchschnitt basierenden Prognosestrategie demonstrieren.

Regularisierung

Bei der Erstellung von Vorhersagemodellen besteht das Ziel darin, ein Beispiel zu schaffen, das ein einzigartiges Muster erkennen lässt, das in der realen Welt genutzt werden kann. Um dies effektiv zu tun, müssen wir sicherstellen, dass das Modell relevante Muster aus den Trainingsdaten „lernt“. Das ist natürlich leichter gesagt als getan. Dies führt in der Regel dazu, dass das Modell irrelevante Informationen (Rauschen) aufnimmt, was sich letztlich negativ auf seine Leistung auswirkt. Die Regularisierung ist ein Verfahren zur Minimierung der Auswirkungen einer Überanpassung.

Die Lasso-Regressionstechnik hilft, Trainingsverzerrungen zu reduzieren, indem redundante Prädiktoren unterdrückt werden, wenn das Modell durch zu viele optimierbare Variablen definiert ist. Dadurch wird das Modell vereinfacht.

Bei der Ridge-Regression werden die Koeffizienten der Regressionsgleichung so minimiert, dass sie sich von ihrem Optimum entfernen. Dies trägt zur Verallgemeinerung des Modells bei, wobei alle Prädiktoren erhalten bleiben.

Sowohl das Lasso als auch der Ridge unterscheiden sich durch die Art des angewandten Strafbegriffs. Der Strafterm der elastischen Netzregression ist eine Kombination aus dem absoluten Wert und dem Quadrat der Koeffizienten, gewichtet mit zwei Hyperparametern, Alpha und Lambda.

Auf diese Weise steuert Alpha die Art der Regularisierung. Wenn alpha gleich Null ist, reduziert sich der Strafterm auf die l2-Norm, wenn alpha gleich 1 ist, wird die Straffunktion zur l1-Norm. Durch die Angabe von Alpha zwischen 0 und 1 können lineare Modelle erstellt werden, die bis zu einem gewissen Grad die Qualitäten von Ridge- und Lassoregression kombinieren, was durch den Hyperparameter lambda bestimmt wird, der den Grad der Regularisierung steuert.

Solche Modelle können ein Segen sein, wenn es um die Entwicklung von Handelsstrategien geht, bei denen wir oft blindlings zahlreiche Prädiktoren anwenden, in der Hoffnung, eine Kombination zu finden, die Gewinn bringt. Mit Hilfe der elastischen Netzregression können wir die Überanpassung minimieren und gleichzeitig nutzlose Indikatoren von solchen trennen, die ein bedeutendes Vorhersagepotenzial haben. Und wir können dies tun, ohne uns Gedanken darüber zu machen, wie die Indikatoren zueinander in Beziehung stehen. Es scheint fast zu schön, um wahr zu sein.

Koordinatenabstieg

Koordinatenabstieg ist eine Optimierungsmethode, die sich gut für die multivariable Optimierung eignet. Ein komplexes mehrdimensionales Optimierungsproblem wird in eine Reihe von eindimensionalen Problemen reduziert.  Erreicht durch iterative Minimierung jeder einzelnen Dimension einer Funktion, wobei die Werte der Funktion in den anderen Dimensionen statisch bleiben. Es gibt zahlreiche Quellen im Internet, die Interessierten genauere Erklärungen liefern können. Hier geht es um die Anwendung auf die Strategieentwicklung.
 
Für unsere Zwecke wird die Koordinatenabstiegsmethode auf zwei Arten bei der Implementierung der elastischen Netzregression verwendet. Zunächst wird es verwendet, um das optimale Lambda auf der Grundlage eines vom Nutzer festgelegten Alphas zu bestimmen. Danach wird die Optimierungsmethode erneut aufgerufen, um die Beta-Koeffizienten der Regressionsgleichung zu bearbeiten. Lassen Sie uns einen Blick in den Code werfen, um zu sehen, wie dies erreicht wird.

Die Klasse 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) ;
  } ;

Die Klasse CCoordinateDescent ist in der Datei CoordinateDescent.mqh definiert. Ihr Konstruktor ist parametrisch und wird zur Angabe wichtiger Merkmale eines Modells verwendet, aber bevor wir uns damit befassen, gibt es einige sachdienliche Fragen zu einem bestimmten zu verwendenden Datenkonstrukt.

Die Bibliothek, die wir spezifizieren werden, wird keine eindeutigen Datentypen verwenden, wie etwa die neuen Matrix- und Vektortypen von MQL5. Damit soll die Kompatibilität mit mql4 gewährleistet werden. Da es keine Möglichkeit gibt, mehrdimensionale Arrays dynamisch zu definieren, werden Matrizen als normale flache Arrays dargestellt. Das Konstrukt lässt sich am besten an einem Beispiel erläutern.
 
Angenommen, wir wollen eine Matrix mit 4 Zeilen und 3 Spalten definieren. Wir würden ein Array der Größe 4 multipliziert mit 3, also 12, erstellen. Die Elemente dieses Arrays werden so angeordnet, wie sie bei Verwendung des integrierten Matrix-Datentyps erscheinen würden. Das heißt, dass in unserem Beispiel zuerst die Mitglieder der ersten Reihe angegeben werden, dann die Mitglieder der zweiten Reihe und so weiter. Der folgende Codeschnipsel veranschaulicht die Erstellung einer 4 x 3-Matrix, bei der jeder Wert in einer Spalte gleich groß ist.

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

Ausgabe von 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 

Beim Durchlaufen des Arrays in Matrixform haben wir den Zeilenindex * die Anzahl der Spalten + den Spaltenindex. Instanzen, in denen solche Array-Konstrukte erforderlich sind, werden alle durch das Suffix _matrix entweder an einem Klassenvariablennamen oder einem Funktionsparameternamen gekennzeichnet.

Die Verwendung dieses Konstrukts bedeutet, dass bei der Übergabe von Matrizen an Funktionen einige Funktionsparameter für die Angabe der Dimensionen einer bestimmten Matrix reserviert werden müssen. Ich bin sicher, dass es viel intuitiver wird, wenn wir gegen Ende des Artikels zur Anwendung der Klasse kommen. Den Nutzern steht es frei, die Bibliothek zu forken, wenn sie nicht an einer plattformübergreifenden Portabilität interessiert sind. Zurück zur Beschreibung der Klasse.

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

Der parametrische Konstruktor benötigt 4 Parameter:

• num_predictors legt die Anzahl der Variablen fest, d. h. die Anzahl der Prädiktoren oder Indikatoren, wobei jeder Satz von Indikatoren eine Spalte in der internen Datenmatrix belegt.

• num_observations gibt die Datenmenge an, die das Objekt erwarten sollte, d. h. die Anzahl der Zeilen oder die genaue Anzahl der Elemente, die in jedem Satz von Variablen/Prädiktoren/Indikatoren verfügbar sind.

• use_covariance_updates ist eine boolesche Option, die idealerweise verwendet werden sollte, wenn mehr num_observations als num_predictors vorhanden sind, und deren Einstellung auf true eine erhebliche Verbesserung der Ausführungszeit gegenüber der Alternative bedeutet. Diese Option sollte nur in Betracht gezogen werden, wenn num_observations > num_predictors.

• num_lambdas_to_trial legt die maximale Anzahl von Lambda-Variationen fest, die während des Trainingsprozesses getestet werden.

Der Konstruktor bereitet lediglich die internen Datenstrukturen für die Aufnahme aller erforderlichen Daten vor.

 {
   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());

  }

Sobald eine Instanz von CCoordinateDescent erstellt ist, müssen wir alle Prädiktoren und Zielwerte für die Vorverarbeitung sammeln.  Dies geschieht mit der Methode SetData. Der erste Parameter ist ein Startindex, der angibt, an welcher Stelle in den Arrays, die dieser Methode zugeführt werden, mit der Datensammlung begonnen werden soll. Diese Vorgehensweise hilft bei der späteren Kreuzvalidierung.

//+------------------------------------------------------------------+
//|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 ist ein Parametername, der bereits im Konstruktor vorkommt, hier wird er etwas anders verwendet. Wenn hier ein kleinerer Wert als der bei der Instanziierung des Objekts verwendete eingestellt wird, kann bei Erreichen dieser Indexposition zum ersten Wert im Array zurückgekehrt werden. Wenn eine solche Funktionalität nicht benötigt wird, setzen Sie diesen Wert auf denselben Wert, der im Konstruktoraufruf verwendet wird. Stellen Sie ihn nur nicht auf Null oder darunter ein. Da dies zu einem Fehler führen wird.

Der nächste erforderliche Parameter xx_matrix ist ein Array mit der besprochenen speziellen Matrixanordnung. Hier geben wir die Rohindikatoren ein. Sie sollte die im Konstruktoraufruf angegebene Größe haben, also num_observations * num_predictors.

Der letzte Parameter yy ist ein Array mit entsprechenden Zielwerten.

Die Methode standardisiert beide Eingabe-Arrays, bevor sie diese in die internen Objektpuffer kopiert.

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

Wenn SetData erfolgreich abgeschlossen ist und true zurückgibt, kann der Nutzer entweder Train() oder TrainLambda() aufrufen, je nachdem, was er tun möchte.

//+------------------------------------------------------------------+
//|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?
)

In der Methode Train() findet die Optimierung statt. Hier werden die Art der Regularisierung (alpha) und der Grad der Regularisierung (lambda) angegeben. Zusammen mit der Art des durchzuführenden Konvergenztests (fast_test) und der erforderlichen Genauigkeit für die zu erreichende Konvergenz (convergence_criterion).

• maxits ist ein Parameter für eine Sicherheitsvorkehrung. Er verhindert, dass die Routine zu viel Zeit verbraucht. Er sollte auf einen angemessen großen Wert gesetzt werden, etwa 1000 oder mehr.

• warm_start gibt an, ob das Training mit Beta-Gewichten, die auf Null initialisiert sind, begonnen werden soll oder nicht.

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

Während wir durch die Beobachtungen iterieren, berechnen wir auch den Anteil der erklärten Zielvarianz. Wenn der langsame Konvergenztest verwendet wird (fast_test auf false gesetzt), ist die Konvergenz erreicht, wenn die Änderung von einer Iteration zur nächsten kleiner ist als der angegebene Wert des Konvergenzkriteriums.

Andernfalls wird bei Verwendung der schnellen Methode Konvergenz erreicht, wenn die maximale Änderung der Beta-Anpassung unter allen Betas kleiner ist als das Konvergenzkriterium.

//+------------------------------------------------------------------+
//|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() benötigt einen einzigen Eingabeparameter, der die Art der Regularisierung angibt. Diese Methode gibt den berechneten Wert von Lambda zurück, für den alle entsprechenden Betas gleich Null sind. Die Idee ist, dass ein solcher Wert ein guter Ausgangspunkt für die Suche nach dem optimalen Lambda-Hyperparameter für ein bestimmtes Alpha ist.

Die eigentliche Optimierung von Lambda wird von TrainLambda() durchgeführt. Sie hat ähnliche Funktionsparameter wie Train(). Der Nutzer kann den Anfangswert für Lambda durch maxlambda festlegen. Wird er auf 0 oder weniger gesetzt, wird automatisch GetlambdaThreshold() aktiviert, um den wahren Startwert festzulegen. Die Hauptschleife ruft wiederholt Train() auf und speichert die Betas für jedes Lambda, und zwar für eine im Konstruktoraufruf angegebene Höchstzahl von m_nlambda-Iterationen.

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

Unsere Koordinatenabstiegsklasse ist vollständig. Als Nächstes benötigen wir ein Werkzeug, mit dem wir eine Kreuzvalidierung durchführen können, um den Lambda-Hyperparameter abzustimmen.

OptimizeLambda-Funktion

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

Sein Hauptzweck besteht darin, ein Kreuzvalidierungstraining durchzuführen, um den Lambda-Hyperparameter automatisch auszuwählen. Die meisten Eingabeparameter haben bekannte Namen, da die Routine eine Koordinatenabstiegsoptimierung verwendet.

Diese Funktion kann optional verwendet werden, wenn ein Nutzer nicht sicher ist, welchen Wert von Lambda er verwenden soll. Die Kreuzvalidierung ist das gängige Verfahren zur Abstimmung von Hyperparametern. Um es zu verwenden, würden wir natürlich dieselben Trainingsdaten übergeben, die schließlich zur Erstellung des vollständigen Regressionsmodells verwendet werden.

in_matrix ist die Eingabe für die Matrix der Prädiktoren, in_targets ist die Eingabe für die entsprechenden Ziele. Zusätzlich zu diesen Eingabe-Arrays müssen wir noch zwei weitere Arrays bereitstellen. out_lambdas und out_lambda_OOS sind Arrays, die die feineren Details des Kreuzvalidierungsprozesses enthalten werden.

Der letzte Parameter gibt an, ob die Ergebnisse des Prozesses auf dem Terminal ausgedruckt werden sollen.

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

Die Funktion verwendet eine lokale Instanz von CCoordinateDescent, um eine Reihe von Lambdas zu testen. Die Anzahl der getesteten Lambdas wird durch den Parameter n_lambda der Funktion festgelegt. Die getesteten Lambdas beginnen mit dem Maximum, das durch den Aufruf von GetLambdaThreshold() berechnet wurde. Jeder Lambda-Test erzeugt neue Beta-Koeffizienten, die zur Berechnung des Anteils der erklärten Varianz verwendet werden. All dies wird für jede Falte (fold) durchgeführt. Die Ergebnisse aller Falten werden geprüft, und die beste wird ausgewählt. Der Lambda-Wert, der das beste Ergebnis liefert, wird als optimaler Lambda-Wert zurückgegeben.  
 
Mit all den beschriebenen Code-Utilities ist es nun an der Zeit, sie in die Praxis umzusetzen.

Ein Beispiel

Um die praktische Anwendung dieser Methode zu demonstrieren, werden wir sie verwenden, um ein Modell zu erstellen, das die Preisänderung für den nächsten Balken auf der Grundlage einer Reihe von langen und kurzen gleitenden Durchschnitten vorhersagt. Wir wollen den Satz gleitender Durchschnitte finden, der für die Vorhersage der Kursänderung des nächsten Balkens am nützlichsten ist.  

Zu diesem Zweck liefern wir dem Modell Indikatoren, die auf der Grundlage von logarithmierten Rohpreisen berechnet werden, wobei die Ziele die logarithmierten Differenzen sind. Wir brauchen einen Indikator, der rohe Preise logarithmisch umwandelt, sodass andere Indikatoren (in diesem Fall der gleitende Durchschnitt) auf ihn verweisen können. Der Indikator für die Log-Preise ist unten dargestellt.

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

Das Schulungsprogramm wird in Form eines Skripts umgesetzt. Wir beginnen damit, die wesentlichen Include-Dateien und die Eingaben des Skripts festzulegen.  Die Eingaben ermöglichen es dem Nutzer, verschiedene Aspekte des Programms an seine Bedürfnisse anzupassen. Dazu gehört auch die Möglichkeit, die Termine für die Schulungs- und Prüfungszeiträume festzulegen.

//+------------------------------------------------------------------+
//|                                 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

Wichtige Nutzereingabeoptionen sind der Eingang MA_period_inc, der die Periodenschritte festlegt. Num_Ma_periods definiert die Anzahl der gleitenden Durchschnitte, die dem Algorithmus zugeführt werden. Die Indikatorwerte, die als Prädiktoren verwendet werden sollen, sind die Differenz zwischen einem langen und einem kurzen gleitenden Durchschnitt. Der kurze gleitende Durchschnitt wird als die Hälfte der Periode des resultierenden langen gleitenden Durchschnitts berechnet. Der lange gleitende Durchschnitt wird durch Inkrementierung um MA_period_inc , Num_MA_period mal bestimmt.
Num_Folds legt die Anzahl der Falten fest, die von der Funktion Optimizelambda während der Kreuzvalidierung verwendet werden.  
Andere Eingaben sind selbsterklärend.

Das Skript beginnt mit der Aufzählung der Trainings- und Testdatensätze. Lokale Puffer werden auf der Grundlage der gewählten Nutzereingaben in ihrer Größe angepasst.

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

Arrays, die an die CCoordinateDescent-Instanz übergeben werden, werden vorbereitet und gefüllt, d. h. das Ziel-Array und die Matrix der Prädiktoren.

//---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];
//---

Die Abstimmung von Lambda erfolgt in Abhängigkeit vom Wert von Alpha. Wenn Alpha kleiner oder gleich Null ist, wird kein optimales Lambda berechnet. Das Ergebnis ist ein Modell, das einer linearen Standardregression ohne jegliche Regularisierung ähnelt.

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

Sobald das Training durch das CCoordinateDescent-Objekt abgeschlossen ist, können die Ergebnisse optional auf dem Terminal ausgegeben werden.

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

Die erste Spalte zeigt den langen gleitenden Durchschnittszeitraum, die zweite den entsprechenden kurzen gleitenden Durchschnitt und schließlich den Betawert für den jeweiligen Prädiktor. Wenn Null angezeigt wird, bedeutet dies, dass dieser Prädiktor verworfen wurde.

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("");

Das Programm endet nach der Prüfung der Leistung über den gewählten Testzeitraum. Nutzer sollten beachten, dass der am Ende des Programms angezeigte Leistungswert kein Hinweis auf die tatsächliche Leistung ist, da viele Dinge nicht berücksichtigt werden. Diese Zahlen sollten in Relation zu anderen Ergebnissen gesetzt werden, die mit anderen Programmparametern erzielt wurden.

Die folgende Ausgabe zeigt die Ergebnisse, wenn Alpha 0 ist. Wie bereits erwähnt, findet bei Alpha 0 keine Regularisierung statt, das Modell wird mit allen gelieferten Prädiktoren erstellt, keiner wird ausgelassen.

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)

Nachstehend die Ausgabe, wenn Alpha 0,1 ist. Von Interesse sind die Beta-Werte im Vergleich zum vorherigen Lauf. Beta-Werte von Null zeigen an, dass der entsprechende Prädiktor verworfen wurde.

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)

Als Nächstes sehen wir uns die Ausgabe an, wenn Alpha 0,9 ist. Diesmal heben wir die Ausgabe von LambdaOptimize hervor. In der ersten Spalte steht der getestete Lambda-Wert, in der zweiten Spalte die Anzahl der in das Modell aufgenommenen Prädiktoren und in der letzten Spalte der Anteil der erklärten Varianz aus dem Test für eine bestimmte Falte. Im Skript haben wir 10 Falten angegeben, also gibt es zehn Tabellen mit diesen Daten.

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

Beachten Sie, dass bei maximalem Lambda die Anzahl der aktiven Prädiktoren gleich Null ist und dieser Wert bei jeder Iteration mit sinkendem Lambda steigt. Die Anzahl der ausgewählten Prädiktoren erhöht oder verringert sich, wenn der Algorithmus entscheidet, welcher Lambda-Wert der beste ist. Das resultierende Modell verwirft schließlich einige weitere Indikatorwerte, die es für unnötig hält.

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)

Schlussfolgerung

Die elastische Netzregression ist in Bezug auf ihre Fähigkeiten recht bemerkenswert. Es ist jedoch kein Allheilmittel, denn es gibt eine Reihe von kritischen Variablen, die zur Definition des Modells verwendet werden und die spezifiziert werden müssen. Neben der Art der Regularisierung, die gewählt werden muss, muss sich der Nutzer noch mit anderen Aspekten wie dem Konvergenzkriterium auseinandersetzen. Trotz dieser Nachteile kann nicht geleugnet werden, dass es ein nützliches Instrument ist.

Dateiname	Beschreibung
MQL5\Indicators\LogPrices.mq5	ein Indikator zur Protokollierung von Rohpreisen, dessen Handle an andere Indikatoraufrufe weitergegeben werden kann.
MQL5\Include\CoordinateDescent.mqh	Include-Datei mit der Definition der Klasse CCoordinateDescent und der Funktion OptimizeLambda().
MQL5\Scripts\ELN_MA.mq5	Dies ist ein Beispiel für ein Skript, das das elastische Netz anwendet, um ein Prognosemodell aus mehreren gleitenden Durchschnittsindikatoren zu erstellen.