Inhalt

• 1. Einführung
• 2. Wie berechnet man eine Trendlinie aus einer Grafik der Salden?
• 2.1. Algorithmus der Berechnung des Kriteriums für die Optimierung
• 2.2. Einführung der ersten Variable TrendProfit
• 2.3. Die Variable ProfitStability
• 3. Arbeiten mit der Bibliothek ALGLIB
• 3.1. Berechnungsschritte (Methode GetProfitStability)
• 4. Einbinden der Klasse CBalanceRegression
• 4.1. Ein Expert Advisor erstellt mit dem MQL5 Wizard
• 4.2. Ein Expert Advisor einem standardmäßigen MACD und einer mit gleitendem Durchschnitt
• 5. Optimierung mit EURUSD H4, kein Vorwärts-Test
• 5.1. "EA-Test Salden regression.mq5", EURUSD H4, kein Vorwärts-Test
• 5.1.1 Test 1
• 5.1.2. Vergleich der Testgeschwindigkeit zwischen der im lokalen Netzwerk mit zwei PC und der in der Cloud
• 5.1.3. Test 2
• 5.1.4. Test 3
• 5.2. "Moving Average balance regression.mq5", EURUSD H4, kein Vorwärts-Test
• 5.2.1. Test 1 
• 5.2.2. Test 2
• 5.2.3. Test 3
• 5.3. "MACD Sample balance regression.mq5", EURUSD H4, kein Vorwärts-Test
• 5.3.1. Test 1 
• 5.3.2. Test 2
• 5.3.3. Test 3
• 6. Optimierung mit EURUSD M15 mit Vorwärts-Test
• 6.1. EA "EA test balance regression.mq5", Vorwärts-Test
• 6.1.1. Test 1
• 6.1.2. Test 2
• 6.1.3. Test 3
• 6.2. EA "MACD Sample balance regression.mq5", Vorwärts-Test
• 6.2.1. Test 1
• 6.2.2. Test 2
• 6.2.3. Test 3
• 6.3. EA "Moving Average balance regression.mq5", Vorwärts-Test
• 6.3.1. Test 1
• 6.3.2. Test 2
• 6.3.3. Test 3
• 7. Schlussfolgerung

1. Einführung

Während meiner Arbeit wurde mir klar, dass es für die Saldenkurve nicht ausreicht, einfach nur das historische Wachstum zu beurteilen. Außerdem sollte sie möglichst gerade sein. Mit anderen Worten, die mittlere quadratische Abweichung von der Trendlinie sollte so klein wie möglich sein. Das bedeutet, dass wir neben Profit auch Stabilität erreichen wollen. Um das zu erreichen, lassen Sie uns noch einen weiteren Optimierungsparameter überprüfen: Die Saldenkurve und die Varianz der Abweichungen der Werte von der Regressionsgeraden.

Wir verwenden die Bibliothek ALGLIB für numerische Berechnungen der linearen Regression und einige andere statistischer Kenngrößen.

2. Wie berechnet man eine Trendlinie aus einer Grafik der Salden?

Wir müssen jene Trendlinie für die Saldenkurve ermitteln, die die Summe der Quadrate der Abweichungen von der Linie minimiert.

Die Parameter der Geradengleichung y=ax+b werden mit der Standardmethode des kleinsten Quadrats (LS) ermittelt. Ich werde nicht alle notwendigen mathematischen Gleichungen entwickeln. Stattdessen werde ich eine fertige Funktion aus der Bibliothek ALGLIB verwenden, die an unsere Erfordernisse angepasst wird.

2.1. Algorithmus der Berechnung des Kriteriums für die Optimierung

Schauen wir uns ein Beispiel von fünf Positionen an:

Abb. 1. Saldenkurve und die lineare Regression

Diese fünf Positionen aus "Balance" 1-2-3-4-5 Saldenkurve. Die linearen Regression wird mit die Methode der kleinsten Quadrate berechnet und gezeichnet (berechnet durch die numerische Analyse der Bibliothek ALGLIB).

2.2. Einführung der ersten Variable TrendProfit

Sie steht für Gewinn je Position in der gezeichneten Linie:

Abb. 2. TrendProfit parameter

Die Variable errechnet sich aus dem Verhältnis der Regressionsgeradenhöhe zur Anzahl der Positionen. Die Höhe wird wiederum als Differenz der Regressionsgeraden an den Punkten B und A berechnet.

Nun müssen wir den Fehler der Regressionsgeraden ermitteln - die durchschnittliche Abweichung der Regressionsgeraden von der Saldenkurve. Wir nennen dies die Standardabweichung der Salden von der linearen Regression und kennzeichnen sie als LR Standardabweichung:

Pic. 3. LR Standardabweichung

In dieser Gleichung wird der Fehler aus der Differenz vom Saldo und dem Wert der linearen Regression ermittelt. Sie finden Details dazu hier (auf russisch). 

Im Fall der Abb. 1, sind die Fehler wir folgt:

Daher errechnet sich der LR Standardabweichung wie folgt:

Pic. 4. Berechnung des LR Standardabweichungs

2.3. Die Variable ProfitStability.

Dieser Parameter ist verantwortlich für die Glätte des Saldenkurve. Unsere Ziele:

• Die Regressionsgerade sollte möglichst steil sein, relativ zur Waagerechten - das bedeutet mehr Gewinn;
• Die Abweichung der Saldenkurve von der Regressionsgeraden sollte so gering wie möglich sein - dies deutet auf eine stabilere Handelsbilanz hin.

Die ProfitStability wird als Verhältnis von TrendProfit und LR Standardabweichung berechnet:

Pic. 5. Die Variable ProfitStability 

Um die Auswirkungen von Positionen mit unterschiedlichen Volumina zu reduzieren, können wir die Variable ProfitStability durch das Gesamtvolumen aller Positionen dividieren.

3. Arbeiten mit der Bibliothek ALGLIB

Pic. 6. Der Pfad zu Bibliothek ALGLIB in der Standardbibliothek

Die Klassen der Bibliothek ALGLIB 

• Klasse CLinReg — Basisklasse zur Berechnung der linearen Regression
• Methode CLinReg::LRBuild — Berechnet die linearen Regression
• Methode CLinReg::LRUnpack — Rückgabe des Koeffizienten der linearen Modells
• Klasse CLinearModel — Hilfsklasse
• Klasse CLRReport — Struktur, die die erweiterten Daten des linearen Modells enthält. Insbesondere interessieren wir uns für die Variable m_rmserror (mittlerer quadratischer Fehler).

Klasse BalanceRegression.mqh

Alle Arbeiten, die mit der linearen Regression und der Parameterberechnung zusammenhängen, werden in der Klasse BalanceRegression.mqh ausgeführt.

Methoden der Klassen

Die Arbeit mit CBalanceRegression umfasst folgende Schritte.

1. Bestimmen des Anfangssaldo — Aufruf der Methode SetStartBalance.
2. Setzten das Anfangsdatum in der Handelshistorie — Aufruf der Methode SetFromDate.
3. Bestimmen der Art, die Volumina zu normalisieren — Aufruf der Methode SetVolumeNormalization. Wenn Sie die Volumina normalisieren wollen, über geben Sie 'true', sonst — 'false'. 
4. Abfrage der Ergebnisse — Aufruf der Methode GetProfitStability, sie gibt die Ergebnisse von OnTester zurück.

3.1. Berechnungsschritte (Methode GetProfitStability)

Die Ergebnisse der Positionen mit (Kommission + Swap + Gewinn) > 0.0 werden im Array arr_profits gesichert. Die Volumina aller Positionen müssen in der Variablen total_volume aufsummiert werden.

//---
   double   arr_profits[];                            // array of results deals 
   double   total_volume=0;                           // total volume

Als nächstes gehen Sie alle Positionen durch - tragen Sie sie in das Array arr_profits ein und addieren Sie die Volumina der Positionen zur Variablen total_volume:

//--- request trade history 
   HistorySelect(m_from_date,to_date);
   uint total_deals=HistoryDealsTotal();
   ulong ticket_history_deal=0;
//--- for all deals 
   for(uint i=0;i<total_deals;i++)
     {
      //--- try to get deals ticket_history_deal 
      if((ticket_history_deal=HistoryDealGetTicket(i))>0)
        {
         long     deal_type         =HistoryDealGetInteger(ticket_history_deal,DEAL_TYPE);
         double   deal_volume       =HistoryDealGetDouble(ticket_history_deal,DEAL_VOLUME);
         double   deal_commission   =HistoryDealGetDouble(ticket_history_deal,DEAL_COMMISSION);
         double   deal_swap         =HistoryDealGetDouble(ticket_history_deal,DEAL_SWAP);
         double   deal_profit       =HistoryDealGetDouble(ticket_history_deal,DEAL_PROFIT);

         if(deal_type!=DEAL_TYPE_BUY && deal_type!=DEAL_TYPE_SELL)
            continue;

         if(deal_commission==0.0 && deal_swap==0.0 && deal_profit==0.0)
            continue;

         total_volume+=deal_volume;

         int arr_size=ArraySize(arr_profits);
         ArrayResize(arr_profits,arr_size+1,50);   // resize the aray

         if(arr_size==0)
            arr_profits[arr_size]=GetSetStartBalance()+deal_commission+deal_swap+deal_profit;
         else
            arr_profits[arr_size]=arr_profits[arr_size-1]+deal_commission+deal_swap+deal_profit;

         int d=0;
        }
     }

Anmerkung: Wenn wir den ersten Eintrag in das Array arr_profits vornehmen, summieren wir den Anfangssaldo und die Resultate der Positionen. Für alle nachfolgenden Einträge summieren Sie die vorherige Eintragung und das Endergebnis des Handels.

Deklarieren Sie das Objekt der Klasse CMatrixDouble. Eigentlich ist das eine Matrix. Füllen wir sie aus: Positionsnummer (beginnend in "1") und das finanzielle Ergebnis.

//--- CMatrixDouble object
   CMatrixDouble xy(arr_size,2);
   for(int i=0;i<arr_size;i++)
     {
      xy[i].Set(0,i+1);
      xy[i].Set(1,arr_profits[i]);
      //Print(arr_profits[i]); // for debag
     }

Deklarieren Sie die Objekte der benötigten Klassen (CLinReg, CLinearModel, CLRReport) und berechnen Sie die linearen Regression:

//--- linear regression construction
   CLinReg        linear_regression;
   CLinearModel   linear_model;
   CLRReport      linear_report;
   int retcode;
   linear_regression.LRBuild(xy,arr_size,1,retcode,linear_model,linear_report);
   if(retcode!=1)
     {
      Print("Linear regression failed, error code=",retcode);
      return(0.0);
     }
   int nvars;
   double coefficients[];
   linear_regression.LRUnpack(linear_model,coefficients,nvars);
   double coeff_a=coefficients[0];
   double coeff_b=coefficients[1];
   PrintFormat("y = %.1f x + %.1f",coeff_a,coeff_b);

Rufen Sie schließlich die Methode LRUnpack auf, um die Koeffizienten für der Gleichung y = a*x + b zu erhalten. Die Koeffizienten sind im Array der Koeffizienten.

Nachdem wir nun die lineare Regression mit Hilfe der Bibliothek ALGLIB berechnet haben, können wir direkt mit der Berechnung des Parameters fortfahren, der den Schwerpunkt des gesamten Artikels bildet.

//--- сalculation of parameters
   double TrendProfit=((double)arr_size*coeff_a+coeff_b)-(1.0*coeff_a+coeff_b);  // the projection of the regression line on the "Y" axis 
   TrendProfit/=(double)arr_size;                                                // divided by the number of trades
   double TrendMSE=linear_report.m_rmserror;                                     // root mean square error on a training set
   double ProfitStability=TrendProfit/TrendMSE;
//--- normalize the trading volume
   if(GetVolumeNormalization())
      ProfitStability/=total_volume;
//--- we multiply by the number of deals - we aren't interested in passes which have few deals
   ProfitStability*=arr_size;
//---
   return(ProfitStability*10000.0);

Abhängig vom anfänglichen Parametern, gesetzt von der Methode SetVolumeNormalization, teilen wir den Parameter ProfitStability entweder in die Summe der gehandelten Volumina auf oder nicht. Das Ergebnis wird mit 10 000 multipliziert, um die Ergebnisse besser darstellen zu können.

4. Einbinden der Klasse CBalanceRegression

Betrachten wir den Vorgang verschiedener EAs, die Klasse CBalanceRegression einzubinden.  

4.1. Ein Expert Advisor erstellt mit dem MQL5 Wizard

Wir wollen prüfen, wie sich die Normalisierung der gehandelten Volumina auf das Ergebnis auswirkt. Das bedeutet, dass wir einen EA benötigen, der dynamisch das Volumen der offenen Positionen berechnet. Dies kann im MQL5 Wizard geschehen: Wählen Sie Expert Advisor (erstellen) und fügen Sie eines der Geldmanagementmodule auf der Seite "Geldmanagement" hinzu:

• "Handeln mit fixer Margin" — berechnet die Lotgröße in % der freien Margin
• "Handeln mit fixem Risiko" — berechnet die Lotgröße in % des Kontosaldos
• "Handeln mit optimierten Handelsvolumen" — berechnet die Lotgröße in Abhängigkeit der Handelshistorie

Für diesen Artikel wählte ich das Geldmanagementmodul "Handeln mit fixem Risiko", und der EA heißt "EA test balance regression.mq5". Beispielsweise zeige ich die Einbindung der Datei mit der Klasse CBalanceRegression.

Schritt 1. Einbinden der Datei CBalanceRegression und Anlegen des Klassenobjektes (m_balance_regression).

//--- available money management
#include <Expert\Money\MoneyFixedRisk.mqh>
//--- available module Balance Regression
#include <Balance regression\BalanceRegression.mqh>
//+------------------------------------------------------------------+
//| Inputs                                                           |
//+------------------------------------------------------------------+

and

//+------------------------------------------------------------------+
//| Global expert object                                             |
//+------------------------------------------------------------------+
CExpert ExtExpert;
CBalanceRegression m_balance_regression;
//+------------------------------------------------------------------+
//| Initialization function of the expert                            |
//+------------------------------------------------------------------+

Schritt 2. Ergänzen eines Eingabeparameters, um das Normalisieren der Volumina zu aktivieren/deaktivieren:

input double             Money_FixRisk_Percent=10.0;                            // Percentage of risk
//--- inputs for balance normalization
input bool               InpVolumeNormalization=true;                           // Volume normalization
//+------------------------------------------------------------------+
//| Global expert object                                             |
//+------------------------------------------------------------------+

Schritt 3. Legen Sie die Parameter für das Objekt m_balance_regression der Klasse CBalanceRegression fest: Ausgangsdaten für die Abfrage der Handelshistorie und des Modus der Normalisierung des Handelsvolumens:

//+------------------------------------------------------------------+
//| Initialization function of the expert                            |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Set parameters of CBalanceRegression
   m_balance_regression.SetStartBalance(AccountInfoDouble(ACCOUNT_BALANCE));
   m_balance_regression.SetFromDate(TimeCurrent());
   m_balance_regression.SetVolumeNormalization(InpVolumeNormalization);
//--- Initializing expert

Schritt 4. Fügen Sie die Funktion OnTester ganz am Ende der Datei hinzu. Hier erhalten wir das eigene Optimierungskriterium (durch Aufruf von GetProfitStability) und übergeben die Parameter an den Tester:

//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
//---
   double ret=m_balance_regression.GetProfitStability(TimeCurrent());
//---
   return(ret);
  }

4.2. Der Expert Advisors auf Basis eines standardmäßigen MACD und einem gleitenden Durchschnitt

Die originalen EAs befinden sich in [Datenordner]\MQL5\Experten\Beispiele\MACD\MACD Sample.mq5 bzw. [Datenordner]MQL5\Experten\Beispiele\Moving Average\Moving Average.mq5.

Nehmen Sie die original EAs und speichern Sie ihre Kopien unter einem anderen Namen. Ich habe die Namen "MACD Sample balance regression.mq5" und "Moving Average balance regression.mq5" gewählt.

#include <Trade\AccountInfo.mqh>
//--- available module Balance Regression
#include <Balance regression\BalanceRegression.mqh>
CBalanceRegression m_balance_regression;
//---
input double InpLots          =0.1; // Lots

#include <Trade\Trade.mqh>
//--- available module Balance Regression
#include <Balance regression\BalanceRegression.mqh>
CBalanceRegression m_balance_regression;

input double MaximumRisk        = 0.02;    // Maximum Risk in percentage

input int    InpMATrendPeriod =26;  // MA trend period
//--- inputs for balance normalization
input bool   InpVolumeNormalization=true; // Volume normalization
//---
int ExtTimeOut=10; // time out in seconds between trade operations

input int    MovingShift        = 6;       // Moving Average shift
//--- inputs for balance normalization
input bool   InpVolumeNormalization=true;  // Volume normalization
//---
int    ExtHandle=0;

//+------------------------------------------------------------------+
//| Initialization and checking for input parameters                 |
//+------------------------------------------------------------------+
bool CSampleExpert::Init(void)
  {
//--- Set parameters of CBalanceRegression
   m_balance_regression.SetStartBalance(AccountInfoDouble(ACCOUNT_BALANCE));
   m_balance_regression.SetFromDate(TimeCurrent());
   m_balance_regression.SetVolumeNormalization(InpVolumeNormalization);
//--- initialize common information

//+------------------------------------------------------------------+
//| Initialisierungsfunktion des Experten                            |
//+------------------------------------------------------------------+
int OnInit(void)
  {
//--- Set parameters of CBalanceRegression
   m_balance_regression.SetStartBalance(AccountInfoDouble(ACCOUNT_BALANCE));
   m_balance_regression.SetFromDate(TimeCurrent());
   m_balance_regression.SetVolumeNormalization(InpVolumeNormalization);
//--- prepare trade class to control positions if hedging mode is active

//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
//---
   double ret=m_balance_regression.GetProfitStability(TimeCurrent());
//---
   return(ret);
  }

Fazit: Die Optimierung durch den Parameter "Custom max" in beiden Tests (Test 2 und 3) schaffte es, bessere Ergebnisse als in Test 1 zu erzielen. Der Parameter für die Optimierung des gehandelten Volumens, der gleich 'true' ist, hat in Test 3 keine Korrekturen vorgenommen.

5.3. MACD Sample balance regression.mq5, EURUSD, H4, kein Vorwärts-Test

Die folgenden Parameter werden zur Optimierung ausgewählt:

Pic. 19. EA-Fenster zur Optimierung

Ich werde die gleichen drei Tests mit dem EA "MACD Sample balance regression" durchführen:

• Test 1: Optimierung der Standardparameter "Balance + max Sharp Ratio"
  
• Test 2: Optimierung des benutzerdefinierten Parameters "Custom max", während der Parameter für die Optimierung der gehandelten Volumina 'false' ist,
  
• Test 3: Optimierung des benutzerdefinierten Parameters "Custom max", während der Parameter für die Optimierung der gehandelten Volumina 'true' ist.

6. Optimierung mit EURUSD M15 mit Vorwärts-Test

Vorwärts-Ergebnisse:

Abb. 27. Test 1, EURUSD M15, Vorwärtsdurchlauf 78

6.2.2. Test 2: Optimierung des benutzerdefinierten Parameters "Custom max", während der Parameter für die Optimierung der gehandelten Volumina 'false' ist,

Ergebnisse der Optimierung:

Abb. 28. Test 2, EURUSD M15, Optimierungsdurchlauf 168

Vorwärts-Ergebnisse:

Abb. 29. Test 2, EURUSD M15, Vorwärtsdurchlauf 78

6.2.3. Test 3: Optimierung des benutzerdefinierten Parameters "Custom max", während der Parameter für die Optimierung der gehandelten Volumina, der auf 'true' gesetzt ist, in der Cloud ausgeführt wird. In der Cloud dauert der Test 1 Minute und 44 Sekunden. Der gesamte Test lief in der MQL5 Cloud Europe 1. Die Kosten betrugen $0.08.

Ergebnisse der Optimierung:

Vorwärts-Ergebnisse:

6.3. Der EA "Moving Average balance regression.mq5", Vorwärts-Test

6.3.1. Test 1: Optimierung der Standardparameter "Balance + max Sharp Ratio". Die Parameter des Testers sind ähnlich mit denen der Abb. 15. und die für den EA ähnlich denen der Abb. 23.

In der Cloud dauert der Test 1 Minute und 28 Sekunden. Der gesamte Test lief in der MQL5 Cloud Europe 1. Die Kosten betrugen $0.05.

Ergebnisse der Optimierung:

Abb. 30. Test 1, EURUSD M15, Optimierungsdurchlauf 53

Vorwärts-Ergebnisse:

Abb. 31. Test 1, EURUSD M15, Vorwärtsdurchlauf 48

6.3.2. Test 2: Optimierung des benutzerdefinierten Parameters "Custom max", während der Parameter für die Optimierung der gehandelten Volumina 'false' ist. 

Ergebnisse der Optimierung: 

Vorwärts-Ergebnisse:

6.3.3. Test 3: Optimierung des benutzerdefinierten Parameters "Custom max", während der Parameter für die Optimierung der gehandelten Volumina, der auf 'true' gesetzt ist, in der Cloud ausgeführt wird. In der Cloud benötigt der Test 0 Minuten und 42 Sekunden. Der gesamte Test lief in der MQL5 Cloud Europe 1. Die Kosten betrugen $0.04. 

Ergebnisse der Optimierung:

Vorwärts-Ergebnisse: 

7. Schlussfolgerung