MQL5 Cookbook : Réduction de l'effet du surajustement et traitement de l'absence de cotations
Anatoli Kazharski | 13 janvier, 2022
Introduction
Je pense que de nombreux traders se sont interrogés à plusieurs reprises sur les paramètres optimaux pour leurs systèmes de trading. En effet, un algorithme de trading seul ne suffit pas. Il faut voir comment il peut encore être utilisé. Quelle que soit la stratégie de trading que vous utilisez, qu'elle soit simple ou complexe, avec un ou plusieurs instruments, vous ne pouvez pas éviter la question des paramètres à choisir pour assurer des profits futurs.
Nous avons tendance à vérifier les systèmes de trading avec des paramètres qui ont montré de bons résultats sur la période d'optimisation (backtesting) et sur la période suivante (forward testing ou tests avancés). Les tests avancés ne sont en fait pas si nécessaires. Les résultats pertinents peuvent être obtenus en utilisant des données historiques.
Cette méthode soulève une énorme question à laquelle on ne peut pas répondre avec certitude : quelle quantité de données historiques faut-il utiliser pour optimiser un système de trading ? Le truc, c'est qu'il y a beaucoup d'options. Tout dépend de la gamme de fluctuations de prix sur laquelle vous vous attendez à capitaliser.
Pour en revenir à la quantité d'historique requise pour l'optimisation, nous concluons que les données disponibles pourraient bien être suffisantes pour le trading intra-horaire. Ce n'est pas toujours vrai pour les périodes plus longues. Plus le nombre de répétitions d'un modèle cohérent est élevé, c'est-à-dire plus nous avons des trades, plus les performances du système de trading testé sont véridiques que nous pouvons nous attendre à voir à l'avenir.
Que se passe-t-il si les données de prix d'un certain instrument ne suffisent pas pour obtenir un nombre suffisant de répétitions et se sentir plus sûr ? Réponse : utilisez les données de tous les instruments disponibles.
Exemple dans NeuroShell DayTrader Professional
Avant de passer à la programmation dans MetaTrader 5, examinons un exemple dans NeuroShell DayTrader Professional. Il offre d'excellentes fonctionnalités pour optimiser les paramètres d'un système de trading (compilé avec un constructeur) pour plusieurs symboles. Vous pouvez définir les paramètres requis dans les paramètres du module de trading, optimiser les paramètres pour chaque symbole séparément ou trouver un ensemble de paramètres optimal pour tous les symboles à la fois. Cette option se trouve dans l'onglet Optimisation :
Fig. 1. L'onglet Optimisation dans le module de trading de NeuroShell DayTrader Professional
Dans notre cas, n'importe quel système de trading simple fera l'affaire car nous n'avons qu'à comparer les résultats de deux méthodes d'optimisation, donc le choix du système est actuellement de peu d'importance.
Vous pouvez trouver l'information sur la façon de compiler les stratégies de trading dans NeuroShell DayTrader Professional dans d'autres articles de mon blog (vous pouvez chercher ou utiliser les tags pour trouver l'information pertinente). Je vous recommande également de lire un article intitulé "Comment préparer des cotations MetaTrader 5 pour d'autres applications" qui décrit et montre comment, à l'aide d'un script, vous pouvez télécharger des cotations de MetaTrader 5 dans le format compatible avec NeuroShell DayTrader Professional.
Pour faire ce test, j'ai préparé des données obtenues à partir de barres quotidiennes pour huit symboles de l'année 2000 à janvier 2013 :
Fig. 2. Liste des symboles pour un test dans NeuroShell DayTrader Professional
La figure ci-dessous montre deux résultats d'optimisation. La partie supérieure affiche le résultat de l'optimisation où chaque symbole obtient ses propres paramètres, tandis que la partie inférieure affiche le résultat où les paramètres sont communs à tous les symboles.
Fig. 3. Comparaison des résultats de deux modes d'optimisation des paramètres
Le résultat montrant les paramètres communs n'est pas aussi bon que celui où les paramètres sont différents pour chaque symbole. Pourtant, cela inspire plus de confiance car le système de trading passe par un certain nombre de modèles de comportement de prix différents (volatilité, nombre de tendances/plats) avec les mêmes paramètres pour tous les symboles.
En continuant sur le même sujet, nous pouvons logiquement trouver un autre argument en faveur de l'optimisation utilisant une plus grande quantité de données. Il se peut très bien que le comportement des prix d'une certaine paire de devises, par exemple EURUSD, soit assez différent par la suite (dans deux, cinq ou dix ans). Par exemple, les tendances des prix GBPUSD seront similaires au comportement des prix passés de l'EURUSD et vice versa. Vous devriez être prêt pour cela car cela est vrai pour n'importe quel instrument.
Un exemple dans MetaTrader 5
Voyons maintenant quels modes d'optimisation des paramètres sont proposés dans MetaTrader 5. Ci-dessous, vous pouvez voir tous les symboles sélectionnés dans le mode d'optimisation Market Watch marqués d'une flèche dans la liste déroulante des modes d'optimisation.
Fig. 4. Modes d'optimisation dans le testeur de stratégie MetaTrader 5
Ce mode vous permet de tester uniquement un EA avec les paramètres actuels sur chaque symbole un par un. Les symboles utilisés dans les tests sont ceux qui sont actuellement sélectionnés dans la fenêtre Market Watch. En d'autres termes, l'optimisation des paramètres n'est dans ce cas pas effectuée. Cependant, MetaTrader 5 et MQL5 vous permettent de mettre en œuvre cette idée par vous-même.
Maintenant, nous devons voir comment mettre en œuvre une telle évaluation environnementale. La liste des symboles sera fournie dans un fichier texte (*.txt). De plus, nous mettrons en œuvre la possibilité de stocker plusieurs ensembles de listes de symboles. Chaque ensemble sera dans une section séparée avec son propre en-tête comportant un numéro de section. Les chiffres sont nécessaires pour faciliter la vérification visuelle.
Notez qu'il est important d'avoir # devant le nombre afin de permettre à l'Expert Advisor d'obtenir le bon jeu de données lors du remplissage du tableau de symboles. Généralement, l'en-tête peut contenir n'importe quel symbole, mais il doit toujours avoir #. Le signe dièse peut être remplacé par tout autre symbole selon lequel l'Expert Advisor déterminera/comptera les sections. Dans ce cas, le remplacement devra être reflété dans le code.
Ci-dessous, vous pouvez voir le fichier SymbolsList.txt qui contient trois jeux de symboles à tester. Ce fichier, tel qu'illustré, sera ensuite utilisé lors du test de la méthode.
Fig. 5. Plusieurs jeux de symboles fournis dans un fichier texte pour les tests
Dans les paramètres externes, nous ajouterons un autre paramètre, SectionOfSymbolList, pour indiquer l'ensemble de symboles que l'Expert Advisor doit utiliser dans le test en cours. Ce paramètre prend la valeur (de zéro vers le haut) qui définit le jeu de symboles. Si la valeur dépasse le nombre d'ensembles disponibles, l'Expert Advisor écrira une entrée correspondante dans le journal et le test ne sera effectué que sur le symbole actuel.
SymbolsList.txt doit être situé dans le répertoire du terminal local sous Metatrader 5\MQL5\Files. Il peut également être placé dans le dossier commun mais dans ce cas, il ne sera pas disponible pour l'optimisation des paramètres dans le MQL5 Cloud Network. De plus, pour permettre l'accès au fichier et aux indicateurs personnalisés pertinents pour les tests, nous devons écrire les lignes suivantes au début du fichier :
//--- Allow access to the external file and indicator for optimization in the cloud #property tester_file "SymbolsList.txt" #property tester_indicator "EventsSpy.ex5"
Notre Expert Advisor sera basé sur l'Expert Advisor multi-devises prêt à l'emploi présenté dans l'article "MQL5 Cookbook : Développement d'un Expert Advisor multi-devises avec un nombre illimité de paramètres". Sa stratégie de trading sous-jacente est assez simple mais il suffira de tester l'efficacité de la méthode. Nous allons simplement supprimer les parties inutiles, ajouter ce dont nous avons besoin et corriger le code pertinent existant. Nous allons certainement améliorer notre Expert Advisor avec la fonction d'enregistrement de rapport largement décrite dans l'article précédent de la série "MQL5 Cookbook : Écriture de l'historique des transactions dans un fichier et création de graphiques d'équilibre pour chaque symbole dans Excel". Des tableaux d'équilibre pour tous les symboles seront également nécessaires pour évaluer l'efficacité de la méthode considérée.
Les paramètres externes de l'Expert Advisor doivent être modifiés comme suit :
//--- External parameters of the Expert Advisor sinput int SectionOfSymbolList = 1; // Section number in the symbol lists sinput bool UpdateReport = false; // Report update sinput string delimeter_00=""; // -------------------------------- sinput long MagicNumber = 777; // Magic number sinput int Deviation = 10; // Slippage sinput string delimeter_01=""; // -------------------------------- input int IndicatorPeriod = 5; // Indicator period input double TakeProfit = 100; // Take Profit input double StopLoss = 50; // Stop Loss input double TrailingStop = 10; // Trailing Stop input bool Reverse = true; // Position reversal input double Lot = 0.1; // Lot input double VolumeIncrease = 0.1; // Position volume increase input double VolumeIncreaseStep = 10; // Volume increase step
Tous les tableaux associés aux paramètres externes doivent être supprimés car ils ne seront pas nécessaires et doivent en outre être remplacés par les variables externes dans tout le code. Nous ne devons laisser que le tableau dynamique de symboles, InputSymbols[], dont la taille dépendra du nombre de symboles utilisés dans l'un des ensembles du fichier SymbolsList.txt. Si l'Expert Advisor est utilisé en dehors du Strategy Tester, la taille de ce tableau sera égale à 1 car en mode temps réel, l'Expert Advisor fonctionnera avec un seul symbole.
Les modifications correspondantes doivent également être effectuées dans le fichier d'initialisation du tableau - InitializeArrays.mqh. C'est-à-dire que toutes les fonctions responsables de l'initialisation des tableaux de variables externes doivent être supprimées. La fonction InitializeArraySymbols() ressemble maintenant à ce qui suit :
//+------------------------------------------------------------------+ //| Filling the array of symbols | //+------------------------------------------------------------------+ void InitializeArraySymbols() { int strings_count =0; // Number of strings in the symbol file string checked_symbol =""; // To check the accessibility of the symbol on the trade server //--- Test mode message string message_01="<--- All symbol names in the <- SymbolsList.txt -> file are incorrect ... --->\n" "<--- ... or the value of the \"Section of List Symbols\" parameter is greater, " "than the number of file sections! --->\n" "<--- Therefore we will test only the current symbol. --->"; //--- Real-time mode message string message_02="<--- In real-time mode, we only work with the current symbol. --->"; //--- If in real-time mode if(!IsRealtime()) { //--- Get the number of strings from the specified symbol set in the file and fill the temporary array of symbols strings_count=ReadSymbolsFromFile("SymbolsList.txt"); //--- Iterate over all symbols from the specified set for(int s=0; s<strings_count; s++) { //--- If the correct string is returned following the symbol check if((checked_symbol=GetSymbolByName(temporary_symbols[s]))!="") { //--- increase the counter SYMBOLS_COUNT++; //--- set/increase the array size ArrayResize(InputSymbols,SYMBOLS_COUNT); //--- index with the symbol name InputSymbols[SYMBOLS_COUNT-1]=checked_symbol; } } } //--- If all symbol names were not input correctly or if currently working in real-time mode if(SYMBOLS_COUNT==0) { //--- Real-time mode message if(IsRealtime()) Print(message_02); //--- Test mode message if(!IsRealtime()) Print(message_01); //--- We will work with the current symbol only SYMBOLS_COUNT=1; //--- set the array size and ArrayResize(InputSymbols,SYMBOLS_COUNT); //--- index with the current symbol name InputSymbols[0]=_Symbol; } }
Le code de la fonction ReadSymbolsFromFile() doit également être modifié. Auparavant, il lisait toute la liste des symboles alors que maintenant nous voulons qu'il ne lise que le jeu de symboles spécifié. Ci-dessous le code de fonction modifié :
//+------------------------------------------------------------------+ //| Returning the number of strings (symbols) from the specified | //| set in the file and filling the temporary array of symbols | //+------------------------------------------------------------------+ //--- When preparing the file, symbols in the list should be separated with a line break int ReadSymbolsFromFile(string file_name) { ulong offset =0; // Offset for determining the position of the file pointer string delimeter ="#"; // Identifier of the section start string read_line =""; // For the check of the read string int limit_count =0; // Counter limiting the number of the possibly open charts int strings_count =0; // String counter int sections_count =-1; // Section counter //--- Message 01 string message_01="<--- The <- "+file_name+" -> file has not been prepared appropriately! --->\n" "<--- The first string does not contain the section number identifier ("+delimeter+")! --->"; //--- Message 02 string message_02="<--- The <- "+file_name+" -> file has not been prepared appropriately! --->\n" "<--- There is no line break identifier in the last string, --->\n" "<--- so only the current symbol will be involved in testing. --->"; //--- Message 03 string message_03="<--- The <- "+file_name+" -> file could not be found! --->" "<--- Only the current symbol will be involved in testing. --->"; //--- Open the file (get the handle) for reading in the local directory of the terminal int file_handle=FileOpen(file_name,FILE_READ|FILE_ANSI,'\n'); //--- If the file handle has been obtained if(file_handle!=INVALID_HANDLE) { //--- Read until the current position of the file pointer // reaches the end of the file or until the program is deleted while(!FileIsEnding(file_handle) || !IsStopped()) { //--- Read until the end of the string or until the program is deleted while(!FileIsLineEnding(file_handle) || !IsStopped()) { //--- Read the whole string read_line=FileReadString(file_handle); //--- If the section number identifier has been found if(StringFind(read_line,delimeter,0)>-1) //--- Increase the section counter sections_count++; //--- If the section has been read, exit the function if(sections_count>SectionOfSymbolList) { FileClose(file_handle); // Close the file return(strings_count); // Return the number of strings in the file } //--- If this is the first iteration and the first string does not contain the section number identifier if(limit_count==0 && sections_count==-1) { PrepareArrayForOneSymbol(strings_count,message_01); //--- Close the file FileClose(file_handle); //--- Return the number of strings in the file return(strings_count); } //--- Increase the counter limiting the number of the possibly open charts limit_count++; //--- If the limit has been reached if(limit_count>=CHARTS_MAX) { PrepareArrayForOneSymbol(strings_count,message_02); //--- Close the file FileClose(file_handle); //--- Return the number of strings in the file return(strings_count); } //--- Get the position of the pointer offset=FileTell(file_handle); //--- If this is the end of the string if(FileIsLineEnding(file_handle)) { //--- Go to the next string if this is not the end of the file // For this purpose, increase the offset of the file pointer if(!FileIsEnding(file_handle)) offset++; //--- move it to the next string FileSeek(file_handle,offset,SEEK_SET); //--- If we are not in the specified section of the file, exit the loop if(sections_count!=SectionOfSymbolList) break; //--- Otherwise, else { //--- if the string is not empty if(read_line!="") { //--- increase the string counter strings_count++; //--- increase the size of the array of strings, ArrayResize(temporary_symbols,strings_count); //--- write the string to the current index temporary_symbols[strings_count-1]=read_line; } } //--- Exit the loop break; } } //--- If this is the end of the file, terminate the entire loop if(FileIsEnding(file_handle)) break; } //--- Close the file FileClose(file_handle); } else PrepareArrayForOneSymbol(strings_count,message_03); //--- Return the number of strings in the file return(strings_count); }
Vous pouvez voir que certaines chaînes du code ci-dessus sont mises en évidence. Ces chaînes contiennent la fonction PrepareArrayForOneSymbol() qui prépare simplement un tableau pour un symbole (actuel) en cas d'erreur.
//+------------------------------------------------------------------+ //| Preparing an array for one symbol | //+------------------------------------------------------------------+ void PrepareArrayForOneSymbol(int &strings_count,string message) { //--- Print the message to the log Print(message); //--- Array size strings_count=1; //--- Set the size of the array of symbols ArrayResize(temporary_symbols,strings_count); //--- Write the string with the current symbol name to the current index temporary_symbols[0]=_Symbol; }
Tout est maintenant prêt pour tester la méthode d'optimisation des paramètres. Mais avant de procéder aux tests, ajoutons une autre série de données au rapport. Auparavant, en plus des soldes de tous les symboles, le fichier de rapport contenait tous les retraits des maxima locaux exprimés en pourcentage. Désormais, le rapport couvrira également tous les retraits en termes monétaires. Dans le même temps, nous allons modifier la fonction CreateSymbolBalanceReport() où le rapport est généré.
Le code de la fonction CreateSymbolBalanceReport() est fourni ci-dessous :
//+------------------------------------------------------------------+ //| Creating test report on deals in .csv format | //+------------------------------------------------------------------+ void CreateSymbolBalanceReport() { int file_handle =INVALID_HANDLE; // File handle string path =""; // File path //--- If an error occurred when creating/getting the folder, exit if((path=CreateInputParametersFolder())=="") return; //--- Create a file to write data in the common folder of the terminal file_handle=FileOpen(path+"\\LastTest.csv",FILE_CSV|FILE_WRITE|FILE_ANSI|FILE_COMMON); //--- If the handle is valid (file created/opened) if(file_handle>0) { int digits =0; // Number of decimal places in the price int deals_total =0; // Number of deals in the specified history ulong ticket =0; // Deal ticket double drawdown_max =0.0; // Drawdown double balance =0.0; // Balance string delimeter =","; // Delimiter string string_to_write =""; // To generate the string for writing static double percent_drawdown =0.0; // Drawdown expressed as percentage static double money_drawdown =0.0; // Drawdown in monetary terms //--- Generate the header string string headers="TIME,SYMBOL,DEAL TYPE,ENTRY TYPE,VOLUME," "PRICE,SWAP($),PROFIT($),DRAWDOWN(%),DRAWDOWN($),BALANCE"; //--- If more than one symbol is involved, modify the header string if(SYMBOLS_COUNT>1) { for(int s=0; s<SYMBOLS_COUNT; s++) StringAdd(headers,","+InputSymbols[s]); } //--- Write the report headers FileWrite(file_handle,headers); //--- Get the complete history HistorySelect(0,TimeCurrent()); //--- Get the number of deals deals_total=HistoryDealsTotal(); //--- Resize the array of balances according to the number of symbols ArrayResize(symbol_balance,SYMBOLS_COUNT); //--- Resize the array of deals for each symbol for(int s=0; s<SYMBOLS_COUNT; s++) ArrayResize(symbol_balance[s].balance,deals_total); //--- Iterate in a loop and write the data for(int i=0; i<deals_total; i++) { //--- Get the deal ticket ticket=HistoryDealGetTicket(i); //--- Get all the deal properties GetHistoryDealProperties(ticket,D_ALL); //--- Get the number of digits in the price digits=(int)SymbolInfoInteger(deal.symbol,SYMBOL_DIGITS); //--- Calculate the overall balance balance+=deal.profit+deal.swap+deal.commission; //--- Calculate the max drawdown from the local maximum TesterDrawdownMaximum(i,balance,percent_drawdown,money_drawdown); //--- Generate a string for writing using concatenation StringConcatenate(string_to_write, deal.time,delimeter, DealSymbolToString(deal.symbol),delimeter, DealTypeToString(deal.type),delimeter, DealEntryToString(deal.entry),delimeter, DealVolumeToString(deal.volume),delimeter, DealPriceToString(deal.price,digits),delimeter, DealSwapToString(deal.swap),delimeter, DealProfitToString(deal.symbol,deal.profit),delimeter, DrawdownToString(percent_drawdown),delimeter, DrawdownToString(money_drawdown),delimeter, DoubleToString(balance,2)); //--- If more than one symbol is involved, write their balance values if(SYMBOLS_COUNT>1) { //--- Iterate over all symbols for(int s=0; s<SYMBOLS_COUNT; s++) { //--- If the symbols are equal and the deal result is non-zero if(deal.symbol==InputSymbols[s] && deal.profit!=0) { //--- Display the deal in the balance for the corresponding symbol // Take into consideration swap and commission symbol_balance[s].balance[i]=symbol_balance[s].balance[i-1]+ deal.profit+ deal.swap+ deal.commission; //--- Add to the string StringAdd(string_to_write,","+DoubleToString(symbol_balance[s].balance[i],2)); } //--- Otherwise write the previous value else { //--- If the deal type is "Balance" (the first deal) if(deal.type==DEAL_TYPE_BALANCE) { //--- the balance is the same for all symbols symbol_balance[s].balance[i]=balance; StringAdd(string_to_write,","+DoubleToString(symbol_balance[s].balance[i],2)); } //--- Otherwise write the previous value to the current index else { symbol_balance[s].balance[i]=symbol_balance[s].balance[i-1]; StringAdd(string_to_write,","+DoubleToString(symbol_balance[s].balance[i],2)); } } } } //--- Write the generated string FileWrite(file_handle,string_to_write); //--- Mandatory zeroing out of the variable for the next string string_to_write=""; } //--- Close the file FileClose(file_handle); } //--- If the file could not be created/opened, print the appropriate message else Print("Error creating the file! Error: "+IntegerToString(GetLastError())+""); }
Nous avions l'habitude de calculer les retraits dans la fonction DrawdownMaximumToString(). Ceci est maintenant effectué par la fonction TesterDrawdownMaximum(), tandis que la valeur de retrait est convertie en une chaîne de caractères à l'aide de la fonction de base DrawdownToString().
Le code de la fonction TesterDrawdownMaximum() est le suivant :
//+------------------------------------------------------------------+ //| Returning the max drawdown from the local maximum | //+------------------------------------------------------------------+ void TesterDrawdownMaximum(int deal_number, double balance, double &percent_drawdown, double &money_drawdown) { ulong ticket =0; // Deal ticket string str =""; // The string to be displayed in the report //--- To calculate the local maximum and drawdown static double max =0.0; static double min =0.0; //--- If this is the first deal if(deal_number==0) { //--- There is no drawdown yet percent_drawdown =0.0; money_drawdown =0.0; //--- Set the initial point as the local maximum max=balance; min=balance; } else { //--- If the current balance is greater than in the memory, then... if(balance>max) { //--- Calculate the drawdown using the previous values: // in monetary terms money_drawdown=max-min; // expressed as percentage percent_drawdown=100-((min/max)*100); //--- Update the local maximum max=balance; min=balance; } //--- Otherwise else { //--- Return zero value of the drawdown money_drawdown=0.0; percent_drawdown=0.0; //--- Update the minimum min=fmin(min,balance); //--- If the deal ticket by its position in the list has been obtained, then... if((ticket=HistoryDealGetTicket(deal_number))>0) { //--- ...get the deal comment GetHistoryDealProperties(ticket,D_COMMENT); //--- Flag of the last deal static bool last_deal=false; //--- The last deal in the test can be identified by the "end of test" comment if(deal.comment=="end of test" && !last_deal) { //--- Set the flag last_deal=true; //--- Update the drawdown values: // in monetary terms money_drawdown=max-min; // expressed as percentage percent_drawdown+=100-((min/max)*100); } } } } }
Le code de la fonction DrawdownToString() est fourni ci-dessous :
//+------------------------------------------------------------------+ //| Converting drawdown to a string | //+------------------------------------------------------------------+ string DrawdownToString(double drawdown) { return((drawdown<=0) ? "" : DoubleToString(drawdown,2)); }
Maintenant, tout est prêt pour le test de l'Expert Advisor et l'analyse des résultats. Au début de l'article, nous avons vu un exemple de fichier prêt à l'emploi. Procédons comme suit : optimisons les paramètres des symboles du deuxième ensemble (il y a trois symboles : EURUSD, AUDUSD et USDCHF) et après l'optimisation, exécutez le test en utilisant tous les symboles du troisième ensemble (sept symboles au total) pour voir les résultats des symboles dont les données n'étaient pas impliquées dans l'optimisation des paramètres.
Optimisation des paramètres et test Expert Advisor
Le testeur de stratégie doit être configuré comme indiqué ci-dessous :
Fig. 6. Les paramètres de testeur de stratégie pour l'optimisation
Les paramètres de l'Expert Advisor pour l'optimisation des paramètres sont fournis ci-dessous :
Fig. 7. Les paramètres de l'Expert Advisor pour l'optimisation des paramètres
Étant donné que l'optimisation implique trois symboles et que l'augmentation du volume de la position est activée pour chacun d'eux, nous définissons le lot minimum aux fins d'ouvrir une position et d'augmenter le volume de la position. Dans notre cas, la valeur est de 0,01.
Après l'optimisation, nous sélectionnons le meilleur résultat par le facteur de récupération maximal et définissons le paramètre VolumeIncrease à 0,1 pour le lot. Le résultat est présenté ci-dessous :
Fig. 8. Le résultat du test dans MetaTrader 5
Ci-dessous, vous pouvez voir le résultat tel qu'il apparaît dans Excel 2010 :
Fig. 9. Le résultat du test pour trois symboles comme indiqué dans Excel 2010
Le tirage en termes monétaires est affiché sous forme de marques vertes dans le graphique inférieur en termes de deuxième échelle (auxiliaire).
Vous devez également connaître les limites des graphiques dans Excel 2010 (la liste complète des spécifications et des limites est disponible sur page des spécifications et limites Excel du site Web de Microsoft Office).
Fig. 10. Spécifications et limites des graphiques dans Excel 2010
Le tableau montre que nous pouvons exécuter le test pour 255 symboles en même temps et afficher tous les résultats dans le graphique ! Nous ne sommes limités que par les ressources informatiques.
Exécutons maintenant le test pour sept symboles du troisième ensemble avec les paramètres actuels et vérifions le résultat :
Fig. 11. Le résultat du test pour sept symboles comme indiqué dans Excel 2010
Avec sept symboles à l'étude, nous avons 6901 transactions. Les données du graphique sont mises à jour assez rapidement dans Excel 2010.
Conclusion
Je pense que la méthode introduite est remarquable car même une stratégie de trading simple comme celle que nous avons utilisée a donné de bons résultats. Ici, il faut garder à l'esprit que l'optimisation n'a été effectuée que pour trois symboles sur sept. Nous pouvons essayer d'améliorer le résultat en optimisant les paramètres pour tous les symboles à la fois. Cependant, nous devrions avant tout viser à améliorer le système commercial, ou mieux encore, à avoir un portefeuille de différents systèmes de trading. Nous reviendrons sur cette idée plus tard.
C'est à peu près ça. Nous avons un outil assez utile pour étudier les résultats des stratégies de trading multi-devises. Vous trouverez ci-dessous le fichier zip téléchargeable avec les fichiers de l'Expert Advisor pour votre considération.
Après avoir extrait les fichiers, placez le dossier ReduceOverfittingEA dans le répertoire MetaTrader 5\MQL5\Experts. De plus, l'indicateur EventsSpy.mq5 doit être placé dans MetaTrader 5\MQL5\Indicators. SymbolsList.txt doit être situé sous MetaTrader 5\MQL5\Files.