Création de Critères Personnalisés d’Optimisation des Expert Advisors

Introduction

Le terminal client MetaTrader 5 offre un large éventail de possibilités d’optimisation des paramètres de l’Expert Advisor. En plus des critères d’optimisation compris dans le testeur de stratégie, les développeurs sont offerts une opportunité de créer leurs propres critères. Cela conduit à un nombre presque illimité de possibilités de test et d’optimisation des Expert Advisors. L’article décrit des méthodes pratiques d’établir de tels critères - à la fois complexes et simples.

1. L’Examen des Caractéristiques du Testeur de Stratégie

Ce sujet a été abordé à plusieurs reprises, donc je ne vais faire qu’une liste d’articles avec leurs brèves descriptions. Je vous recommande de vous familiariser avec les documents suivants avant de lire cet article.

• "Les Fondamentaux du Test en MetaTrader 5". Il couvre tous les aspects techniques du test d’un Expert Advisor en détail - les modes de génération de tiques, le travail avec les prix ouverts et les barres M1. Il décrit l’utilisation des indicateurs lors des tests, l’émulation des variables d’environnement et la gestion des événements standard. En outre, il explique les bases des tests multi-devises.
• "Guide du Test et Optimisation d’ Expert Advisors en MQL5". Il couvre les questions de test et d’optimisation des paramètres d’entrée d’un Expert Advisor. Il décrit le processus d’ajustement des paramètres, l’interprétation des résultats des tests et la sélection des meilleurs paramètres.
• "Utilisation de la fonction TesterWithdrawal() pour modéliser les retraits de bénéfice". Il parle de l’utilisation de la fonction TesterWithdrawal pour modéliser les retraits d’argent d’un compte dans le testeur de stratégie. Il montre également comment cette fonction affecte l’algorithme de calcul des retraits d’actions dans le testeur de stratégie.
  

Et bien sûr, vous devez d’abord vous familiariser avec la titlehttps://www.metatrader5.com/fr/trading-platformtitledocumentation fournie avec le terminal client.

2. Les Critères d’Optimisation Intégrés dans le Testeur de Stratégie

Si vous examinez la documentation, vous trouverez la description suivante : titlehttps://www.metatrader5.com/fr/terminal/help/algotrading/testingtitle critère d’optimisationtitlehttps://www.metatrader5.com/ru/terminal/help/algotrading/optimization_types est un certain facteur, dont la valeur définit la qualité d’un ensemble de paramètres testés.title Plus la valeur du critère d’optimisation est élevée, meilleur est le résultat du test avec l’ensemble de paramètres donné.

Ici, nous devrons faire une note importante: un critère d’optimisation ne peut être utilisé que dans le mode d’optimisation de l’algorithme génétique. Il est clair que lorsque l’on passe en revue toutes les combinaisons possibles de valeurs de paramètres, il ne peut y avoir aucun facteur de choix des paramètres optimaux d’un Expert Advisor. L’autre côté est que nous pouvons enregistrer les résultats des tests, puis les traiter pour trouver une combinaison optimale de paramètres.

Comme il est écrit dans la documentation, le testeur de stratégie inclut les critèressuivants à utiliser avec l’algorithme génétique :

• Soldemax - la valeurla plus élevée du solde;
• Balance + maxProfit Factor- la valeur la plus élevée du produit du solde etfacteurde profit;
• Solde + maxGain attendu - la valeur du produit de l’équilibre et le gain https://www.metatrader5.com/fr/terminal/help/algotrading/testing attendu ;
• Solde + minRetrait - dans ce cas, la valeur du solde et le niveau de retrait https://www.metatrader5.com/fr/terminal/help/algotrading/testing sont pris en compte: (100% - Retrait)*Solde;
• Balance + maxRecovery Factor - le produit d’équilibre et le facteur de reprisetitlehttps://www.metatrader5.com/fr/terminal/help/algotrading/testing:title
• Balance + maxSharpe Ratio - la valeur du produit d’équilibre et le rapportde Sharpe;
• Custommax - critère personnalisé d’optimisation. Le critère d’optimisation ici est la valeur de la fonction OnTester() dans l’Expert Advisor. Ce paramètre permet d’utiliser n’importe quelle valeur personnalisée pour l’optimisation de l’Expert Advisor.

Un critère d’optimisation peut être sélectionné dans l’onglet Paramètres du testeur de stratégie comme le montre la fig. 1 :

Fig. 1. Choisir le critère d’optimisation pour Expert Advisor

Le critère Custom max, qui est le dernier de la liste, est le plus intéressant pour nous, et son utilisation fait l’objet de cet article.

3. Création de Critères d’Optimisation Personnalisés

La première chose à faire est de donner à un utilisateur la possibilité d’une combinaison libre de paramètres (non limités à ceux illustrés sur la fig. 1, mais personnalisés), qui sont calculés par le testeur de stratégie après chaque exécution d’un Expert Advisor.

Par exemple, la variante suivante est intéressante : Solde max + min Retrait + Numéro de trades - plus il y a de trades, plus le résultat est fiable. Ou le suivant - Solde max + minRetrait + max Profit Factor. Bien sûr, il existe de nombreuses autres combinaisons intéressantes qui ne sont pas comprises dans les paramètres du testeur de stratégie.

Appelons ces combinaisons de critère de simples critères d’optimisation.

Mais ces critères ne suffisent pas à établir une estimation fiable d’un système de trade. Si nous regardons du point de vue du concept de trading - faire un profit avec un risque minimal - nous pouvons admettre le critère suivant: nous pouvons optimiser les paramètres pour obtenir une courbe d’équilibre la plus lisse avec un écart minimal des résultats des trades séparés de la ligne droite.

Appelons ce critèrecritère d’optimisation par courbed’équilibre.

Le prochain critère d’optimisation que nous allons utiliser est le coefficient de sécurité d’un système de trade. Ce coefficient est décrit dans l’article https://championship.mql5.com/« Be In-Phase ». Il caractérise la correspondance d’un système de trade avec le marché; c’est ce que nous devons découvrir lors de l’optimisation des paramètres. Appelons-le comme critère d’optimisation par le coefficient de sécurité d’un système de trade (CSTS).

De plus, rendons possible la combinaison libre des critères décrits.

4. Fonction OnTester()

Avant d’écrire les parties du code, examinons l’organisation de l’utilisation des critères personnalisés d’optimisation EA dans le testeur de stratégie.

La fonction prédéfinie OnTester() est destinée à la création de critères d’optimisation personnalisés. Il est automatiquement appelé à la fin de chaque transmission de test d’un Expert Advisor dans un laps de temps spécifié. Cette fonction est appelée juste avant l’appel de la fonction OnDeinit().

Encore une fois, faites attention que pour utiliser la fonction OnTester(), vous devez activer le mode d’optimisation de l’algorithme de base génétique rapide, comme le montre la fig.1.

Cette fonction a le double format de la valeur renvoyée, qui est utilisée pour l’optimisation dans le testeur de stratégie.

Jetez un coup d’œil à la documentation une fois de plus:

Dans l’optimisation génétique, le tri décroissant est appliqué aux résultats en une génération. C’est-à-dire que du point de vue du critère d’optimisation, les meilleurs résultats sont ceux avec les valeurs les plus importantes. Dans un tel tri, les pires valeurs sont positionnées à la fin et rejetées davantage et ne participent pas à la formation de la générationsuivante.

Ainsi, lors de la création d’un critère d’optimisation personnalisé, nous devons obtenir une valeur intégrale qui sera utilisée pour l’estimation du trading de l’Expert Advisor. Plus la valeur est grande, meilleur est le trading de l’Expert Advisor.

5. Rédaction d’un Expert Advisor Expérimental

Il est maintenant temps de créer un Expert Advisor que nous allons optimiser dans le testeur de stratégie. Dans ce cas, les principales exigences pour cela sont d’être simple et rapide pour ne pas perdre beaucoup de temps dans la procédure de routine d’optimisation. En outre, il est souhaitable que l’Expert Advisor ne soit pas très peu rentable.

Prenons l’Expert Advisor décrit dans l’article « Plusieurs Moyens de Trouver une Tendance dans MQL5 » comme expérimental et améliorons-le. Notamment, l’EA basé sur le « fan » de trois moyennes mobiles. L’amélioration consiste à se débarrasser de l’utilisation de l’indicateur pour augmenter la vitesse de fonctionnement et à déplacer la partie calcul du code à l’intérieur de l’EA lui-même. Cela permet d’augmenter considérablement la vitesse des tests (près de trois fois sur une plage de deux ans).

La partie de la définition des paramètres d’entrée est simple:

input double Lots = 0.1; 
input int  MA1Period = 200; // period of the greatest moving average
input int  MA2Period = 50;  // period of the medium moving average
input int  MA3Period = 21;  // period of the smallest moving average

Les périodes des moyennes mobiles sont celles que nous allons optimiser.

La structure et le fonctionnement de l’Expert Advisor sont décrits en détail dans l’article mentionné ci-dessus, alors sautons-le ici. La principale innovation est le gestionnaire de l’événement d’achèvement d’un autre test réussi - la fonction OnTester(). Actuellement, il est vide et renvoie le contrôle.

//---------------------------------------------------------------------
//  The handler of the event of completion of another test pass:
//---------------------------------------------------------------------
double OnTester()
{
  return(0.0);
}

Le fichier de l’EA - FanExpert.mq5 est joint à cet article. Nous pouvons nous assurer que c’est identique à l’EA FanTrendExpert.mq5 du point de vue des deals passés. La vérification de l’existence et la direction d’un signal est effectuée à l’ouverture d’une nouvelle barre sur un graphique.

Pour obtenir le résultat des tests calculé à la fin de chaque transmission, testerStatistics() est utilisé ; il renvoie la valeur statistique demandée calculée à la suite du test. Il ne peut être appelé qu’à partir des fonctions OnTester() et OnDeinit(), sinon le résultat n’est pas défini.

Maintenant, ajoutons un critère d’optimisation personnalisé. Admettons que nous devons trouver des résultats optimaux sur la base d’une valeur maximale du facteur de reprise - facteur maximal de reprise. Pour ce faire, nous devons connaître les valeurs du retrait maximum du solde en argent et du bénéfice brut à la fin destests. Le fait de reprise est calculé comme la division du bénéfice sur le retrait maximal.

Cela se fait juste à titre d’exemple, puisque le facteur de reprise est déjà inclus dans la liste des résultats statistiques calculés des tests.

Pour ce faire, ajoutez le code simple suivant à la fonctionOnTester() :

//---------------------------------------------------------------------
//  The handler of the event of completion of another test pass:
//---------------------------------------------------------------------
double OnTester()
{
  double  profit = TesterStatistics(STAT_PROFIT);
  double  max_dd = TesterStatistics(STAT_BALANCE_DD);
  double  rec_factor = profit/max_dd;

  return(rec_factor);
}

La vérification de la division zéro est exclue du code pour faciliter les choses. Étant donné que le retrait maximal peut être égal à zéro, cette vérification doit être effectuée dans un véritable Expert Advisor.

Maintenant, créons le critère mentionné ci-dessus: Solde max + min Retrait + Numéro des Trades - Solde + Retrait Minimal + Nombre de Trades.

Pour ce faire, modifiez la fonctionOnTester() de la manière suivante :

double OnTester()
{
  double  param = 0.0;

//  Balance max + min Drawdown + Trades Number:
  double  balance = TesterStatistics(STAT_PROFIT);
  double  min_dd = TesterStatistics(STAT_BALANCE_DD);
  if(min_dd > 0.0)
  {
    min_dd = 1.0 / min_dd;
  }
  double  trades_number = TesterStatistics(STAT_TRADES);
  param = balance * min_dd * trades_number;

  return(param);
}

Ici, nous prenons une valeur qui est opposée au retrait, car plus le retrait est petit, meilleure est la situation, en supposant que les autres conditions soient égales. Exécutez l’optimisation de l’EA FanExpert avec le critère d’optimisation créé par le paramètre MA1Period en utilisant la plage 2009.06.01 - 2011.06.03 et la période Н1. Définissez la plage de valeurs de la moyenne mobile de 100 à 2000.

À la fin de l’optimisation, vous obtiendrez le tableau de valeurs suivant trié par les meilleurs paramètres:

Fig. 2. Les meilleurs résultats d’optimisation par le critère Balance max + min Retrait + Trades Number

Les meilleurs paramètres sont répertoriés ici (par la colonne Résultat).

Maintenant,jetons un coup d’œil aux pires paramètres:

Fig. 3. Les pires paramètres d’optimisation par le critère Balance max + min Retrait + Trades Number

En comparant deux tableaux, vous pouvez constater que le retrait et le profit sont considérés avec le nombre de trades, c’est-à-dire que notre critère d’optimisation fonctionne. De plus, nous pouvons voir le graphique d’optimisation (linéaire):

d’optimisationd’optimisation

Fig. 4. Le graphique d’optimisation par le critère Balancemax + min Retrait + Trades Number

L’axe horizontal affiche le paramètre optimisé et l’axe vertical affiche le critère d’optimisation. Nous pouvons voir le maximum clair du critère défini; il est situé dans la gamme de périodes 980 à 1200.

Vous devez comprendre et vous rappeler qu’il s’agit de l’optimisation génétique des paramètres, et non de la recherche complète. C’est pourquoi les tableaux présentés dans les fig. 2 et . 3 comportent les paramètres les plus « viables » qui ont transmis la sélection naturelle en plusieurs générations. Probablement, certaines variantes réussies ont été ignorées.

La courbe solde/capitaux propres pour la période 1106 se présente comme suit :

période MA1Period = 1106La courbe

Fig. 5. La courbe solde/capitaux propres pour la période MA1Period = 1106

6. Création de Classes de Critères d’Optimisation Personnalisés

Nous avons donc appris à créer et à utiliser des critères d’optimisation simples. Maintenant, faisons un cours pour simplifier leur utilisation dans Expert Advisors. L’une des principales exigences pour une telle classe est la vitesse de fonctionnement en plus de la commodité d’utilisation. Les calculs des critères d’optimisation doivent être effectués rapidement, sinon vous attendrez longtemps les résultats.

MetaTrader 5 permet d’utiliser la technologie de calcul cloud pour l’optimisation. Il s’agit d’une énorme percée, car le traitement d’un grand nombre de paramètres nécessite une puissance de calcul gigantesque. Ainsi, pour créer notre classe, nous allons utiliser les solutions les plus simples et les plus rapides, même si elles ne sont pas si élégantes du point de vue de la programmation.

Pour le développement, nous allons utiliser les classes standard d’organisation des données qui sont livrées avec le terminal client.

Tout d’abord, classons les types de résultats statistiquescalculés des tests:

• Type flottant ou entier avec la proportionnalité directe entre les valeurs du résultat du test et le critère d’optimisation.

En d’autres termes, plus la valeur du résultat des tests est grande, meilleure et plus grande est la valeur du critère d’optimisation. Un exemple frappant d’un tel résultat de test est le bénéfice brut à la fin des tests STAT_PROFIT. La valeur se présente en format flottant et peut passer de l’infini négatif (en fait, il est limité par la valeur du dépôt) à l’infini positif.

Un autre exemple du résultat des tests de ce type est le nombre de trades STAT_TRADES. Généralement, plus le nombre de trades est élevé, plus fiable est le résultat de l’optimisation. La valeur se présente en format entier et peut passer de zéro à l’infini positif.

• Type flottant ou entier avec la proportionnalité inverse entre les valeurs du résultat du test et le critère d’optimisation.

En d’autres termes, plus la valeur du résultat des tests est faible, meilleure et plus grande est la valeur du critère d’optimisation. Un exemple d’un tel résultat de test est le Retrait maximal du solde de l’argent STAT_BALANCE_DD ainsi que tout autre retrait.

Pour obtenir ce type de résultat de test, nous allons prendre une valeur inverse pour le calcul de la valeur du critère d’optimisation. Bien sûr, nous devons implémenter la vérification de la division zéro pour éviter l’erreur correspondante.

La classe de base pour la création des critères personnalisés d’optimisation TCustomCriterion est très simple. Son but est la détermination de la fonctionnalité de base. Il se présente comme suit :

class TCustomCriterion : public CObject
{
protected:
  int     criterion_level;        // type of criterion

public:
  int   GetCriterionLevel();
  virtual double  GetCriterion();  // get value of the result of optimization
};

La méthode virtuelleTCustomCriterion::GetCriteriondoit être remplacée dans les classes héritées. C’est la principale méthode qui renvoie la valeur des résultats intégraux d’un Expert Advisor au terme de chaque test réussi.

Le membre de classe TCustomCriterion::criterion_level stocke le type de critère personnalisé inhérent à cette instance de classe. Il sera utilisé davantage pour différencier les objets par leurs types.

Maintenant, nous pouvons en hériter toutes les classes nécessaires à l’optimisation.

La classe TSimpleCriterion est destinée à la création d’un critère personnalisé « simple » qui correspond à un résultat statistique de test spécifié. Sa détermination se présente comme suit :

class TSimpleCriterion : public TCustomCriterion
{
protected:
  ENUM_STATISTICS  stat_param_type;

public:
  ENUM_STATISTICS  GetCriterionType();     // get type of optimized stat. parameter

public:
  virtual double   GetCriterion(); // receive optimization result value
  TSimpleCriterion(ENUM_STATISTICS _stat); // constructor
};

Ici, nous utilisons un constructeur avec des paramètres; il est implémenté comme suit:

//---------------------------------------------------------------------
//  Constructor:
//---------------------------------------------------------------------
TSimpleCriterion::TSimpleCriterion(ENUM_STATISTICS _stat)
:
stat_param_type( _stat )
{
  criterion_level = 0;
}

Cette nouvelle caractéristique du langage MQL5 est pratique à utiliser lors de la création d’instances de classe. En outre, nous avons remplacé la méthode virtuelle TSimpleCriterion::GetCriterion qui est utilisée pour obtenir le résultat de l’optimisation à la fin de chaque test réussi. Son implémentation est simple :

//---------------------------------------------------------------------
//  Get the result of optimization:
//---------------------------------------------------------------------
double  TSimpleCriterion::GetCriterion()
{
  return(TesterStatistics(stat_param_type));
}

Comme vous le constatez, il renvoie simplement le résultat statistique correspondant des tests.

Le type suivant du critère personnalisé « simple » d’optimisation est créé à l’aide de la classe TSimpleDivCriterion. Il est consacré aux critères dont la proportionnalité inverséeentre les valeurs des résultats du test et les critères d’optimisation.

La méthode TSimpleDivCriterion::GetCriterion se présente comme suit :

//---------------------------------------------------------------------
//  Get value of the optimization result:
//---------------------------------------------------------------------
double  TSimpleDivCriterion::GetCriterion()
{
  double  temp = TesterStatistics(stat_param_type);
  if(temp>0.0)
  {
    return(1.0/temp);
  }
  return(0.0);
}

Ce code ne nécessite aucune description supplémentaire.

Deux autres types de critères d’optimisation personnalisés « simples » sont créés à l’aide des classes TSimpleMinCriterion et TSimpleMaxCriterion. Ils sont destinés à la création de critères avec des valeurs limitées de résultat statistique des tests à la fois par le bas et par le haut, respectivement.

Ils peuvent être utiles au cas où vous deviez rejeter délibérément des valeurs de paramètres erronées lors de l’optimisation. Par exemple, vous pouvez limiter le nombre minimal de trades, le retrait maximal, etc.

La description de la classe TSimpleMinCriterion se présente comme suit :

class TSimpleMinCriterion : public TSimpleCriterion
{
  double  min_stat_param;

public:
  virtual double  GetCriterion();    // receive optimization result value
  TSimpleMinCriterion(ENUM_STATISTICS _stat, double _min);
};

Ici, nous utilisons le constructeur avec deux paramètres. Le paramètre _min définit la valeur minimale d’un résultat statistique de test. Si un autre test réussi permet d’obtenir une valeur inférieure à celle spécifiée, le résultat est ignoré.

L’implémentation de la méthode TSimpleMinCriterion ::GetCriterion est la suivante :

//---------------------------------------------------------------------
//  Get value of the optimization result:
//---------------------------------------------------------------------
double  TSimpleMinCriterion::GetCriterion()
{
  double  temp = TesterStatistics(stat_param_type);
  if(temp<this.min_stat_param)
  {
    return(-1.0);
  }
  return(temp);
}

La classe TSimpleMaxCriterion est créée de la même manière et ne nécessite aucune description supplémentaire. Les autres classes des critères personnalisés « simples » sont créées de la même manière que celles décrites ci-dessus; elles se trouvent dans le fichier CustomOptimisation.mqh joint à cet article. Le même principe peut être utilisé pour créer n’importe quelle autre classe à utiliser dans l’optimisation.

Avant d’utiliser les classes décrites ci-dessus, créons une classe conteneur pour une opération plus pratique avec l’ensemble des critères. À cette fin, nous utilisons également les classes standard pour organiser lesdonnées. Puisque nous avons besoin d’un traitement simple et conséquent des critères, la classe la plus appropriée pour cela est CArrayObj. Il permet d’organiser un tableau dynamique d’objets hérités de la classe CObject.

La description de la classe de conteneur TCustomCriterionArray est très simple :

class TCustomCriterionArray : public CArrayObj
{
public:
  virtual double  GetCriterion( );  // get value of the optimization result
};

Il ne dispose que d’une seule méthode - TCustomCriterionArray::GetCriterion, qui renvoie la valeur du critère d’optimisation à la fin de chaque test réussi. Son implémentation est la suivante :

double  TCustomCriterionArray::GetCriterion()
{
  double  temp = 1.0;
  int     count = this.Total();
  if(count == 0)
  {
    return(0.0);
  }
  for(int i=0; i<count; i++)
  {
    temp *= ((TCustomCriterion*)(this.At(i))).GetCriterion();
    if(temp <= 0.0)
    {
      return(temp);
    }
  }

  return(temp);
}

Une chose à laquelle vous devez faire attention: si vous rencontrez une valeur négative lors du traitement des critères, la transmission ultérieure du cycle devient inutile. En outre, elle élimine la situation lorsque vous obtenez une valeur positive à la suite de la multiplication de deux valeurs négatives.

7. Utilisation de Classes de Critères d’Optimisation Personnalisés

Nous avons donc tout pour utiliser les critères personnalisés « simples » lors de l’optimisation des Expert Advisors. Analysons la séquence d’étapes d’amélioration de l’EA FanExpert« expérimental » :

• Ajoutez le fichier include qui comporte la description des classes des critères personnalisés:

#include <CustomOptimisation.mqh>

• Ajoutez le pointeur à l’objet de la classe conteneur pour l’utilisation de critères personnalisés :

TCustomCriterionArray*  criterion_Ptr;

• Initialisez le pointeur vers l’objet de la classe conteneur pour l’utilisation de critères personnalisés :

  criterion_array = new TCustomCriterionArray();
  if(CheckPointer(criterion_array) == POINTER_INVALID)
  {
    return(-1);
  }

Cela se fait dans la fonction OnInit. En cas d’échec de la création de l’objet, renvoyez avec une valeur négative. Dans ce cas, l’Expert Advisor interrompt l’opération.

• Ajoutez les critères d’optimisation requis à l’Expert Advisor :

  criterion_Ptr.Add(new TSimpleCriterion(STAT_PROFIT));
  criterion_Ptr.Add(new TSimpleDivCriterion(STAT_BALANCE_DD));
  criterion_Ptr.Add(new TSimpleMinCriterion(STAT_TRADES, 20.0));

Dans ce cas, nous avons décidé d’optimiser l’EA par le profit maximum, le retrait minimum et le nombre maximum de trades. De plus, nous éliminons les ensembles de paramètres externes de l’Expert Advisor qui débouchent sur moins de vingt trades.

• Ajoutez l’appel correspondant à la fonction OnTester :

  return(criterion_Ptr.GetCriterion());

• Dans la fonction OnDeinit, ajoutez le code de suppression de l’objet conteneur :

  if(CheckPointer(criterion_Ptr) == POINTER_DYNAMIC)
  {
    delete(criterion_Ptr);
  }

C’est tout avec l’optimisation. Exécutez l’optimisation et assurez-vous que tout fonctionne comme il est destiné. Pour ce faire, définissez les paramètres dans l’onglet Paramètres du testeur de stratégie comme illustré dans la figure ci-dessous :

Fig. 6. Paramètres du testeur de stratégie

Définissez l’onglet de la plage d’optimisation des paramètres d’entrée Paramètres d’entréedu testeur de stratégie comme indiqué dans la Fig 7:

Fig. 7. Paramètres d’entrée optimisés

Utilisez les agents du « cloud » pour l’optimisation. Pour ce faire, définissez les paramètres suivants dans l’onglet Agents :

Fig. 8. Paramètres des agents de test

Maintenant, cliquez sur le bouton Démarrer (fig.6) et attendez la finalité de l’optimisation. Lors de l’utilisation de la technologie de calcul « cloud », l’optimisation est rapidement exécutée. En fin de compte, nous obtenons les résultats d’optimisation suivants conformément aux critères spécifiés:

Fig. 9. Résultats de l’optimisation

Notre Expert Advisor « expérimental » a été optimisé avec succès. Il a fallu 13 minutes pour optimiser l’utilisation des agents « cloud ». L’EA de vérification du critère se trouve dans le fichier FanExpertSimple.mq5 joint à l’article.

8. Création d’une Classe d’un Critère d’Optimisation Personnalisé sur la Base de l’Analyse de la Courbe d’ Équilibre.

La base de création de cette classe est l’article « Contrôle de la Pente de la Courbe d’Équilibre Pendant le Travail d’un Expert Advisor ». L’idée de ce critère d’optimisation est de faire en sorte que la ligne d’équilibre soit au maximum proche d’une ligne droite. Le degré de proximité d’une ligne droite sera estimé par la valeur de l’écart-type des résultats du trade qui en découlent. L’équation d’une ligne droite sera calculée pour la ligne de régression tracée par les résultats des deals dans le testeur de stratégie.

Pour éliminer les courbes avec un solde subséquent négatif, définissez des limites supplémentaires - le bénéfice résultant doit être supérieur à une valeur spécifiée et le nombre de trades ne doit pas être inférieur à une valeur spécifiée.

Ainsi, notre critère d’optimisation sera inversement proportionnel à la valeur de l’écart-type des résultats de trade de la ligne droite compte tenu des limites du profit résultant et du nombre de trades.

Pour implémenter le critère d’optimisation sur la base de la courbe d’équilibre, nous avons besoin de la classe TBalanceSlope de l’article mentionné ci-dessus. Nous allons le changer: utilisez des constructeurs avec des paramètres (par souci de commodité) et ajoutez le calcul de l’écart-type au calcul de la régression linéaire. Ce code se trouve dans le fichier BalanceSlope.mqh joint à l’article.

La séquence d’étapes de l’ajout de ce critère d’optimisation à l’Expert Advisor est la même que celle décrite ci-dessus. Maintenant, les critères d’optimisation se décline comme suit:

criterion_Ptr.Add(new TBalanceSlopeCriterion(Symbol( ), 10000.0));

En plus du critère de la courbe d’équilibre, nous pouvons ajouter des critères que nous avons nous-mêmes créés. Pour les lecteurs, je laisse la possibilité d’expérimenter différents ensembles de paramètres statistiques de test.

Effectuons l’optimisation selon les critères définis. Pour acquérir plus de trades, effectuez l’optimisation en utilisant la période H4, la période 2010.01.01 - 2011.01.01 et le symbole EURUSD. Nous obtiendrons un ensemble de résultats:

Fig. 10. Le résultat de l’optimisation par la courbe d’équilibre

Maintenant, nous devons estimer la qualité de l’optimisation. Je pense que le critère principal est le travail de l’Expert Advisor en dehors de la période d’optimisation. Pour le vérifier, effectuez un seul test au cours de la période 2010.01.01-2011.06.14.

Comparez deux résultats (qui ont presque le même profit résultant) de l’ensemble des paramètres optimaux - le meilleur résultat avec un résultat du milieu. Les résultats en dehors de la période d’optimisation sont séparés par la ligne rouge :

Fig. 11. Le meilleur résultat de l’optimisation

Généralement, le comportement de la courbe ne s’est pas aggravé. La rentabilité a légèrement diminué, passant de 1,60 à 1,56.

Fig. 12. Le résultat moyen des tests

L’Expert Advisor n’est pas rentable en dehors de la période d’optimisation. La rentabilité a considérablement diminué, passant de 2,17 à 1,75.

Ainsi, nous pouvons conclure que l’hypothèse de corrélation de la courbe d’équilibre avec la durée de travail des paramètres optimisés a le droit d’exister. Certes, nous ne pouvons pas exclure la variante lorsqu’un résultat acceptable de l’utilisation de ce critère est inaccessible pour un Expert Advisor. Dans ce cas, nous devons effectuer des analyses et des expériences supplémentaires.

Probablement, pour ce critère, nous devons utiliser la période maximale possible (mais raisonnable). L’Expert Advisor chargé de la vérification de ce critère se trouve dans le fichier FanExpertBalance.mq5 joint à l’article.

9. Création d’une Classe d’un Critère d’Optimisation Personnalisé sur la Base du Coefficient du Système de Trade sûr (CSTS)

Comme il est décrit dans « Be in-Phase », le coefficient du système de trade sûr (CSTS) est calculé à l’aide de la formule suivante :

CSTS = Avg.Win / Avg.Loss ((110% - %Win) / (%Win-10%) + 1)

Où :

• Avg.Win - la valeur moyenne d’un deal rentable;
• Perte moyenne - la valeur moyenne d’un deal perdant;
• %Win - le pourcentage de deals rentables;

Si la valeur CSTS est inférieure à 1, le système de trade se trouve dans la zone de risque élevé de trade; des valeurs encore plus petites indiquent la zone de trading non rentable. Plus la valeur de CSTS est grande, mieux le système de trade s’adapte au marché et plus il est rentable.

Toutes les valeurs statistiques requises pour le calcul du CSTS sont calculées dans le test de stratégie après chaque test réussi. Il reste à créer la classe TTSSFCriterion héritée de TCustomCriterion et à y implémenter la méthode GetCriterion(). L’implémentation de cette méthode dans le code est la suivante :

double  TTSSFCriterion::GetCriterion()
{
  double  avg_win = TesterStatistics(STAT_GROSS_PROFIT) / TesterStatistics(STAT_PROFIT_TRADES);
  double  avg_loss = -TesterStatistics(STAT_GROSS_LOSS) / TesterStatistics(STAT_LOSS_TRADES);
  double  win_perc = 100.0 * TesterStatistics(STAT_PROFIT_TRADES) / TesterStatistics(STAT_TRADES);

//  Calculated safe ratio for this percentage of profitable deals:
  double  teor = (110.0 - win_perc) / (win_perc - 10.0) + 1.0;

//  Calculate real ratio:
  double  real = avg_win / avg_loss;

//  CSTS:
  double  tssf = real / teor;

  return(tssf);
}

Je suppose que de courtes périodes conviennent à ce critère d’optimisation. Cependant, pour éviter l’ajustement, il vaut mieux prendre les résultats qui sont au milieu des résultats d’optimisation.

Donnons à nos lecteurs la possibilité d’effectuer eux-mêmes l’optimisation. L’Expert Advisor chargé de vérifier ce critère se trouve dans le fichier FanExpertTSSF.mq5 joint à l’article.

Conclusion

Quoi qu’il en soit, vous devez avouer qu’une solution aussi simple à l’implémentation de la possibilité de créer des critères d’optimisation personnalisés (en utilisant un seul taux intégral) est presque parfaite par rapport à d’autres variantes. Il permet d’élever la barre du développement de systèmes de trade robustes vers un niveau supérieur. L’utilisation de la technologie « cloud » réduit considérablement la limitation des optimisations effectuées.

D’autres modes d’évolution peuvent être liés à des critères mathématiquement et statistiquement étayés décrits dans différentes sources d’information. Nous avons un outil pour cela.