![Datenwissenschaft und maschinelles Lernen (Teil 19): Überladen Sie Ihre AI-Modelle mit AdaBoost](https://c.mql5.com/2/65/Data_Science_and_Machine_Learning_7Part_191_Supercharge_Your_AI_models_with_AdaBoost_600x314.jpg)
Datenwissenschaft und maschinelles Lernen (Teil 19): Überladen Sie Ihre AI-Modelle mit AdaBoost
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:
Logistische Regression AdaBoost:
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:
Logistische Regression AdaBoost:
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
![Aufbau und Test des Handelssystems Aroon](https://c.mql5.com/2/64/Building_and_testing_Aroon_Trading_Systems___LOGO.png)
![MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 10). Die unkonventionelle RBM](https://c.mql5.com/2/64/MQL5_Wizard_Techniques_you_should_know_cPart_10e_The_Unconventional_RBM___LOGO.png)
![Wie man einen einfachen Multi-Currency Expert Advisor mit MQL5 erstellt (Teil 6): Zwei RSI-Indikatoren kreuzen ihre Linien](https://c.mql5.com/2/64/rj-article-image-60x60.png)
![Deep Learning, Vorhersage und Aufträge mit Python, dem MetaTrader5 Python-Paket und ONNX-Modelldatei](https://c.mql5.com/2/64/Deep_Learning_Forecast_and_ordering_with_Python_and_MetaTrader5_python_packag___LOGOe.png)
![MQL5 - Sprache von Handelsstrategien, eingebaut ins Kundenterminal MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.