Création d’EA de réseau de neurones en utilisant MQL5 Wizard et Hlaiman EA Generator
343
0
Introduction
Pratiquement tous les traders connaissent l’existence de réseaux de neurones. Mais pour la majorité d’entre eux, cela reste une boîte noire, les seules choses connues étant la capacité des réseaux de neurones à reconnaître des modèles, à produire une recherche associative de solutions et à apprendre, ainsi que le fait qu’ils peuvent être efficaces pour prédire le comportement du marché et dans le trading automatisé. De nombreuses sources d’information qui se concentrent sur l’application des réseaux de neurones parlent souvent de leur difficulté, soulignant qu’il faut consacrer beaucoup de temps et d’efforts pour bien apprendre ce sujet et être capable d’utiliser les réseaux de neurones à l’avenir.
Cet article vise à réfuter ces arguments et à prouver que les méthodes d’automatisation avancées permettent aux traders de commencer facilement avec les réseaux de neurones et d’éviter le long processus d’apprentissage. Il n’y a rien de difficile à obtenir votre propre expérience avec les réseaux de neurones. C’est certainement plus facile que l’analyse technique.
Dans cette perspective, nous décrirons une méthode de génération automatique d’EA de réseau de neurones pour MetaTrader 5 en utilisant le MQL5 Wizard et Hlaiman EA Generator.
Le choix des outils pour résoudre la tâche à accomplir est loin d’être aléatoire :
- MQL5 Wizard est un mécanisme efficace et le plus rapide de génération automatique de code MQL5 à ce jour qui vous permet de mettre à l’échelle le code généré à l’aide de modules supplémentaires.
- Hlaiman EA Generator est un moteur de réseau de neurones avec un mécanisme flexible d’intégration d’objets, programmable directement dans le code MQL5 d’un Expert Advisor.
L’abréviation 'EA a été ajoutée intentionnellement au nom de l’Expert Advisor, car les propriétés humaines associées à la reconnaissance et à l’apprentissage sont prédominantes dans un réseau de neurones EA, contrairement à d’autres cas où l’utilisation de 'EA dans un nom est souvent trompeuse et ne reflète pas la vraie nature des choses.
Description générale
Pour la raison exposée dans l’objectif de l’article, vous ne trouverez pas ici d’informations théoriques, de classifications et de structure de réseaux de neurones ou de données de recherche liées aux marchés financiers. Cette information est disponible dans d’autres sources. Dans cet article, nous nous limiterons délibérément au concept d’un réseau de neurones comme une boîte noire capable de penser de manière associative et de prédire les entrées de marché sur la base de la reconnaissance de modèles de prix graphiques. Pour la même raison, nous utiliserons la notion la plus simple du motif étant une séquence continue de barres dans un graphique d’instrument de trading qui précède un mouvement de prix rentable.
Quelques mots sur les outils de résolution de problèmes. Contrairement à Hlaiman,, MQL5 Wizard a souvent fait l’objet de divers articles et documentations et n’a pas besoin d’introduction tout comme MetaTrader 5. Le projet Hlaiman à vocation sociale est destiné au développement et à la promotion de logiciels polyvalents sous forme de plug-ins, dont ’EAGenerator fait partie. Comme mentionné précédemment, fonctionnellement EA Generator représente un moteur de réseau de neurones avec le mécanisme d’intégration.
Hlaiman EA Generator inclut <hlaim.exe> - un shell qui représente une application Windows GUI avec une interface multi-documents et des plug-ins sous la forme de bibliothèques de composants chargeables dynamiquement. Le système fournit une large gamme de méthodes de réglage manuel et algorithmique et de contrôle des composants qui peuvent être à la fois standard et chargeables dans le cadre de plug-ins. Au cours de l’exploitation du système, vous pouvez créer des hiérarchies complexes d’objets et avoir un contrôle flexible sur leurs méthodes et propriétés, à l’aide de l’Inspecteur d’objets et d’outils logiciels d’automatisation, par exemple des scripts.
L’intégration de Hlaiman EA Generator avec MQL5 implique l’interpréteur de script Object Pascal, tandis que le code source est transmis via Named Pipes. Un perceptron multicouche (MLP) est utilisé comme composant principal du réseau de neurones.
Hlaiman EA Generator est intégré à l’assistant MQL5 Wizard à l’aide d’un module de bibliothèque de signal - SignalHNN.mqh. Une fois généré automatiquement, l’Expert Advisor peut ensuite apprendre à trader sur n’importe quel nombre d’instruments et de délais. Dans le terminal МetaТrader 5, les flèches indiquant les signaux peuvent être dessinées manuellement dans le tableau des prix à l’aide des objets graphiques pour les flèches ou automatiquement à l’aide du script TeachHNN.mq5 qui initie en même temps le processus d’enseignement de l’Expert Advisor.
Ceci conclut la description théorique. Nous passons maintenant à la partie pratique qui est divisée en deux sections - Principes de fonctionnement et Mise en œuvre.
La deuxième section s’adresse aux développeurs de logiciels et est fournie ici principalement par respect pour ce site Web. Il est donc facultatif, en particulier pour les traders qui ont peu ou pas d’intérêt à acquérir des compétences en programmation, mais qui sont intéressés par la création d’EAs de réseau de neurones et l’évaluation de leur efficacité ou de leur inutilité en termes de trading.
Principes de fonctionnement
Dans MQL5.community, il serait probablement inutile de mentionner que vous avez besoin du terminal MetaТrader 5 pour continuer. Si vous ne l’avez pas, vous pouvez le télécharger et l’installer. Vous devez également télécharger et installer une version de démo Hlaiman EA Generator.
Lancez le terminal МetaТrader 5 et démarrez MetaEditor. Ouvrez l’Assistant MQL5 Wizard. Vous pouvez le faire en utilisant l’option 'New' dans la barre d’outils Standard ou dans le menu Fichier, ainsi qu’en utilisant le raccourci clavier 'Ctrl+N'.
Dans la fenêtre de l’Assistant MQL5, sélectionnez 'Expert Advisor (generate)' et cliquez sur 'Next'.
Fig. 1. Création d’un Expert Advisor dans l’Assistant MQL5
Spécifiez l’emplacement et le nom de l’Expert Advisor, par exemple : 'Experts\SampleHNN' et cliquez sur 'Next'.
Fig. 2. Propriétés générales de l’Expert Advisor
Cliquez sur le bouton 'Add'. Vous verrez la fenêtre de 'Parameters of Signal Module' où vous devez sélectionner 'Signals of patterns Hlaiman Neural Network EA generator' dans la liste déroulante et cliquer sur 'OK'.
Fig. 3. Sélection du module de signal de trading du Hlaiman Neural Network EA generator
Dans le cas d’une implémentation très basique, vous pouvez cliquer sur 'Next' à toutes les étapes restantes de l’Assistant MQL5. Si nécessaire, l’Expert Advisor peut être amélioré en sélectionnant des options supplémentaires.
Une fois la génération de code terminée, cliquez sur 'Compile' et fermez la fenêtre MetaEditor. L’Expert Advisor généré apparaîtra dans le panneau Navigateur du terminal MetaTrader 5 sous 'Expert Advisors'.
Fig. 4. L’Expert Advisor de SampleHNN
Avant de procéder à l’enseignement de l’Expert Advisor généré, nous devons ouvrir un graphique avec le symbole et le délai requis dans le terminal. L’application Hlaiman EA Generator doit être opérationnelle.
Fig. 5. Préparation à l'enseignement des réseaux de neurones
Pour enseigner l’Expert Advisor, sélectionnez 'TeachHNN' sous 'Scripts' dans le panneau Navigateur du terminal et activez-le pour le graphique spécifié.
Avant d’exécuter le script 'TeachHNN', vous devez vous assurer qu’il dispose de tous les paramètres appropriés. Il possède les paramètres suivants :
- Nom du document - nom de l’Expert Advisor pour l’enseignement ;
- Couches de neurones - nombre de couches de réseau de neurones ;
- Neurones moyens - nombre de neurones ;
- Époques d’enseignement - nombre d’époques d’enseignement ;
- Barres de modèle - nombre de barres dans un modèle ;
- Enseigner un réseau ? - lancer le processus d'apprentissage du réseau de neurones (ou simplement la génération du signal) ;
- SignalsCreate - pour créer automatiquement des images graphiques de signaux ;
- SignalsBarPoints - seuil de génération de signal exprimé en points ;
- SignalsBarsCount - nombre de barres pour le calcul des points ;
- SignalsStartTime, SignalsEndTime - heure de début et de fin de la période de génération du signal ;
- SignalsClear - pour supprimer automatiquement les images de signaux à la fin de l’enseignement.
Fig. 6. Paramètres de script TeachHNN
Si tout est prêt, cliquez sur 'OK' pour lancer le processus d’enseignement de l’Expert Advisor. Cela lancera la génération automatique de modèles graphiques pour chacun des signaux disponibles dans le graphique.
Les informations pertinentes sont affichées dans l’onglet 'Experts' du panneau 'Toolbox' du terminal, tandis que les objets correspondants apparaissent dans la fenêtre Hlaiman EA Generator.
Une fois la génération du modèle terminée, le processus d’enseignement commence. Il est affiché dans la barre de progression de l’enseignement qui apparaît à l’écran.
Fig. 7. Panneau de progression de l’enseignement
Veuillez patienter jusqu'à ce que le processus soit terminé. Le processus d’enseignement peut être terminé avant d’être terminé en cliquant avec le bouton droit de la souris sur la barre de progression de l’enseignement et en sélectionnant l’option appropriée dans le menu contextuel.
Une fois le processus d’enseignement et l’opération de script terminés, le message correspondant sera ajouté au journal dans l’onglet 'Experts' , par exemple. 'Le réseau de neurones crée le succès ! Sur 431 modèles' indique que l’enseignement de l’Expert Advisor a été complété avec succès en utilisant 431 signaux.
Ces messages montrent combien de modèles ont été impliqués dans le processus d’enseignement et découvrent le nombre de ces modèles. Les BUY et SELL, en particulier, sont déterminés à l’aide des messages du type suivant : 'Vendre le signal détecté au modèle #211'.
Fig. 8. Les messages de script TeachHNN au cours de l’enseignement
Les raisons pour lesquelles le processus d’enseignement de l’Expert Advisor peut commencer par une erreur sont les suivantes:
- L’application Hlaiman n’était pas opérationnelle avant le démarrage, comme requis. Dans ce cas, le message d’erreur sera le suivant "CSignalHNN::InitHNN : Erreur! initialisation du serveur de canalisations (raison possible : L’APPLICATION HLAIMAN N’EST PAS EN COURS D’EXÉCUTION !)".
- L’absence de flèches indiquant les signaux dans le graphique lors de la désactivation de la génération automatique de signaux (la variable SignalsCreate = false). Dans ce cas, le message d’erreur à afficher est le suivant : "OnStart : erreur, flèche d’ordre introuvable!" Si la génération automatique de signaux est activée (la variable SignalsCreate = true), une erreur peut être causée par la présence d’autres objets graphiques dans le graphique, car les marquages personnalisés ne sont pas censés être gâchés dans le programme. Il est donc recommandé d’ouvrir tous les graphiques séparément aux fins de la génération automatique de signaux.
Une fois l’enseignement de l’Expert Advisor terminé, vous pouvez afficher les résultats pertinents en passant à l’interface graphique Hlaiman et en sélectionnant les objets et les panneaux de visualisation appropriés.
Fig. 9. L’onglet 'Text' de l’application Hlaiman
Fig. 10. L’onglet 'Graph' de l’application Hlaiman
Après avoir enseigné avec succès l’Expert Advisor sur au moins un instrument de trading, nous pouvons procéder à des tests et / ou à l’optimisation.
Pour ce faire, sélectionnez le nom de l’Expert Advisor formé, le symbole, la période, l’intervalle et d’autres paramètres de test dans le Strategy Tester. Définissez les variables externes, si nécessaire, et exécutez le test.
Fig. 11. Paramètres de l’Expert Advisor SampleHNN pour le backtesting
Fig. 12. Les variables externes de l’Expert Advisor SampleHNN peuvent être modifiées
Vous trouverez ci-dessous un exemple du rapport d’opération Expert Advisor dans le Strategy Tester. L’Expert Advisor a été enseigné en utilisant de signaux générés automatiquement, tous les paramètres externes du script d’enseignement étant définis par défaut. La période d’enseignement : 01.01.2010-01.07.2013, instrument : EURUSD H4.
Rapport du testeur de stratégie
| Expert Advisor : | SampleHNN |
|---|---|
| Symbole : | EURUSD |
| Période : | H4 (2010.01.01-2013.07.12) |
| devise : | USD |
| Dépôt initial : | 10 000.00 |
| Effet de levier : | 0,111111111 |
| Backtesting | |
| Qualité de l’histoire : | 100% |
| Barres : | 5497 |
| Bénéfice net : | 9 159.58 |
| Bénéfice brut : | 29 735.97 |
| Perte brute : | -20 576.39 |
| Facteur de profit : | 1.45 |
| Facteur de récupération : | 12.81 |
| AHPR : | 1.0005 (0.05%) |
| GHPR : | 1.0005 (0.05%) |
| Total des trades : | 1417 |
| Nombre total de transactions : | 2246 |
| Ticks : | 60211228 |
| Prélèvement du solde absolu : | 0.00 |
| Prélèvement du solde maximal : | 679.98 (3.81%) |
| Prélèvement du solde relatif : | 4.00% (715.08) |
| Gain attendu | 6.46 |
| Ratio de Sharpe | 0.16 |
| Corrélation LR : | 0.98 |
| Erreur standard LR : | 595.06 |
| Trades courts (% gagnés) : | 703 (56.61%) |
| Trades à profit (% du total) : | 793 (55.96%) |
| Le plus grand profit de trade : | 53.00 |
| Bénéfice moyen du trade | 37.50 |
| Gains consécutifs maximales | 9 (450.38) |
| Pertes consécutives maximales | 450.38 (9) |
| Moyenne de gains consécutifs : | 2 |
| Symboles : | 1 |
| Prélèvement absolu sur capitaux propres : | 6.60 |
| Prélèvement maximal sur capitaux propres : | 715.08 (4.00%) |
| Prélèvement relatif sur capitaux propres : | 4.00% (715.08) |
| Niveau de marge : | 6929.24% |
| Compte-Z : | -1.24 (78.50%) |
| Résultat OnTester : | 0 |
| Longs trades (% gagné) : | 714 (55.32%) |
| Trades de perte (% du total) : | 624 (44.04%) |
| Le plus grand trade à perte : | -53.30 |
| Moyenne de trade à perte : | -32.97 |
| Pertes consécutives maximales : | 9 (-234.00) |
| Perte consécutive maximale : | -276.67 (7) |
| Pertes consécutives moyennes : | 2 |
Fig. 13. Résultats du backtest sampleHNN Expert Advisor
Fig. 14. Les statistiques d’entrée sur le marché de SampleHNN Expert Advisor
Fig. 15. Corrélation entre le bénéfice et le MFE/MAE de l’Expert Advisor de SampleHNN
Fig. 16. Statistiques du temps de maintien de la position de l’Expert Advisor de SampleHNN
Implémentation
Le principal composant d’implémentation MQL5 est la classe CSignalHNN décrite dans le module de signal SignalHNN.mqh. La classe est héritée de la classe de base CExpertSignal et inclut tous les champs de données et méthodes nécessaires au fonctionnement et à l’intégration de Hlaiman, ainsi qu’à l’utilisation des Expert Advisors générés à l’aide de l’Assistant MQL5 Wizard.
Le modèle de classe est le suivant :
//+------------------------------------------------------------------+ //| Class CSignalHNN. | //| Purpose: Class of generator of trade signals based on | //| the 'Hlaiman EA Generator Neural Net' indicator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalHNN :public CExpertSignal { protected: //--- variables int m_hnn; // handle of HNN connect string hnn_path; // MT5 Terminal data path string hnn_fil; // HNN file w neural net string hnn_nam; // Expert name string hnn_sym; // Symbol name string hnn_per; // Period name ENUM_TIMEFRAMES hnn_period; // Period timeframe int hnn_index; // Index ext multinet int hnn_bar; // index of last bar int hnn_in; // input layer int hnn_out; // output layer int hnn_layers; // layers count int hnn_neurons; // neurons count int hnn_epoch; // learn epoch double hnn_signal; // value of last signal double pattern[]; // values of the pattern bool hnn_norm; // normalize pattern public: CSignalHNN(void); // class constructor ~CSignalHNN(void); // class destructor //--- methods of setting adjustable parameters void PatternBarsCount(int value) { hnn_in = value; ArrayResize(pattern, value + 1); } void LayersCount(int value) { hnn_layers = value; } void NeuronsCount(int value) { hnn_neurons = value; } void EpochCount(int value) { hnn_epoch = value; } void Normalize(bool value) { hnn_norm = value; } //--- method of verification of settings virtual bool ValidationSettings(void); //--- method of creating the indicator and timeseries virtual bool InitIndicators(CIndicators *indicators); //--- methods of checking conditions of entering the market virtual double Direction(void); bool FillPattern(datetime tim = 0); // prepare pattern bool AddPattern(string name, int ptype); // add new pattern bool TeachHNN(void); // learn neural net bool SaveFileHNN(void); // neural net file double CalculateHNN(void); // calc neural signal //protected: //--- method of initialization of the Hlaiman Application bool InitHNN(bool openn); // Hlaiman App Init void FreeHNN(void) { // Hlaiman App Deinit if(m_hnn!=0 && m_hnn!=INVALID_HANDLE) { FileClose(m_hnn); m_hnn=0; } }; };
Après la création de l’instance de classe à l’aide du constructeur, cet objet peut fonctionner dans deux modes principaux :
- Le mode d’enseignement: ce mode est associé à la collecte de modèles de marché et à l’enseignement du réseau de neurones.
- Le mode indicateur: dans ce mode, le signal du réseau de neurones est calculé à l’aide du modèle actuel.
Le mode est identifié lors de l’appel du mode d’initialisation InitHNN à l’aide du paramètre booléen openn. La valeur réelle de ce paramètre initie la recherche et l’ouverture, ainsi que le chargement et le fonctionnement du fichier de données du réseau de neurones enseigné en mode indicateur (2). Ce mode est considéré comme le mode de fonctionnement et est utilisé dans l’Expert Advisor pour le trading.
Contrairement au mode d’enseignement (1) qui est initialisé lors de l’appel de la méthode InitHNN avec openn=false, le mode indicateur est préparatoire à l’Expert Advisor et est utilisé pour le fonctionnement du script d’enseignement.
La méthode d’initialisation est implémentée comme suit :
//+------------------------------------------------------------------+ //| Initialize HNN | //+------------------------------------------------------------------+ bool CSignalHNN::InitHNN(bool openn) { //--- initialize Hlaiman Application int num=0; ulong res=0; if(m_symbol!=NULL) { hnn_sym=m_symbol.Name(); hnn_period=m_period; } else { hnn_sym=_Symbol; hnn_period=_Period; } hnn_per = string(PeriodSeconds(hnn_period) / 60); hnn_fil = hnn_nam + NAME_DELIM + hnn_sym + hnn_per + NAME_DELIM + string(hnn_index) + TYPE_NEURO; if(m_hnn== 0|| m_hnn == INVALID_HANDLE) m_hnn=FileOpen(HLAIMAN_PIPE,FILE_READ|FILE_WRITE|FILE_BIN); if(m_hnn!=0 && m_hnn!=INVALID_HANDLE) { string source,result=""; if(openn==true) { result=CON_OPENN+CON_TRUE; if(!FileIsExist(hnn_fil,FILE_READ)) { if(FileIsExist(hnn_fil,FILE_READ|FILE_COMMON)) hnn_fil=TerminalInfoString(TERMINAL_COMMONDATA_PATH)+PATH_FILES+hnn_fil; else { // hnn_fil = hnn_path + PATH_MQL5 + PATH_FILES + hnn_fil; hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } } else hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } else { result=CON_OPENN+CON_FALSE; hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } source="unit InitHNN; Interface "+result+" var libr, term, exp, sym: TObject;" " Implementation function main: integer;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');" " if (exp = nil) then exp := term.AddObject('TMT45Expert');\n\r" // Line #5 " if (exp <> nil) then" " begin" " if (exp.Name <> '"+hnn_nam+"') then exp.Name := '"+hnn_nam+"';\n\r" // Line #6 " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');" " if (sym = nil) then sym := exp.AddObject('TMT45Symbol');" " if (sym <> nil) then" " begin" " sym.Log.Add('"+hnn_sym+hnn_per+"');\n\r" " if (sym.Name <> '"+hnn_sym+hnn_per+"') then sym.Name := '"+hnn_sym+hnn_per+"';" " if (sym.Period <> "+hnn_per+") then sym.Period := "+hnn_per+";" " if (openn = true) then" " begin" // " sym.Log.Add('" + hnn_fil + "');" " if (sym.Open('"+hnn_fil+"')) then Result := sym.TeachInput;\n\r" // ret input Line #8 " end else" " begin" " sym.TeachInput := "+IntegerToString(hnn_in)+";" " sym.TeachOutput := "+IntegerToString(hnn_out)+";" " sym.TeachLayer := "+IntegerToString(hnn_layers)+";" " sym.TeachNeurons := "+IntegerToString(hnn_neurons)+";" " sym.TeachEpoch := "+IntegerToString(hnn_epoch)+";" " sym.FileName := '"+hnn_fil+"';" " Result := sym.TeachInput;\n\r" // ret input Line #9 " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(res<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); res=FileSize(m_hnn); num++; } if(res>0) { result=FileReadString(m_hnn,int(res/2)); res=StringToInteger(result); if(res<=RES_OK) printf(__FUNCTION__+": Error! Initialization data(possible reason: FILE NOT EXIST OR CORRUPTED "+hnn_fil); else { printf(__FUNCTION__+": Initialization successful! NEURAL PATTERN "+string(res)); ArrayResize(pattern,int(res+1)); return(true); } } else printf(__FUNCTION__+": Error! pipe server not responding(possible elimination: RESTART HLAIMAN APPLICATION)"); } else printf(__FUNCTION__+": Error! initializing pipe server (possible reason: HLAIMAN APPLICATION IS NOT RUNNING!)"); //--- ok return(false); }
Comme le voit le code, la première étape d’initialisation couvre une tentative d’ouverture d’un canal nommé pour la connectivité avec l’application Hlaiman. Si cette tentative échoue (par exemple, lorsque <hlaim.exe> n’est pas en cours d’exécution), la sortie est effectuée avec un état négatif. À la deuxième étape (après la réussite de la première étape et du mode indicateur de fonctionnement), les dossiers locaux et courants du terminal sont recherchés pour le nom de fichier requis avec les données du réseau de neurones. La troisième étape concerne la préparation du code dans ObjectPascal (Delphi) pour l’initialisation directement dans l’application Hlaiman.
Le texte du code est ensuite déplacé vers la chaîne source. Pour faciliter la mise en forme, il est décomposé en sous-chaînes à l’aide de '\n\r' et contient des appels de propriétés et de méthodes d’objet Hlaiman (voir commentaires). Comme défini dans le texte, l’environnement basé sur les objets du plug-in MetaTrader 5 Hlaiman représente l’architecture arborescente, avec l’objet du plug-in à la racine.
L’objet terminal МetaТrader 5 est au niveau suivant, suivi par Expert Advisor et les objets symboles. En cas de traduction et d’exécution réussies du code source transmis via le canal nommé, la valeur Result renvoyée contiendra le nombre d’éléments du vecteur d’entrée du réseau de neurones. Comme le suggère le code, cette valeur est utilisée pour initialiser le tableau de modèles et l’exécution de la méthode est terminée avec un état positif.
Les autres méthodes clés de la classe CSignalHNN sont CalculateHNN, AddPattern et TeachHNN. Le premier renvoie le résultat du calcul du réseau de neurones en mode indicateur. Les deux autres méthodes sont utilisées en mode d’enseignement lors de la collecte de modèles et du lancement du processus d’enseignement du réseau de neurones, respectivement.
L’implémentation de ces méthodes dans <SignalHNN.mqh> est la suivante :
//+------------------------------------------------------------------+ //| Calculate HNN signal | //+------------------------------------------------------------------+ double CSignalHNN::CalculateHNN(void) { if(m_hnn==0 || m_hnn==INVALID_HANDLE) return(0.0); int num = 0; ulong siz = 0; double res=0.0; string source,result=""; if(FillPattern(0)==true) { result=CON_START; for(int i=1; i<(ArraySize(pattern)-1); i++) result= result+DoubleToString(pattern[i])+CON_ADD; result = result + DoubleToString(pattern[ArraySize(pattern) - 1]) + CON_END; source = "unit CalcHNN; Interface " + result + " var i: integer; libr, term, exp, sym, lst: TObject;" " Implementation function main: double;\n\r" // Line #1 " begin" " Result := 0.0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " lst := TStringList.Create;" " if (lst <> nil) then" " begin" " lst.Text := cons;" " if (lst.Count >= sym.NetInputs.Count) then" " begin" " for i := 0 to sym.NetInputs.Count - 1 do" " begin" " sym.NetInputs.Objects[i].NetValue := StrToFloat(lst[i]);\n\r" // Line #6 // " sym.Log.Add('Input ' + IntToStr(i) + ' = ' + lst[i]);" " end;" " sym.Computed := true;" " Result := sym.NetOutputs.Objects[0].NetValue;\n\r" // ret input Line #7 " end;" " lst.Free;" " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToDouble(result); } } //else Print("fill pattern error!"); return(res); } //+------------------------------------------------------------------+ //| AddPattern | //+------------------------------------------------------------------+ bool CSignalHNN::AddPattern(string name,int ptype) { int num=0; long res=0; ulong siz=0; string result,source,nam=name; if(m_hnn!=0 || m_hnn!=INVALID_HANDLE) { pattern[0]=ptype; result=CON_START; for(int i=0; i<(ArraySize(pattern)-1); i++) result= result+DoubleToString(pattern[i])+CON_ADD; result = result + DoubleToString(pattern[ArraySize(pattern) - 1]) + CON_END; source = "unit AddPatternHNN; Interface " + result + " Implementation function main: integer;" " var i: integer; out: double; onam: string;" " libr, term, exp, sym, ord, tck, lst: TObject;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " lst := TStringList.Create;" " if (lst <> nil) then" " begin" " lst.Text := cons;" " if (lst.Count >= (sym.TeachInput + sym.TeachOutput)) then" " begin" " out := StrToFloat(lst[0]);" " if(out >= 0) then onam := 'BUY-"+nam+"'" " else onam := 'SELL-"+nam+"';" " ord := sym.ObjectOfName(onam);" " if (ord = nil) then ord := sym.AddObject('TMT45Order');\n\r" // Line #6 " if (ord <> nil) then" " begin" " if (ord.Name <> onam) then ord.Name := onam;\n\r" // Line #7 " if (out >= 0) then ord.OrderType := 0 else ord.OrderType := 1;" " if (ord.NetOutput <> out) then ord.NetOutput := out;\n\r" // Line #8 " for i := 1 to sym.TeachInput do" " begin" " if(i <= ord.Count) then tck := ord.Items[i - 1] else" " tck := ord.AddObject('TMT45Tick');\n\r" // Line #10 " if (tck <> nil) then" " begin" " tck.x := i;" " tck.y := StrToFloat(lst[i]);\n\r" // Line #11 " end;" " end;" " end;" " Result := sym.Count;\n\r" // ret input Line #12 " end;" " lst.Free;" " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToInteger(result); } } return(res>0); } //+------------------------------------------------------------------+ //| TeachHNN | //+------------------------------------------------------------------+ bool CSignalHNN::TeachHNN(void) { int num=0; long res=0; ulong siz=0; string result,source; if(m_hnn!=0 || m_hnn!=INVALID_HANDLE) { source="unit TeachHNN; Interface const WAIT_TIM = 100; WAIT_CNT = 100;" " var i: integer; libr, term, exp, sym: TObject;" " Implementation function main: integer;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " if (sym.Teached) then sym.Teached := false;\n\r" // Line #6 " sym.Teached := true;\n\r" // Line #7 " Result := sym.Count;\n\r" // ret input Line #8 " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0) {// && (MQL5InfoInteger(MQL5_TESTER) || num < WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToInteger(result); } } return(res>0); }
Comme on peut le voir dans le code, le corps de la méthode se compose principalement des lignes sources, dont le texte est organisé de la même manière que les textes considérés ci-dessus dans la description de la méthode InitHNN. La seule différence étant que la hiérarchie basée sur les objets du plug-in a deux niveaux supplémentaires pour la représentation du motif - ordre et tick. En outre, le code contient des propriétés et des méthodes d’objet supplémentaires. Par exemple, le début du calcul du réseau de neurones est marqué par le drapeau calculé de l’objet « symbole », tandis que le drapeau enseigné est utilisé lors du lancement du processus d’enseignement.
La méthode CalculateHNN est également différente des autres méthodes en ce que le type de la valeur 'main' renvoyée par la fonction dans ce cas est 'double'. Cette valeur est la sortie du réseau de neurones - le signal, où le niveau BUY se situe dans la plage 0..1 et le niveau SELL est dans la plage 0..-1. Ce signal est utilisé par l’Expert Advisor pour prendre des décisions concernant l’ouverture ou la fermeture de positions de trading et est contrôlé par la méthode Direction. Cette méthode effectue un nouveau calcul dans le cas de la nouvelle barre et renvoie sa valeur exprimée en pourcentage.
//+------------------------------------------------------------------+ //| Check conditions for trading signals. | //+------------------------------------------------------------------+ double CSignalHNN::Direction(void) { if( m_hnn == 0 || m_hnn == INVALID_HANDLE) return(EMPTY_VALUE); //--- check new bar condition int cur_bar = Bars(hnn_sym, hnn_period); if (hnn_bar != cur_bar) { //--- condition OK hnn_signal = CalculateHNN() * 100; hnn_bar = cur_bar; } return(hnn_signal); }
Pour définir le seuil de réponse du signal de l’Expert Advisor en ce qui concerne les signaux d’ouverture et de clôture des positions de trading, vous pouvez utiliser les variables externes suivantes :
- entrée int Signal_ThresholdOpen = 10; Valeur seuil du signal à ouvrir [0...100]
- entrée int Signal_ThresholdClose=10; Valeur seuil du signal à fermer [0...100]
En pratique, les niveaux de signal dépendent de la qualité et de l’intensité de l’enseignement du réseau de neurones qui, en règle générale, peut être évalué visuellement en surveillant la dynamique de diminution de l’erreur de calcul affichée dans l’indicateur au cours de l’enseignement.
Conclusions
Hlaiman EA Generator fournit des composants et un environnement transparent contrôlé basé sur des objets pour l’intégration avec MQL5, par lequel :
- L’interface de l’assistant MQL5 Wizard obtient un type supplémentaire basé sur la reconnaissance du signal et des formes, ainsi que la possibilité de générer des EA de réseau de neurones.
- En plus de la possibilité de générer rapidement des EA de réseau de neurones, vous pouvez également les adapter rapidement à l’évolution du comportement du marché et les enseigner à plusieurs reprises sur différents instruments de trading et délais.
- Ainsi que l’assistant MQL5 Wizard peut activer plusieurs modules de signaux, vous pouvez créer des AG de réseau de neurones multi-devises complexes et/ou des SA de réseau de neurones basés sur des indicateurs composés. Ils peuvent également être combinés avec divers filtres supplémentaires, par exemple des filtres temporels.
- Et enfin, le module de réseau de neurones en lui-même peut être utilisé comme filtre supplémentaire pour augmenter l’efficacité d’un Expert Advisor prêt à l’emploi. Cela est possible grâce à la capacité d’un réseau de neurones à être enseigné à l’aide des tableaux de visualisation des résultats des tests de l’Expert Advisor original.
L’utilisation de l’interpréteur de script faisant apparaître le système informatique intégré peu performant peut être considérée comme l’un des inconvénients de l’implémentation fournie ci-dessus. Tout d’abord, cependant, il convient de noter que l’interprétation du code de script, ainsi que le fonctionnement du plug-in Hlaiman est asynchrone avec EX5, c’est-à-dire que nous traitons de la parallélisation des tâches. Deuxièmement, pour augmenter la vitesse des calculs fastidieux, par exemple lorsqu’il s’agit de grands réseaux de neurones, MetaTrader 5 et Hlaiman peuvent être exécutés sur différents ordinateurs connectés via des canaux réseau nommés. En lançant un terminal de trading sur un ordinateur séparé, vous gagnerez non seulement en performance, mais vous pourrez également augmenter sa sécurité.
Lorsqu’ils sont mis en perspective, nous pouvons examiner le développement d’Expert Advisors qui peuvent s’auto-apprendre au cours du trading. À ce stade, le moyen le plus simple de le faire consiste à combiner le code de l’Expert Advisor avec le code du script d’enseignement, car les deux utilisent la même classe CSignalHNN qui fournit les fonctionnalités requises. Ce matériel peut devenir le sujet de l’article de suivi ou constituer la base d’un article complètement nouveau, s’il semble intéressant.
La version de démo de Hlaiman EA Generator peut être téléchargée ici.
Pièces jointes :
- SignalHNN.mqh - module de signal "MQL5\Include\Expert\Signal\".
- TeachHNN.mq5 - script d'enseignement "MQL5\Scripts\".
- SampleHNN.mq5 - Expert Advisor basé sur le module de signal de trading 'Signaux de modèles Hlaiman Neural Network EA generator' et généré à l'aide de l'assistant MQL5 Wizard.
Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/706
Construire un trader automatique de nouvelles
Une autre classe MQL5 OOP
Le MQL5 Wizard : Comment apprendre à un EA à ouvrir des ordres en attente à n’importe quel prix
Comment installer et utiliser OpenCL pour les calculs
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation