Datenwissenschaft und maschinelles Lernen (Teil 19): Überladen Sie Ihre AI-Modelle mit AdaBoost

MetaTrader 5 — Handel | 2 Mai 2024, 11:16

273

Omega J Msigwa

Was ist AdaBoost?

AdaBoost, kurz für Adaptive Boosting, ist ein maschinelles Lernmodell, das versucht, aus schwachen Klassifizierern einen starken Klassifizierer zu bilden.

Wie funktioniert das?

Der Algorithmus gewichtet die Instanzen je nach ihrer richtigen oder falschen Klassifizierung.
Es kombiniert schwache Lerner mit einer gewichteten Summe.
Der endgültige starke Lerner ist eine lineare Kombination aus schwachen Lernern, deren Gewichte während des Trainings festgelegt werden.

Warum sollte sich jemand für die Verwendung von AdaBoost interessieren?

AdaBoost bietet mehrere Vorteile, darunter:

Verbesserte Genauigkeit – Boosting kann die Gesamtgenauigkeit des Modells verbessern, indem mehrere schwache Modellvorhersagen kombiniert werden. Durch die Durchschnittsbildung der Vorhersagen aller Modelle für die Regression oder die Abstimmung über sie für die Klassifizierung wird die Genauigkeit des endgültigen Modells erhöht.
Robustheit gegenüber Überanpassung – Boosting kann das Risiko der Überanpassung verringern, indem die Gewichte den falsch klassifizierten Eingaben zugewiesen werden.
Besserer Umgang mit unausgewogenen Daten – Boosting kann mit unausgewogenen Daten umgehen, indem es sich mehr auf die Datenpunkte konzentriert, die falsch klassifiziert sind.
Bessere Interpretierbarkeit – Boosting kann die Interpretierbarkeit des Modells erhöhen, indem der Entscheidungsprozess des Modells in mehrere Prozesse unterteilt wird.

Was ist ein Entscheidungsstumpf?

Ein Entscheidungsstumpf (Decision Stump) ist ein einfaches maschinelles Lernmodell, das als schwacher Lerner in Ensemble-Methoden wie AdaBoost verwendet wird. Es handelt sich im Wesentlichen um ein maschinelles Lernmodell, das vereinfacht ist und Entscheidungen auf der Grundlage eines einzigen Merkmals und eines Schwellenwerts trifft. Das Ziel der Verwendung eines Entscheidungsstumpfes als schwacher Lerner ist es, ein grundlegendes Muster in den Daten zu erfassen, das zur Verbesserung des gesamten Ensemblemodells beitragen kann.

Im Folgenden wird die Theorie eines Entscheidungsstumpfes am Beispiel des Entscheidungsbaum-Klassifikators kurz erläutert:

1. Struktur:

- Ein Entscheidungsstumpf trifft eine binäre Entscheidung auf der Grundlage eines einzelnen Merkmals und eines Schwellenwerts.

- Es teilt die Daten in zwei Gruppen auf: diejenigen mit Merkmalswerten unterhalb des Schwellenwerts und diejenigen mit Werten darüber.

- Dies wird üblicherweise im Konstruktor der meisten unserer Klassifikatoren in dieser Bibliothek eingesetzt:

 CDecisionTreeClassifier(uint min_samples_split=2, uint max_depth=2, mode mode_=MODE_GINI);
~CDecisionTreeClassifier(void);

2. Training:

- Während des Trainings identifiziert der Entscheidungsstumpf das Merkmal und den Schwellenwert, der ein bestimmtes Kriterium minimiert, häufig den gewichteten Fehlklassifikationsfehler.

- Der Fehlklassifizierungsfehler wird für jede mögliche Aufteilung berechnet, und diejenige mit dem geringsten Fehler wird ausgewählt.

- Die Anpassungsfunktion(en) sind der Ort, an dem das gesamte Training durchgeführt wird:

void fit(matrix &x, vector &y);

3. Vorhersage:

- Bei der Vorhersage wird ein Datenpunkt danach klassifiziert, ob sein Merkmalswert über oder unter dem gewählten Schwellenwert liegt.

double predict(vector &x);
vector predict(matrix &x);

Zu den häufig verwendeten schwachen Lernern in Ensemble-Methoden wie AdaBoost gehören:

1. Entscheidungsstümpfe/Entscheidungsbäume:

- Wie oben beschrieben, werden aufgrund ihrer Einfachheit häufig Entscheidungsstümpfe (decision stumps) oder flache Entscheidungsbäume verwendet.

2. Lineare Modelle:

- Lineare Modelle wie logistische Regression oder lineare SVMs können als schwache Lerner verwendet werden.

3. Polynomiale Modelle:

- Polynommodelle höheren Grades können komplexere Beziehungen erfassen, und die Verwendung von Polynomen niedrigen Grades kann als schwacher Lerner wirken.

4. Neuronale Netze (Shallow):

- Manchmal werden flache neuronale Netze mit einer geringen Anzahl von Schichten und Neuronen verwendet.

5. Gaußsche Modelle:

- Gaußsche Modelle, wie z. B. Gaußsche Naive Bayes, können als schwache Lerner eingesetzt werden.

Die Wahl eines schwachen Lerners hängt von den spezifischen Merkmalen der Daten und dem jeweiligen Problem ab. In der Praxis sind Entscheidungsstümpfe aufgrund ihrer Einfachheit und Effizienz bei Boosting-Algorithmen sehr beliebt. Der Ensemble-Ansatz von AdaBoost verbessert die Leistung durch die Kombination der Vorhersagen dieser schwachen Lerner.

Da ein Entscheidungsstumpf ein Modell ist, müssen wir dem Konstruktor der Klasse AdaBoost die Argumente für unsere schwachen Modellparameter übergeben;

class AdaBoost
  {
  
protected:
                     vector m_alphas;
                     vector classes_in_data;
                     uint m_min_split, m_max_depth;
                     
                     CDecisionTreeClassifier *weak_learners[]; //store weak_learner pointers for memory allocation tracking
                     CDecisionTreeClassifier *weak_learner;
                     
                     uint m_estimators;
                     
public:
                     AdaBoost(uint min_split, uint max_depth, uint n_estimators=50);
                    ~AdaBoost(void);
                    
                    void fit(matrix &x, vector &y);
                    int predict(vector &x);
                    vector predict(matrix &x);
  };

In diesem Beispiel wird der Entscheidungsbaum verwendet, es kann jedoch jedes beliebige Klassifizierungsmodell für maschinelles Lernen eingesetzt werden.

Aufbau der Klasse AdaBoost:

Der Begriff Anzahl der Schätzer bezieht sich auf die Anzahl der schwachen Lerner (Basismodelle oder Entscheidungsstümpfe), die kombiniert werden, um den endgültigen starken Lerner in einem Ensemble-Lernalgorithmus zu erstellen. Im Zusammenhang mit Algorithmen wie AdaBoost oder Gradient Boosting wird dieser Parameter oft als n_estimators bezeichnet.

AdaBoost::AdaBoost(uint min_split, uint max_depth, uint n_estimators=50)
:m_estimators(n_estimators),
 m_min_split(min_split),
 m_max_depth(max_depth)
 {
   ArrayResize(weak_learners, n_estimators);   //Resizing the array to retain the number of base weak_learners
 }

Im geschützten Teil der Klasse gibt es den Vektor m_alphas, und auch weights wurde im Artikel schon mehrfach erwähnt. Nachfolgend die Erläuterung:

Alpha-Werte:

Die Alphawerte stellen den Beitrag oder die Gewichtung dar, die jedem schwachen Lerner im Ensemble zugewiesen wird; diese Werte werden auf der Grundlage der Leistung jedes schwachen Lerners während des Trainings berechnet.

Höhere Alpha-Werte werden schwachen Lernern zugewiesen, die bei der Reduzierung von Trainingsfehlern gut abschneiden.

Die Formel zur Berechnung von Alpha wird häufig wie folgt angegeben:

wobei:

der gewichtete Fehler des schwachen Lerners t ist.

Umsetzung:

double alpha = 0.5 * log((1-error) / (error + 1e-10));

Weights:

Die Gewichtungsvektoren weights stellen die Wichtigkeit der einzelnen Trainingsinstanzen bei jeder Iteration dar.

Während des Trainings werden die Gewichte der falsch klassifizierten Instanzen erhöht, um sich in der nächsten Iteration auf die schwer zu klassifizierenden Beispiele zu konzentrieren.

Die Formel für die Aktualisierung der Instanzgewichte wird häufig wie folgt angegeben:

ist das Gewicht der Instanz i bei der Iteration.

ist das dem schwachen Lernenden t zugewiesene Gewicht.

ist die wahre Bezeichnung der Instanz.

ist die Vorhersage des schwachen Lerners t für den Fall.

ist ein Normalisierungsfaktor, der sicherstellt, dass die Summe der Gewichte 1 ist.

Umsetzung:

 for (ulong j=0; j<m; j++)
    misclassified[j] = (preds[j] != y[j]);
 
 error = (misclassified * weights).Sum() / (double)weights.Sum();
 
//--- Calculate the weight of a weak learner in the final model

double alpha = 0.5 * log((1-error) / (error + 1e-10));

//--- Update instance weights

weights *= exp(-alpha * y * preds);
weights /= weights.Sum();

Training des AdaBoost-Modells:

Wie bei anderen Ensemble-Techniken wird eine Anzahl von Modellen (in der folgenden Funktion als m_estimators bezeichnet) verwendet, um Vorhersagen für dieselben Daten zu treffen, wobei das Mehrheitsvotum oder andere Techniken eingesetzt werden können, um das bestmögliche Ergebnis zu ermitteln.

void AdaBoost::fit(matrix &x,vector &y)
 {
   m_alphas.Resize(m_estimators);  
   classes_in_data = MatrixExtend::Unique(y); //Find the target variables in the class
      
   ulong m = x.Rows(), n = x.Cols();
   vector weights(m); weights = weights.Fill(1.0) / m; //Initialize instance weights
   vector preds(m);
   vector misclassified(m);
   

   double error = 0;
   
   for (uint i=0; i<m_estimators; i++)
    {      

//---
      
      weak_learner = new CDecisionTreeClassifier(this.m_min_split, m_max_depth);             
              
      weak_learner.fit(x, y); //fiting the randomized data to the i-th weak_learner
      preds = weak_learner.predict(x); //making predictions for the i-th weak_learner
      
             
       for (ulong j=0; j<m; j++)
          misclassified[j] = (preds[j] != y[j]);
       
       error = (misclassified * weights).Sum() / (double)weights.Sum();
       
      //--- Calculate the weight of a weak learner in the final weak_learner
      
      double alpha = 0.5 * log((1-error) / (error + 1e-10));
      
      //--- Update instance weights
      
      weights *= exp(-alpha * y* preds);
      weights /= weights.Sum();
      
      //--- save a weak learner and its weight
      
      this.m_alphas[i] = alpha;
      this.weak_learners[i] = weak_learner;
    }
 }

Wie bei jeder anderen Ensemble-Technik ist auch das Bootstrapping-Verfahren von entscheidender Bedeutung, da sonst alle Modelle und Daten einfach gleich sind und dies dazu führen könnte, dass sich die Leistung aller Modelle nicht mehr voneinander unterscheiden lässt; Bootstrapping muss also eingesetzt werden:

void AdaBoost::fit(matrix &x,vector &y)
 {
   m_alphas.Resize(m_estimators);  
   classes_in_data = MatrixExtend::Unique(y); //Find the target variables in the class
      
   ulong m = x.Rows(), n = x.Cols();
   vector weights(m); weights = weights.Fill(1.0) / m; //Initialize instance weights
   vector preds(m);
   vector misclassified(m);
   
//---

   matrix data = MatrixExtend::concatenate(x, y);
   matrix temp_data;
   
   matrix x_subset;
   vector y_subset;

   double error = 0;
   
   for (uint i=0; i<m_estimators; i++)
    {      
      
      temp_data = data;
      MatrixExtend::Randomize(temp_data, this.m_random_state, this.m_boostrapping);
      
       if (!MatrixExtend::XandYSplitMatrices(temp_data, x_subset, y_subset)) //Get randomized subsets
         {  
            ArrayRemove(weak_learners,i,1); //Delete the invalid weak_learner
            printf("%s %d Failed to split data",__FUNCTION__,__LINE__);
            continue;
         }

//---
      
      weak_learner = new CDecisionTreeClassifier(this.m_min_split, m_max_depth);             
              
      weak_learner.fit(x_subset, y_subset); //fiting the randomized data to the i-th weak_learner
      preds = weak_learner.predict(x_subset); //making predictions for the i-th weak_learner
      
      //printf("[%d] Accuracy %.3f ",i,Metrics::accuracy_score(y_subset, preds));
             
       for (ulong j=0; j<m; j++)
          misclassified[j] = (preds[j] != y_subset[j]);
       
       error = (misclassified * weights).Sum() / (double)weights.Sum();
       
      //--- Calculate the weight of a weak learner in the final weak_learner
      
      double alpha = 0.5 * log((1-error) / (error + 1e-10));
      
      //--- Update instance weights
      
      weights *= exp(-alpha * y_subset * preds);
      weights /= weights.Sum();
      
      //--- save a weak learner and its weight
      
      this.m_alphas[i] = alpha;
      this.weak_learners[i] = weak_learner;
    }
 }

Auch der Klassenkonstruktor musste geändert werden:

class AdaBoost
  {
  
protected:
                     vector m_alphas;
                     vector classes_in_data;
                     int m_random_state;
                     bool m_boostrapping;
                     uint m_min_split, m_max_depth;
                     
                     CDecisionTreeClassifier *weak_learners[]; //store weak_learner pointers for memory allocation tracking
                     CDecisionTreeClassifier *weak_learner;
                     
                     uint m_estimators;
                     
public:
                     AdaBoost(uint min_split, uint max_depth, uint n_estimators=50, int random_state=42, bool bootstrapping=true);
                    ~AdaBoost(void);
                    
                    void fit(matrix &x, vector &y);
                    int predict(vector &x);
                    vector predict(matrix &x);
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
AdaBoost::AdaBoost(uint min_split, uint max_depth, uint n_estimators=50, int random_state=42, bool bootstrapping=true)
:m_estimators(n_estimators),
 m_random_state(random_state),
 m_boostrapping(bootstrapping),
 m_min_split(min_split),
 m_max_depth(max_depth)
 {
   ArrayResize(weak_learners, n_estimators);   //Resizing the array to retain the number of base weak_learners
 }

Ermittlung der Vorhersagen der Mehrheit

Anhand der trainierten Gewichte bestimmt der AdaBoost-Klassifikator die Klasse mit den meisten Stimmen, was bedeutet, dass sie mit größerer Wahrscheinlichkeit auftritt als die anderen:

int AdaBoost::predict(vector &x)
 {
   // Combine weak learners using weighted sum   
   
   vector weak_preds(m_estimators), 
          final_preds(m_estimators);
          
   for (uint i=0; i<this.m_estimators; i++)
     weak_preds[i] = this.weak_learners[i].predict(x);
  
  return (int)weak_preds[(this.m_alphas*weak_preds).ArgMax()]; //Majority decision class
 }

Nun wollen wir sehen, wie wir das Modell in einem Expert Advisor verwenden können:

#include <MALE5\Ensemble\AdaBoost.mqh>

DecisionTree::AdaBoost *ada_boost_tree;
LogisticRegression::AdaBoost *ada_boost_logit;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
  
   string headers;
   matrix data = MatrixExtend::ReadCsv("iris.csv",headers);
   
   matrix x; vector y;
   MatrixExtend::XandYSplitMatrices(data,x,y);
   
   ada_boost_tree = new DecisionTree::AdaBoost(2,1,10,42);
   ada_boost_tree.fit(x,y);
   
   vector predictions = ada_boost_tree.predict(x);
   
   printf("Adaboost acc = %.3f",Metrics::accuracy_score(y, predictions));
 
//---
   return(INIT_SUCCEEDED);
  }

Die Verwendung des Datensatzes iris.csv dient nur dem Aufbau des Modells und Debugging-Zwecken. Dies führte zu:

2024.01.17 17:52:27.914 AdaBoost Test (EURUSD,H1)       Adaboost acc = 0.960

Es scheint, als ob unser Modell mit Genauigkeitswerten um 90 Prozent so weit ganz gut arbeitet, nachdem ich random_state auf -1 gesetzt habe. Das führt dazu, dass GetTickCount als zufälliges „Seed“ jedes Mal, wenn der EA ausgeführt wird, verwendet wird, sodass ich das Modell in einer Umgebung mit viel mehr Zufall bewerten kann.

QK      0       17:52:27.914    AdaBoost Test (EURUSD,H1)       Adaboost acc = 0.960
LL      0       17:52:35.436    AdaBoost Test (EURUSD,H1)       Adaboost acc = 0.947
JD      0       17:52:42.806    AdaBoost Test (EURUSD,H1)       Adaboost acc = 0.960
IL      0       17:52:50.071    AdaBoost Test (EURUSD,H1)       Adaboost acc = 0.933
MD      0       17:52:57.822    AdaBoost Test (EURUSD,H1)       Adaboost acc = 0.967

Die gleichen Kodierungsmuster und die gleiche Struktur können für andere schwache Lerner in unserer Bibliothek befolgt werden, siehe die logistische Regression als schwacher Lerner.

Der einzige Unterschied in der gesamten Klasse ist, dass bei der Anpassungsfunktion der Typ des Modells, das als schwacher Lerner eingesetzt wird, die logistische Regression verwendet wird:

void AdaBoost::fit(matrix &x,vector &y)
 {
   m_alphas.Resize(m_estimators);  
   classes_in_data = MatrixExtend::Unique(y); //Find the target variables in the class
      
   ulong m = x.Rows(), n = x.Cols();
   vector weights(m); weights = weights.Fill(1.0) / m; //Initialize instance weights
   vector preds(m);
   vector misclassified(m);
   
//---

   matrix data = MatrixExtend::concatenate(x, y);
   matrix temp_data;
   
   matrix x_subset;
   vector y_subset;

   double error = 0;
   
   for (uint i=0; i<m_estimators; i++)
    {      
      
      temp_data = data;
      MatrixExtend::Randomize(temp_data, this.m_random_state, this.m_boostrapping);
      
       if (!MatrixExtend::XandYSplitMatrices(temp_data, x_subset, y_subset)) //Get randomized subsets
         {  
            ArrayRemove(weak_learners,i,1); //Delete the invalid weak_learner
            printf("%s %d Failed to split data",__FUNCTION__,__LINE__);
            continue;
         }

//---
      
      weak_learner = new CLogisticRegression();             
              
      weak_learner.fit(x_subset, y_subset); //fiting the randomized data to the i-th weak_learner
      preds = weak_learner.predict(x_subset); //making predictions for the i-th weak_learner
             
       for (ulong j=0; j<m; j++)
          misclassified[j] = (preds[j] != y_subset[j]);
       
       error = (misclassified * weights).Sum() / (double)weights.Sum();
       
      //--- Calculate the weight of a weak learner in the final weak_learner
      
      double alpha = 0.5 * log((1-error) / (error + 1e-10));
      
      //--- Update instance weights
      
      weights *= exp(-alpha * y_subset * preds);
      weights /= weights.Sum();
      
      //--- save a weak learner and its weight
      
      this.m_alphas[i] = alpha;
      this.weak_learners[i] = weak_learner;
    }
 }

Anzeigenverstärkte KI-Modelle im Strategietester

Mit Hilfe des Indikators Bollinger Bänder, der auf den Eröffnungskurs angewendet wird, versuchen wir, unsere Modelle zu trainieren, damit sie lernen, den Schlusskurs der nächsten Kerze vorherzusagen, egal ob sie auf-, abwärts oder keines von beiden ist (HOLD).

Erstellen wir einen Expert Advisor, um unsere Modelle in der Handelsumgebung zu testen, und beginnen wir mit dem Code zur Erfassung der Trainingsdaten:

Sammeln der Trainingsdaten:

//--- Data Collection for training the model

//--- x variables Bollinger band only
   
   matrix dataset;
   
   indicator_v.CopyIndicatorBuffer(bb_handle,0,0,train_bars); //Main LINE
   dataset = MatrixExtend::concatenate(dataset, indicator_v);
   
   indicator_v.CopyIndicatorBuffer(bb_handle,1,0,train_bars); //UPPER BB
   dataset = MatrixExtend::concatenate(dataset, indicator_v);
   
   indicator_v.CopyIndicatorBuffer(bb_handle,2,0,train_bars); //LOWER BB
   dataset = MatrixExtend::concatenate(dataset, indicator_v);
   
//--- Target Variable
   
   int size = CopyRates(Symbol(),PERIOD_CURRENT,0,train_bars,rates);
   vector y(size);
   
   switch(model)
     {
      case  DECISION_TREE:
         {
            for (ulong i=0; i<y.Size(); i++)
              {
                 if (rates[i].close > rates[i].open)
                   y[i] = 1; //buy signal
                 else if (rates[i].close < rates[i].open)
                   y[i] = 2; //sell signal 
                 else
                   y[i] = 0; //Hold signal
              }
         }
        break;
      case LOGISTIC_REGRESSION:
            for (ulong i=0; i<indicator_v.Size(); i++)
              {
                 y[i] = (rates[i].close > rates[i].open); //if close > open buy else sell
              }
        break;
     }
   
   dataset = MatrixExtend::concatenate(dataset, y); //Add the target variable to the dataset
   
   if (MQLInfoInteger(MQL_DEBUG))
    {
       Print("Data Head");
       MatrixExtend::PrintShort(dataset);
    }

Haben Sie die Änderung in der Darstellung der Zielvariablen bemerkt? Da der Entscheidungsbaum vielseitig ist und mehrere Klassen in der Zielvariablen gut handhaben kann, ist er in der Lage, drei Muster auf dem Markt zu klassifizieren: KAUFEN, VERKAUFEN und HALTEN. Im Gegensatz zum logistischen Regressionsmodell, dessen Kern die Sigmoidfunktion ist, die zwei Klassen 0 und 1 klassifiziert, ist es am besten, die Zielvariable so vorzubereiten, dass sie entweder KAUFEN oder VERKAUFEN ist.

Training und Test des trainierten Modells

Ein Elefant im Raum:

MatrixExtend::TrainTestSplitMatrices(dataset,train_x,train_y,test_x,test_y,0.7,_random_state);

Diese Funktion teilt die Daten in Trainings- und Teststichproben auf, wobei 70 % der Daten in die Teststichprobe und die restlichen 30 % in die Teststichprobe fließen.

Doch bevor wir die neu gesammelten Daten verwenden können, ist die Normalisierung immer noch entscheidend für die Modellleistung.

//--- Training and testing the trained model
   
   matrix train_x, test_x;
   vector train_y, test_y;
   
   MatrixExtend::TrainTestSplitMatrices(dataset,train_x,train_y,test_x,test_y,0.7,_random_state); //Train test split data | This function splits the data into training and testing sample given a random state and 70% of data to test while the rest 30% for testing
   
   train_x = scaler.fit_transform(train_x); //Standardize the training data
   test_x = scaler.transform(test_x); //Do the same for the test data
   
   Print("-----> ",EnumToString(model));
   
   vector preds;
   switch(model)
     {
      case  DECISION_TREE:
         ada_boost_tree = new DecisionTree::AdaBoost(tree_min_split, tree_max_depth, _n_estimators, -1, _bootstrapping);  //Building the 
        
        //--- Training 
         
         ada_boost_tree.fit(train_x, train_y);
        
         preds = ada_boost_tree.predict(train_x);
         printf("Train Accuracy %.3f",Metrics::accuracy_score(train_y, preds));
         
        //--- Testing
        
         preds = ada_boost_tree.predict(test_x);
         printf("Test Accuracy %.3f",Metrics::accuracy_score(test_y, preds));
         
        break;
      case LOGISTIC_REGRESSION:
         ada_boost_logit = new LogisticRegression::AdaBoost(_n_estimators,-1, _bootstrapping);
         
        //--- Training 
        
         ada_boost_logit.fit(train_x, train_y);
        
         preds = ada_boost_logit.predict(train_x);
         printf("Train Accuracy %.3f",Metrics::accuracy_score(train_y, preds));
         
        //--- Testing
        
         preds = ada_boost_logit.predict(test_x);
         printf("Test Accuracy %.3f",Metrics::accuracy_score(test_y, preds));
         
        break;
     }

Ausgaben:

PO      0       22:59:11.807    AdaBoost Test (EURUSD,H1)       -----> DECISION_TREE
CI      0       22:59:20.204    AdaBoost Test (EURUSD,H1)       Building Estimator [1/10] Accuracy Score 0.561
OD      0       22:59:27.883    AdaBoost Test (EURUSD,H1)       Building Estimator [2/10] Accuracy Score 0.601
NP      0       22:59:38.316    AdaBoost Test (EURUSD,H1)       Building Estimator [3/10] Accuracy Score 0.541
LO      0       22:59:48.327    AdaBoost Test (EURUSD,H1)       Building Estimator [4/10] Accuracy Score 0.549
LK      0       22:59:56.813    AdaBoost Test (EURUSD,H1)       Building Estimator [5/10] Accuracy Score 0.570
OF      0       23:00:09.552    AdaBoost Test (EURUSD,H1)       Building Estimator [6/10] Accuracy Score 0.517
GR      0       23:00:18.322    AdaBoost Test (EURUSD,H1)       Building Estimator [7/10] Accuracy Score 0.571
GI      0       23:00:29.254    AdaBoost Test (EURUSD,H1)       Building Estimator [8/10] Accuracy Score 0.556
HE      0       23:00:37.632    AdaBoost Test (EURUSD,H1)       Building Estimator [9/10] Accuracy Score 0.599
DS      0       23:00:47.522    AdaBoost Test (EURUSD,H1)       Building Estimator [10/10] Accuracy Score 0.567
OP      0       23:00:47.524    AdaBoost Test (EURUSD,H1)       Train Accuracy 0.590
OG      0       23:00:47.525    AdaBoost Test (EURUSD,H1)       Test Accuracy 0.513
MK      0       23:24:06.573    AdaBoost Test (EURUSD,H1)       Building Estimator [1/10] Accuracy Score 0.491
HK      0       23:24:06.575    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.43700
QO      0       23:24:06.575    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.43432
KP      0       23:24:06.576    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.43168
MD      0       23:24:06.577    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.42909
FI      0       23:24:06.578    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.42652
QJ      0       23:24:06.579    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.42400
IN      0       23:24:06.580    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.42151
NS      0       23:24:06.581    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.41906
GD      0       23:24:06.582    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.41664
DK      0       23:24:06.582    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.41425
IQ      0       23:24:06.585    AdaBoost Test (EURUSD,H1)       Building Estimator [2/10] Accuracy Score 0.477
JP      0       23:24:06.586    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.43700
DE      0       23:24:06.587    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.43432
RF      0       23:24:06.588    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.43168
KJ      0       23:24:06.588    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.42909
FO      0       23:24:06.589    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.42652
NP      0       23:24:06.590    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.42400
CD      0       23:24:06.591    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.42151
KI      0       23:24:06.591    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.41906
NM      0       23:24:06.592    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.41664
EM      0       23:24:06.592    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.41425
EO      0       23:24:06.593    AdaBoost Test (EURUSD,H1)       Building Estimator [3/10] Accuracy Score 0.477
KF      0       23:24:06.594    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.41931
HK      0       23:24:06.594    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.41690
RL      0       23:24:06.595    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.41452
IP      0       23:24:06.596    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.41217
KE      0       23:24:06.596    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.40985
DI      0       23:24:06.597    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.40757
IJ      0       23:24:06.597    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.40533
MO      0       23:24:06.598    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.40311
PS      0       23:24:06.599    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.40093
CG      0       23:24:06.600    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.39877
NE      0       23:24:06.601    AdaBoost Test (EURUSD,H1)       Building Estimator [4/10] Accuracy Score 0.499
EL      0       23:24:06.602    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.41931
MQ      0       23:24:06.603    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.41690
PE      0       23:24:06.603    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.41452
OF      0       23:24:06.604    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.41217
JK      0       23:24:06.605    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.40985
KO      0       23:24:06.606    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.40757
FP      0       23:24:06.606    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.40533
PE      0       23:24:06.607    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.40311
CI      0       23:24:06.608    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.40093
NI      0       23:24:06.609    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.39877
KS      0       23:24:06.610    AdaBoost Test (EURUSD,H1)       Building Estimator [5/10] Accuracy Score 0.499
QR      0       23:24:06.611    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.42037
MG      0       23:24:06.611    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.41794
LK      0       23:24:06.612    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.41555
ML      0       23:24:06.613    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.41318
PQ      0       23:24:06.614    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.41085
FE      0       23:24:06.614    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.40856
FF      0       23:24:06.615    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.40630
FJ      0       23:24:06.616    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.40407
KO      0       23:24:06.617    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.40187
NS      0       23:24:06.618    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.39970
EH      0       23:24:06.619    AdaBoost Test (EURUSD,H1)       Building Estimator [6/10] Accuracy Score 0.497
FH      0       23:24:06.620    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.41565
LM      0       23:24:06.621    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.41329
IQ      0       23:24:06.622    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.41096
KR      0       23:24:06.622    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.40867
LF      0       23:24:06.623    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.40640
NK      0       23:24:06.624    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.40417
OL      0       23:24:06.625    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.40197
RP      0       23:24:06.627    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.39980
OE      0       23:24:06.628    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.39767
EE      0       23:24:06.628    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.39556
QF      0       23:24:06.629    AdaBoost Test (EURUSD,H1)       Building Estimator [7/10] Accuracy Score 0.503
CN      0       23:24:06.630    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.41565
IR      0       23:24:06.631    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.41329
HG      0       23:24:06.632    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.41096
RH      0       23:24:06.632    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.40867
ML      0       23:24:06.633    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.40640
FQ      0       23:24:06.633    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.40417
QR      0       23:24:06.634    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.40197
NF      0       23:24:06.634    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.39980
EK      0       23:24:06.635    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.39767
CL      0       23:24:06.635    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.39556
LL      0       23:24:06.636    AdaBoost Test (EURUSD,H1)       Building Estimator [8/10] Accuracy Score 0.503
HD      0       23:24:06.637    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.44403
IH      0       23:24:06.638    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.44125
CM      0       23:24:06.638    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.43851
DN      0       23:24:06.639    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.43580
DR      0       23:24:06.639    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.43314
CG      0       23:24:06.640    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.43051
EK      0       23:24:06.640    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.42792
JL      0       23:24:06.641    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.42537
EQ      0       23:24:06.641    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.42285
OF      0       23:24:06.642    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.42037
GJ      0       23:24:06.642    AdaBoost Test (EURUSD,H1)       Building Estimator [9/10] Accuracy Score 0.469
GJ      0       23:24:06.643    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [1/10] mse 0.44403
ON      0       23:24:06.643    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [2/10] mse 0.44125
LS      0       23:24:06.644    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [3/10] mse 0.43851
HG      0       23:24:06.644    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [4/10] mse 0.43580
KH      0       23:24:06.645    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [5/10] mse 0.43314
FM      0       23:24:06.645    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [6/10] mse 0.43051
IQ      0       23:24:06.646    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [7/10] mse 0.42792
QR      0       23:24:06.646    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [8/10] mse 0.42537
IG      0       23:24:06.647    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [9/10] mse 0.42285
RH      0       23:24:06.647    AdaBoost Test (EURUSD,H1)       ---> Logistic regression build epoch [10/10] mse 0.42037
KS      0       23:24:06.648    AdaBoost Test (EURUSD,H1)       Building Estimator [10/10] Accuracy Score 0.469
NP      0       23:24:06.652    AdaBoost Test (EURUSD,H1)       Train Accuracy 0.491
GG      0       23:24:06.654    AdaBoost Test (EURUSD,H1)       Test Accuracy 0.447

So weit, so gut! Schließen wir unseren Expert Advisor mit den Codezeilen ab, die in der Lage sind, Trades auszuführen:

Gewinnung der Handelssignale:

void OnTick()
  {
//--- x variables Bollinger band only | The current buffer only this time

   indicator_v.CopyIndicatorBuffer(bb_handle,0,0,1); //Main LINE
   x_inputs[0] = indicator_v[0];
   indicator_v.CopyIndicatorBuffer(bb_handle,1,0,1); //UPPER BB
   x_inputs[1] = indicator_v[0];
   indicator_v.CopyIndicatorBuffer(bb_handle,2,0,1); //LOWER BB
   x_inputs[2] = indicator_v[0];
   
//---
   
   int signal = INT_MAX;
   switch(model)
     {
      case  DECISION_TREE:
        x_inputs = scaler.transform(x_inputs); //New inputs data must be normalized the same way
        signal = ada_boost_tree.predict(x_inputs);   
        break;
      case LOGISTIC_REGRESSION:
         x_inputs = scaler.transform(x_inputs); //New inputs data must be normalized the same way
         signal = ada_boost_logit.predict(x_inputs);
        break;
     }
  }

Zur Erinnerung: 1 ist das Kaufsignal für den Entscheidungsbaum, 0 ist das Kaufsignal für die logistische Regression; 2 ist das Verkaufssignal für den Entscheidungsbaum; 1 ist das Verkaufssignal für die logistische Regression. Wir kümmern uns nicht um das Signal 0 des Entscheidungsbaums, das „hold“ bedeutet. Vereinheitlichen wir diese Signale und bezeichnen sie als 0 und 1 für Kauf- bzw. Verkaufssignale.

case  DECISION_TREE:
  
  x_inputs = scaler.transform(x_inputs); //New inputs data must be normalized the same way
  signal = ada_boost_tree.predict(x_inputs);   
  
   if (signal == 1) //buy signal for decision tree
     signal = 0;
   else if (signal == 2)
     signal = 1;
   else
     signal = INT_MAX; //UNKNOWN NUMBER FOR HOLD
  break;

Eine einfache Strategie auf der Grundlage unserer Modelle:

 SymbolInfoTick(Symbol(), ticks);
 
 if (isnewBar(PERIOD_CURRENT))
  {        
   if (signal == 0) //buy signal
     {
        if (!PosExists(MAGIC_NUMBER, POSITION_TYPE_BUY)) 
          m_trade.Buy(lot_size, Symbol(), ticks.ask, ticks.ask-stop_loss*Point(), ticks.ask+take_profit*Point());
     }
     
   if (signal == 1)
     {
       if (!PosExists(MAGIC_NUMBER, POSITION_TYPE_SELL)) 
         m_trade.Sell(lot_size, Symbol(), ticks.bid, ticks.bid+stop_loss*Point(), ticks.bid-take_profit*Point());
     }
  }

Ergebnisse im Strategietester | von Januar 2020 - Februar 2023 | Zeitrahmen 1 STUNDE:

Entscheidungsbaum AdaBoost:

Entscheidungsbaum adaboost

Logistische Regression AdaBoost:

logisitische Regression adaboost 1hr tf

Beide Leistungen mit dem Zeitrahmen von 1 Stunde sind sehr weit weg von gut. Ein Hauptgrund dafür ist, dass unsere Strategie auf den aktuellen Bars basiert, Meiner Erfahrung nach, diese Art von Strategien sind meist gut geeignet auf höheren Zeitrahmen als ein einziger Bar stellt eine signifikante Bewegung im Gegensatz zu den kleinen Bars, die 24 in einem Tag auftreten, lassen Sie uns versuchen, 12-Stunden-Zeitrahmen.

Alle Parameter wurden unverändert gelassen, mit Ausnahme von train_bars, das von 1000 auf 100 reduziert wurden, da bei höheren Zeitrahmen nicht so viele Balken zur Verfügung stehen, um die Preisentwicklung in der Vergangenheit abzufragen.

Entscheidungsbaum AdaBoost:

Entscheidungsbaum adaboost

Logistische Regression AdaBoost:

logistische Regression adaboost 12 std tf

Zusammengefasst:

AdaBoost erweist sich als potenter Algorithmus, der die Leistung der in dieser Artikelserie besprochenen KI-Modelle erheblich steigern kann. Dies ist zwar mit Kosten verbunden, aber die Investition lohnt sich, wenn sie sinnvoll eingesetzt wird. AdaBoost wird in den verschiedensten Sektoren und Branchen eingesetzt, z. B. im Finanzwesen, in der Unterhaltungsbranche, im Bildungswesen und darüber hinaus.

Zum Abschluss unserer Untersuchung ist es wichtig, die Vielseitigkeit des Algorithmus und seine Fähigkeit zu würdigen, komplexe Klassifizierungsaufgaben durch die Nutzung der kollektiven Stärke schwacher Lerner zu lösen. Die folgenden häufig gestellten Fragen (FAQs) sollen Klarheit und Einblicke bieten und häufige Fragen beantworten, die bei der Erkundung von AdaBoost auftreten können.

Häufig gestellte Fragen (FAQs) zu AdaBoost:

Frage: Wie funktioniert AdaBoost?

Antwort: AdaBoost trainiert iterativ schwache Lerner (in der Regel einfache Modelle wie Entscheidungsstümpfe) auf dem Datensatz, wobei die Gewichte der falsch klassifizierten Instanzen bei jeder Iteration angepasst werden. Das endgültige Modell ist eine gewichtete Summe der schwachen Lerner, wobei die genaueren Lerner stärker gewichtet werden.

Frage: Was sind schwache Lerner in AdaBoost?

Antwort: Schwache Lerner sind einfache Modelle, die etwas besser abschneiden als der Zufall. Entscheidungsstümpfe (flache Entscheidungsbäume) werden üblicherweise als schwache Lerner in AdaBoost verwendet, aber auch andere Algorithmen können diesen Zweck erfüllen.

Frage: Welche Rolle spielen die Instanzgewichte in AdaBoost?

Antwort: Instanzgewichte in AdaBoost steuern die Bedeutung jeder Trainingsinstanz während des Lernprozesses. Zu Beginn werden alle Gewichte gleich gesetzt und bei jeder Iteration angepasst, um sich mehr auf falsch klassifizierte Instanzen zu konzentrieren und so die Generalisierungsfähigkeit des Modells zu verbessern.

Frage: Wie geht AdaBoost mit Fehlern um, die von schwachen Lernern gemacht werden?

Antwort: AdaBoost weist falsch klassifizierten Instanzen ein höheres Gewicht zu und zwingt nachfolgende schwache Lerner dazu, sich stärker auf die Korrektur dieser Fehler zu konzentrieren. Das endgültige Modell gibt schwachen Lernern mit niedrigeren Fehlerquoten mehr Gewicht.

Frage: Ist AdaBoost empfindlich gegenüber Rauschen und Ausreißern?

Antwort: AdaBoost kann empfindlich gegenüber Rauschen und Ausreißern sein, da es versucht, Fehlklassifikationen zu korrigieren. Ausreißer können eine höhere Gewichtung erhalten, was das endgültige Modell beeinflusst. Um diese Empfindlichkeit abzuschwächen, können robuste schwache Lerner oder Datenvorverarbeitungstechniken eingesetzt werden.

Frage: Leidet AdaBoost unter Overfitting?

Antwort: Bei AdaBoost kann es zu einer Überanpassung kommen, wenn die schwachen Lerner zu komplex sind oder wenn der Datensatz Rauschen enthält. Die Verwendung einfacherer schwacher Lerner und die Anwendung von Techniken wie der Kreuzvalidierung können helfen, eine Überanpassung zu vermeiden.

Frage: Kann AdaBoost für Regressionsprobleme verwendet werden?

Antwort: AdaBoost ist in erster Linie für Klassifizierungsaufgaben konzipiert, kann aber auch für die Regression angepasst werden, indem der Algorithmus für die Vorhersage kontinuierlicher Werte modifiziert wird. Für Regressionsprobleme gibt es Techniken wie AdaBoost.R2.

Frage: Gibt es Alternativen zu AdaBoost?

Antwort: Ja, es gibt andere Ensemble-Lernmethoden, wie Random Forest, Boosting und XGBoost. Jede Methode hat ihre Stärken und Schwächen, und die Wahl hängt von den spezifischen Merkmalen der Daten und dem jeweiligen Problem ab.

Frage: In welchen Situationen ist AdaBoost besonders effektiv?

Antwort: AdaBoost ist effektiv, wenn es um eine Vielzahl von schwachen Lernern geht und in Szenarien, in denen mehrere Klassifikatoren kombiniert werden müssen, um ein robustes Modell zu erstellen. Sie wird häufig bei der Gesichtserkennung, der Textklassifizierung und anderen realen Anwendungen eingesetzt.

Um über den Entwicklungsfortschritt und die Fehlerbehebungen für diesen und viele andere Algorithmen auf dem Laufenden zu bleiben, besuchen Sie bitte das GitHub-Repository unter https://github.com/MegaJoctan/MALE5.

Peace out.

Anhänge:

Datei	Beschreibung\|Verwendung
Adaboost.mqh	Enthält adaboost-Namensraumklassen sowohl für die logistische Regression als auch für den Entscheidungsbaum.
Logistic Regression .mqh	Enthält die Hauptklasse der logistischen Regression
MatrixExtend.mqh	Enthält zusätzliche Matrixmanipulationsfunktionen
metrics.mqh	Eine Bibliothek mit Code zur Messung der Leistung von Modellen des maschinellen Lernens
preprocessing.mqh	Eine Klasse mit Funktionen zur Vorverarbeitung von Daten, um sie für maschinelles Lernen geeignet zu machen
tree.mqh	Die Bibliothek der Entscheidungsbäume finden Sie in dieser Datei
AdaBoost Test.mq5(EA)	Der Haupttest des Expert Advisors, der gesamte hier erläuterte Code, wird in dieser Datei ausgeführt

Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/14034

Beigefügte Dateien |

ZIP herunterladen

AdaBoost_attachments.zip (24.41 KB)

Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum

Aufbau und Test des Handelssystems Aroon

In diesem Artikel erfahren wir, wie wir ein Aroon-Handelssystem aufbauen können, nachdem wir die Grundlagen der Indikatoren und die erforderlichen Schritte zum Aufbau eines Handelssystems auf der Grundlage des Aroon-Indikators gelernt haben. Nachdem wir dieses Handelssystem aufgebaut haben, werden wir es testen, um zu sehen, ob es profitabel sein kann oder noch optimiert werden muss.

MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 10). Die unkonventionelle RBM

Restriktive Boltzmann-Maschinen (RBM) sind im Grunde genommen ein zweischichtiges neuronales Netz, das durch Dimensionsreduktion eine unbeaufsichtigte Klassifizierung ermöglicht. Wir nehmen die Grundprinzipien und untersuchen, ob wir durch eine unorthodoxe Umgestaltung und ein entsprechendes Training einen nützlichen Signalfilter erhalten können.

Wie man einen einfachen Multi-Currency Expert Advisor mit MQL5 erstellt (Teil 6): Zwei RSI-Indikatoren kreuzen ihre Linien

Der Multi-Currency Expert Advisor in diesem Artikel ist ein Expert Advisor oder Handelsroboter, der zwei RSI-Indikatoren mit sich kreuzenden Linien verwendet, den Fast RSI, der sich mit dem Slow RSI kreuzt.

Deep Learning, Vorhersage und Aufträge mit Python, dem MetaTrader5 Python-Paket und ONNX-Modelldatei

Im Rahmen des Projekts wird Python für Deep Learning-basierte Prognosen auf den Finanzmärkten eingesetzt. Wir werden die Feinheiten des Testens der Leistung des Modells anhand von Schlüsselkennzahlen wie dem mittleren absoluten Fehler (MAE), dem mittleren quadratischen Fehler (MSE) und dem R-Quadrat (R2) erkunden und lernen, wie man alles in eine ausführbare Datei verpackt. Wir werden auch eine ONNX-Modelldatei mit seinem EA erstellen.