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.
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 avantOnDeinit();- 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 dansOnTester()ouOnDeinit()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()etOnDeinit()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 :
- Exiger un échantillon suffisant : en dessous d’un nombre minimal de trades, la passe ne vaut rien, quel que soit son profit.
- Pénaliser le risque : rapporter le gain au drawdown, de préférence d’equity.
- Récompenser la régularité : une courbe qui monte régulièrement est préférable à une courbe portée par deux trades exceptionnels.
- 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.
- Ê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_DDplutô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_LONGTRADESetSTAT_PROFIT_SHORTTRADES(nombres de trades gagnants dans chaque sens) aux totauxSTAT_LONG_TRADESetSTAT_SHORT_TRADESpour écarter les réglages qui ne gagnent que d’un côté. - Exploiter l’historique des transactions : dans
OnTester(),HistorySelect()puisHistoryDealGetDouble()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 :
- Lancez un test simple et comparez la valeur « OnTester result » du rapport avec un calcul manuel à partir des statistiques affichées.
- 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.
- 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_MAXdu 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.
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é.
- Premiers pas dans le Strategy Tester
- Modes de modélisation des ticks
- Tester en ticks réels
- Simuler les délais d’exécution
- Lire le rapport de backtest
- Optimisation génétique
- Critères d’optimisation
- Forward testing
- Walk-forward sur MetaTrader 5
- Frames : exporter les résultats d’optimisation
- Test visuel et débogage
- Agents locaux et MQL5 Cloud Network
- Symboles personnalisés pour backtester
