Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Strategy Tester

OnTester : créer un critère d’optimisation personnalisé en MQL5

Avec OnTester et TesterStatistics, notez vous-même chaque passe d’optimisation : rendement rapporté au drawdown, régularité de la courbe et nombre minimal de trades, exemple MQL5 complet.

Mis à jour le 23 octobre 2026Lecture : 9 minPar Alix, OptiBot Trading

OnTester() est la fonction événementielle qu’un Expert Advisor peut déclarer pour noter lui-même chaque passe de test : elle est appelée à la fin du test, juste avant OnDeinit(), et la valeur double qu’elle renvoie devient le critère « Custom max » de l’optimisation. À l’intérieur, vous lisez les statistiques de la passe avec TesterStatistics() (profit, drawdown, nombre de trades…) ou celles que vous avez calculées vous-même pendant le test, puis vous les combinez en un score qui reflète ce que vous attendez vraiment d’une stratégie.

Cette page montre comment écrire un critère personnalisé robuste, avec un exemple complet. Elle fait partie de la rubrique Strategy Tester et optimisation. Pour comparer d’abord les critères intégrés, voyez Critères d’optimisation.

Signature et cycle de vie

double OnTester();

Points clés, d’après la documentation MQL5 :

  • OnTester() n’est appelée que lors du test d’un Expert Advisor, à la fin de chaque passe et avant OnDeinit() ;
  • sa valeur de retour est le critère « Custom max » ; elle apparaît aussi dans le rapport sous le nom « OnTester result » et est accessible via TesterStatistics(STAT_CUSTOM_ONTESTER) ;
  • TesterStatistics() ne donne un résultat défini que dans OnTester() ou OnDeinit() pendant un test ;
  • si la passe est interrompue par TesterStop(), OnTester() est quand même appelée et ses statistiques transmises ;
  • en mode « Math calculations », seules OnInit(), OnTester() et OnDeinit() sont appelées.

OnTester() s’exécute sur l’agent qui a calculé la passe, pas sur votre terminal. Pour rapatrier des données plus riches qu’un seul nombre, utilisez les frames : voir Frames : exporter les résultats d’optimisation.

Ce qu’un bon critère doit faire

Un critère personnalisé sert à corriger les biais des critères simples. En pratique, il doit :

  1. Exiger un échantillon suffisant : en dessous d’un nombre minimal de trades, la passe ne vaut rien, quel que soit son profit.
  2. Pénaliser le risque : rapporter le gain au drawdown, de préférence d’equity.
  3. Récompenser la régularité : une courbe qui monte régulièrement est préférable à une courbe portée par deux trades exceptionnels.
  4. Rester continu : de petits changements de paramètres doivent produire de petits changements de score, sinon l’algorithme génétique se comporte de façon erratique. Évitez les paliers brutaux quand c’est possible.
  5. Être lisible : vous devez pouvoir expliquer pourquoi une passe a battu une autre.

Exemple complet : rendement, risque et régularité

Ce critère combine trois éléments : le rapport entre profit net et drawdown maximal d’equity, la régularité de la courbe d’equity mesurée par le coefficient de détermination R² d’une régression linéaire, et une pénalité progressive quand le nombre de trades est insuffisant. L’equity est échantillonnée à chaque nouvelle barre pendant le test.

//+------------------------------------------------------------------+
//| Critère personnalisé : (profit / DD equity) x R² x pénalité      |
//+------------------------------------------------------------------+
input int InpMinTrades = 100;   // Trades souhaités pour une note pleine

double   g_equity[];            // equity échantillonnée à chaque barre
datetime g_lastBar = 0;

int OnInit()
  {
   ArrayResize(g_equity, 0, 10000);   // réserve pour limiter les réallocations
   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   datetime t = iTime(_Symbol, _Period, 0);
   if(t != g_lastBar)
     {
      g_lastBar = t;
      int n = ArraySize(g_equity);
      ArrayResize(g_equity, n + 1, 10000);
      g_equity[n] = AccountInfoDouble(ACCOUNT_EQUITY);
     }
   // ... logique de trading de votre EA ...
  }

// R² de la régression linéaire de l'equity sur le temps (0 à 1)
double RegressionR2(const double &y[], double &pente)
  {
   int n = ArraySize(y);
   pente = 0.0;
   if(n < 3)
      return(0.0);
   double sx = 0, sy = 0, sxx = 0, sxy = 0, syy = 0;
   for(int i = 0; i < n; i++)
     {
      sx  += i;
      sy  += y[i];
      sxx += (double)i * i;
      sxy += i * y[i];
      syy += y[i] * y[i];
     }
   double cov = n * sxy - sx * sy;
   double vx  = n * sxx - sx * sx;
   double vy  = n * syy - sy * sy;
   if(vx <= 0.0 || vy <= 0.0)
      return(0.0);
   pente = cov / vx;
   return((cov * cov) / (vx * vy));
  }

double OnTester()
  {
   double trades = TesterStatistics(STAT_TRADES);
   double profit = TesterStatistics(STAT_PROFIT);
   double ddEq   = TesterStatistics(STAT_EQUITY_DD);   // drawdown d'equity en devise

   if(trades < 1 || profit <= 0.0)
      return(0.0);                     // passes perdantes ou vides : note nulle

   double pente = 0.0;
   double r2 = RegressionR2(g_equity, pente);
   if(pente <= 0.0)
      return(0.0);                     // courbe globalement descendante

   double rendementRisque = profit / MathMax(ddEq, 1.0);
   // Pénalité progressive (continue) si l'échantillon est trop petit
   double penalite = MathMin(1.0, trades / (double)InpMinTrades);
   penalite *= penalite;

   return(rendementRisque * r2 * penalite);
  }

Quelques choix expliqués :

  • STAT_EQUITY_DD plutôt que le drawdown de solde : il intègre les pertes latentes, ce qui pénalise les stratégies qui laissent courir les positions perdantes.
  • MathMax(ddEq, 1.0) évite une division par zéro et des scores infinis pour une passe sans drawdown.
  • La pénalité au carré rend le manque de trades de plus en plus coûteux tout en restant continue : 50 trades sur 100 souhaités divisent le score par quatre.
  • Le R² est calculé sur l’equity par barre et non par trade, ce qui tient compte des périodes sans position.

Pour que le score soit comparable d’une passe à l’autre, le dimensionnement des positions doit être cohérent : un robot qui risque un pourcentage fixe du capital produit des drawdowns comparables, voir Intégrer la gestion du risque.

Variantes utiles

  • Pénaliser le temps passé en drawdown : comptez dans OnTick() les barres où l’equity est sous son plus haut, et divisez le score par une fonction de cette durée.
  • Équilibrer achats et ventes : comparez STAT_PROFIT_LONGTRADES et STAT_PROFIT_SHORTTRADES (nombres de trades gagnants dans chaque sens) aux totaux STAT_LONG_TRADES et STAT_SHORT_TRADES pour écarter les réglages qui ne gagnent que d’un côté.
  • Exploiter l’historique des transactions : dans OnTester(), HistorySelect() puis HistoryDealGetDouble() donnent le résultat de chaque transaction, ce qui permet de calculer une espérance médiane ou un ratio de gain sur perte moyen.

OnTester et la période forward

Lorsque vous réservez une période forward dans les réglages, chaque passe sélectionnée est rejouée sur cette période, et OnTester() est appelée à la fin de ce second test comme à la fin du premier. Le tableau des résultats forward affiche donc votre score calculé sur des données que l’optimisation n’a pas vues. Dans le code, MQLInfoInteger(MQL_FORWARD) indique si la passe en cours est une passe forward, ce qui permet par exemple d’adapter le seuil minimal de trades à une période plus courte : une période forward d’un tiers de l’historique produit environ trois fois moins de trades. Sans cet ajustement, la pénalité d’échantillon écraserait systématiquement les scores forward et fausserait la comparaison. La méthode de comparaison est détaillée dans Forward testing.

Interpréter l’échelle du score

Un score personnalisé n’a pas d’unité universelle : il ne sert qu’à classer des passes entre elles, pour une même stratégie, une même période et un même dépôt. Ne le comparez pas d’une stratégie à l’autre, et ne cherchez pas à atteindre une valeur « cible ». Ce qui compte, c’est l’écart entre les passes voisines et la stabilité du classement quand vous relancez l’optimisation.

Tester votre critère avant de l’utiliser

Un critère personnalisé est du code, donc il peut contenir des erreurs. Avant de lancer une longue optimisation :

  1. Lancez un test simple et comparez la valeur « OnTester result » du rapport avec un calcul manuel à partir des statistiques affichées.
  2. Lancez une optimisation complète sur deux paramètres avec des plages réduites et observez le graphique 2D : un critère sain dessine des zones, pas un damier aléatoire.
  3. Vérifiez qu’une passe manifestement mauvaise (perdante, peu de trades) obtient bien un score bas.

Rappelez-vous aussi que Print() n’est pas exécutée pendant l’optimisation, sauf dans OnInit() : déboguez votre critère en test simple. Les outils de débogage sont présentés dans Test visuel et débogage.

Pièges fréquents

  • Renvoyer des valeurs négatives énormes ou des infinis. Gardez le score dans une plage raisonnable et traitez explicitement les cas limites (DBL_MAX du profit factor, divisions par zéro).
  • Construire un critère qui récompense le hasard. Plus un critère est complexe, plus il a de façons d’être satisfait par une combinaison fortuite. Restez sur quelques composantes justifiées.
  • Ajuster le critère jusqu’à ce que la stratégie paraisse bonne. Modifier la notation après avoir vu les résultats est une forme de sur-optimisation, sujet traité dans notre page sur la sur-optimisation.
Un critère personnalisé améliore la sélection des paramètres, il ne crée pas d’avantage statistique. Les résultats optimisés restent des résultats passés ; validez-les hors échantillon et en démo avant toute exposition réelle.

FAQ

Comment utiliser OnTester comme critère d’optimisation ?

Déclarez double OnTester() dans votre EA, renvoyez votre score, puis choisissez « Custom max » comme critère dans les réglages d’optimisation du Strategy Tester.

Quand OnTester est-elle appelée ?

À la fin de chaque passe de test d’un Expert Advisor, juste avant OnDeinit, y compris lorsque la passe a été arrêtée par TesterStop.

Peut-on utiliser TesterStatistics dans OnTick ?

Non : son résultat n’est défini que dans OnTester ou OnDeinit pendant un test. Pour suivre une grandeur en cours de test, calculez-la vous-même dans OnTick.

Le score OnTester apparaît-il dans le rapport ?

Oui, sous la ligne « OnTester result », et dans la colonne Result des résultats d’optimisation lorsque le critère Custom max est sélectionné.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.