Connecter les NeuroSolutions Réseaux Neuronaux

Introduction

Je suppose que tous les traders qui se familiarisent avec les réseaux neuronaux pensent à quel point ce serait formidable de les utiliser dans l'analyse du marché. Il existe de nombreux programmes qui permettent de créer facilement vos propres réseaux de n'importe quelle configuration, de les enseigner et de les tester en mode visuel. Vous pouvez exporter les informations nécessaires du terminal client vers un programme réseau neuronal et les ’y analyser

Mais que se passe-t-il si vous souhaitez utiliser le réseau neuronal créé dans le trading automatique ? Est-il possible de connecter un Expert Advisor à un réseau neuronal et de trade en mode temps réel ?

Oui c'est le cas. Plusieurs programmes de réseau neuronal disposent les interfaces de programme nécessaires. L'un d'eux s'appelleNeuroSolutions Sa dernière version est la 6, mais ce n’est pas tout le monde qui l’a et la version la plus populaire pour l'instant est la 5ème. C'est pourquoi cet article décrit l'interaction avec la 5ème version. Vous avez besoin de la distribution complète du programme ; il inclut l'assistant de solution personnalisé dont nous avons besoin.

Pensez à une stratégie

La stratégie pour notre exemple de test sera simple. Appelons-leWeekPattern . Il prévoit le prix de clôture d'une barre à son ouverture sur la période J1 à l'aide d'un réseau neuronal. En fonction des informations obtenues, il conclura un deal d’achat d'achat ou de vente et le conservera toute la journée. La prévision de prix sera axée sur les valeurs OHLC des 5 barres précédentes. Pour augmenter la précision du fonctionnement du réseau neuronal, nous allons lui uniquement envoyer les modifications de prix par rapport au prix d'ouverture de l’actuelle barre (zéro) , au lieu des prix eux-mêmes.

Préparation des Données pour la Formation

Avant d’entamer la création d’ un réseau, écrivons un script MQL5, qui exportera toutes les cotations du terminal client sous la forme requise. Ces informations sont nécessaires pour former le réseau neuronal. Les données seront exportées dans un fichier texte. Liste des noms de champs séparés par une virgule dans la première liste du fichier. Les lignes suivantes seront utilisées pour les données séparées par des virgules. Chaque ligne est une combinaison d'entrées et de sorties du réseau neuronal. Dans notre cas, le script reculera d'une barre de l'historique des prix sur chaque ligne et écrira les valeurs OHLC de 6 barres dans la ligne (5 barres du passé sont des entrées et une barre actuelle est la sortie).

Le script скриптWeekPattern-Export.mq5 doit être lancé à une période exigée d'un symbole requis (dans notre exemple, il s'agit de D1 EURUSD). Dans les paramètres, vous devez indiquer un nom de fichier et le nombre de lignes requis (260 lignes pour D1 correspondent à environ 1 an d'historique). Le code complet du script :

#property script_show_inputs
//+------------------------------------------------------------------+
input string    Export_FileName = "NeuroSolutions\\data.csv"; // File for exporting (in the folder "MQL5\Files")
input int       Export_Bars     = 260; // Number of lines to be exported
//+------------------------------------------------------------------+
void OnStart() 
  {
  
   // Create the file
   int file = FileOpen(Export_FileName, FILE_WRITE|FILE_CSV|FILE_ANSI, ',');
   
   if (file != INVALID_HANDLE)
     {
      // Write the heading of data
      
      string row="";
      for (int i=0; i<=5; i++)
        {
         if (StringLen(row)) row += ",";
         row += "Open"+i+",High"+i+",Low"+i+",Close"+i;
        }
      FileWrite(file, row);
      
      // Copy all required information from the history
      
      MqlRates rates[], rate;
      int count = Export_Bars + 5;
      if (CopyRates(Symbol(), Period(), 1, count, rates) < count)
        {
         Print("Error! Not enough history for exporting of data.");
         return;
        }
      ArraySetAsSeries(rates, true);
      
      // Write data      
      
      for (int bar=0; bar<Export_Bars; bar++)
        {
         row="";
         double zlevel=0;
         for (int i=0; i<=5; i++)
           {
            if (StringLen(row)) row += ",";
            rate = rates[bar+i];
            if (i==0) zlevel = rate.open; // level for counting of prices
            row += NormalizeDouble(rate.open -zlevel, Digits()) + ","
                 + NormalizeDouble(rate.high -zlevel, Digits()) + ","
                 + NormalizeDouble(rate.low  -zlevel, Digits()) + ","
                 + NormalizeDouble(rate.close-zlevel, Digits());
           }
         FileWrite(file, row);
        }

      FileClose(file);
      Print("Export of data finished successfully.");
     }
   else Print("Error! Failed to create the file for data export. ", GetLastError());
  }
//+------------------------------------------------------------------+

Après avoir exporté les données, nous obtenons le fichier data.csv ; ses premières lignes (par exemple) se présentent comme suit :

Open0,High0,Low0,Close0,Open1,High1,Low1,Close1,Open2,High2,Low2,Close2,Open3,High3,Low3,Close3,Open4,High4,Low4,Close4,Open5,High5,Low5,Close5
0,0.00463,-0.0041,0.00274,-0.00518,0.00182,-0.00721,-6e-005,0.00561,0.00749,-0.00413,-0.00402,0.02038,0.02242,0.00377,0.00565,0.03642,0.0379,0.01798,0.02028,0.0405,0.04873,0.03462,0.03647
0,0.007,-0.00203,0.00512,0.01079,0.01267,0.00105,0.00116,0.02556,0.0276,0.00895,0.01083,0.0416,0.04308,0.02316,0.02546,0.04568,0.05391,0.0398,0.04165,0.04504,0.05006,0.03562,0.0456
0,0.00188,-0.00974,-0.00963,0.01477,0.01681,-0.00184,4e-005,0.03081,0.03229,0.01237,0.01467,0.03489,0.04312,0.02901,0.03086,0.03425,0.03927,0.02483,0.03481,0.02883,0.04205,0.02845,0.03809

C'est le format, qui peut être compris par NeuroSolutions. Dés à présent, nous sommes en mesure d’entamer la création et la formation d’un réseau.

Création de Réseau Neuronal

Dans NeuroSolutions, vous êtes en mesure de rapidement créer un réseau neuronal, même si vous voyez ce programme pour la première fois et que vous en savez peu sur les réseaux neuronaux. Pour se faire, sélectionnez l'assistant pour débutants NeuralExpert (débutant) au démarrage du programme :

Vous devez y spécifier un type de problème qui doit être résolu par le réseau neuronal :

Ensuite, indiquez le fichier avec les informations de formation, que nous avons créé dans le chapitre précédent :

Comme entrées du réseau, sélectionnez tous les champs du fichier sauf les champs de la barre zéro :

Comme nous n'avons pas de champs de texte, ne sélectionnez rien :

Spécifiez à nouveau notre fichier avec les informations :

Sélectionnez une seule sortie de notre réseau :

L'assistant suggère de créer le réseau le plus simple par défaut. Faisons-le :

L'assistant a terminé son travail de création d’ un réseau neuronal pour nous (pas un réseau formé, juste une structure simple) :

Maintenant, nous pouvons travailler avec. Nous pouvons le former, le tester et l'utiliser pour l'analyse des données.

Si vous cliquez sur le boutonTest, vous serez en mesure de voir comment le réseau non formé réglera notre problème. Répondez aux questions de l'assistant de test :

Effectuez le test sur la base des informations du même fichier :

Le test est terminé. Dans la fenêtre "Sortie vs. Desired Plot" vous pouvez voir le graphique qui indique les valeurs obtenues du net (la couleur rouge) sur notre historique et les valeurs réelles (la couleur bleue). Vous pouvez voir qu'ils sont assez différents :

Maintenant, formons le réseau Pour se faire, cliquez sur le bouton vertStart dans la barre d'outils sous le menu. La formation sera terminée après quelques secondes et le graphique changera :

Maintenant, dans le graphique, vous êtes en mesure de constater que le réseau montre les résultats qui ont l’air vrais. Par conséquent, vous êtes en mesure de l'utiliser pour le trading. Enregistrez le réseau sous le nom WeekPattern

Exporter le réseau neuronal dans une DLL

Sans quitter NeuroSolutions, cliquez sur le boutonCSW qui lance l'assistant de solution personnalisée. Nous devons générer une DLL à partir de l’actuel réseau neuronal

L'assistant peut générer des DLL pour différents programmes. D'après ce que j'ai compris, pour la compilation de la DLL, vous avez besoin de Visual C++ de l'une des versions suivantes : 5.0/6.0/7.0 (.NET 2002)/7.1 (.NET 2003)/8.0 (.NET 2005). Pour une raison quelconque, il n'utilise pas la version Express (je l'ai vérifié).

Il n'y a pas de MetaTrader dans la liste des applications cibles. C'est pourquoi sélectionnez Visual C++.

Chemin pour enregistrer le résultat :

Si tout s'est passé avec succès, l'assistant indique :

De nombreux fichiers apparaîtront dans le dossier spécifié dans l'assistant. Ceux dont nous avons le plus besoin sont : WeekPattern.dll, il comporte notre réseau neuronal avec l'interface du programme ; et le fichier WeekPattern.nsw qui comporte les paramètres d'équilibre du réseau neuronal après sa formation. Parmi les autres fichiers, vous pouvez trouver celui avec un exemple de travail avec ce DLL-réseau neuronal. Dans ce cas, il s'agit du projet Visual C++ 6.

Connecter DLL-réseau neuronal à MetaTrader

Créé dans le chapitre précédent, DLL-réseau neuronal est destiné à être utilisé dans des projets Visual C++. Il fonctionne avec les objets d'une structure complexe qui serait difficile à décrire sur MQL5 voire impossible. C'est pourquoi nous n'allons pas connecter directement cette DLL à MetaTrader. Au lieu de cela, nous allons créer un petit adaptateur DLL. Cet adaptateur comportera une simple fonction pour travailler avec le réseau neuronal. Il créera le réseau, lui transmettra les informations d'entrée et renverra les données de sortie.

Cet adaptateur sera facilement appelé depuis MetaTrader 5. Et l'adaptateur se connectera au DLL-réseau neuronal créé dans NeuroSolutions. Puisque l'adaptateur sera écrit en Visual C++, il n'aura aucun problème avec les objets de cette DLL.

Il n'est pas nécessaire de créer vous-même l'adaptateur DLL. La DLL prête à l'emploi est jointe à cet article. L'adaptateur fonctionne avec n'importe quel réseau neuronal DLL créé dans NeuroSolutions. Vous pouvez passer la lecture de ce chapitre.

Mais si vous avez une expérience de la programmation en C++ et si vous souhaitez savoir comment créer un tel adaptateur, lisez ce chapitre jusqu'à la fin. Probablement, vous aurez intérêt à l'améliorer, puisque certaines autres fonctions peuvent être exportées à partir d'un DLL-réseau neuronal. Par exemple, la fonction formation ( Un Expert Advisor s’adapte à un marché en évolution ,re-formation du réseau automatiquement) Vous pouvez connaître la liste complète des fonctions en analysant l'exemple généré par l'assistant de solution personnalisée, qui est présenté dans le chapitre précédent.

Nous n'aurons besoin que de plusieurs fichiers de cet exemple.

Dans Visual C++ (la même version que celle utilisée dans Custom Solution Wizard), créez un projet DLL vide nommé NeuroSolutionsAdapter et copiez les fichiers NSNetwork.h, NSNetwork.cpp et StdAfx.h de l'exemple vers celui-ci. Créez également un fichier vide main.cpp  :

Écrivez le code suivant dans le fichier main.cpp :

#include "stdafx.h"
#include "NSNetwork.h"

extern "C" __declspec(dllexport) int __stdcall CalcNeuralNet(
                LPCWSTR dllPath_u, LPCWSTR weightsPath_u,
                double* inputs, double* outputs)
{       
    // Transform the lines from Unicode to normal ones
    CString dllPath     (dllPath_u);
    CString weightsPath (weightsPath_u);

    // Create neuronet
    NSRecallNetwork nn(dllPath);
    if (!nn.IsLoaded()) return (1);

    // Load balances
    if (nn.LoadWeights(weightsPath) != 0) return (2);
        
    // Pass input data and calculate the output
    if (nn.GetResponse(1, inputs, outputs) != 0) return (3);

    return 0;
}

Construire L'adaptateur DLL est prêt !

Utiliser réseau neuronal dans Expert Advisor

Eh bien, nous avons déjà créé plusieurs fichiers. Permettez-moi de lister les fichiers nécessaires au fonctionnement de l'Expert Advisor et les dossiers dans lesquels vous devez les placer. Tous ces fichiers sont joints à l'article.

Fichier	Description	Où mettre (dans le dossier du terminal)
WeekPattern.dll	notre DLL-réseau neuronal créé dans NeuroSolutions	MQL5\Files\NeuroSolutions\
WeekPattern.nsw	paramètres d'équilibre de notre réseau neuronal	MQL5\Files\NeuroSolutions\
NeuroSolutionsAdapter.dll	adaptateur DLL universel pour n'importe quel réseau neuronal DLL	MQL5\Libraries\

Voici le code complet de l'Expert AdvisorWeekPattern.mq5. Pour faciliter la recherche et les modifications ultérieures, tout ce qui concerne le réseau neuronal est placé dans la classe séparée CNeuroSolutionsNeuralNet.

input double    Lots = 0.1;
//+------------------------------------------------------------------+
// Connect the DLL adapter, using which we are going to use the DLL neuronet created in NeuroSolutions
#import "NeuroSolutionsAdapter.dll"
int CalcNeuralNet(string dllPath, string weightsPath, double& inputs[], double& outputs[]);
#import 
//+------------------------------------------------------------------+
class CNeuroSolutionsNeuralNet
{
private:
   string dllPath;     // Path to a DLL neuronet created in NeuroSolutions
   string weightsPath; // Path to a file of the neuronet balances
public:
   double in[20]; // Neuronet inputs - OHLC of 5 bars
   double out[1]; // Neuronet outputs - Close of a current bar

   CNeuroSolutionsNeuralNet();
   bool Calc();
};
//+------------------------------------------------------------------+
void CNeuroSolutionsNeuralNet::CNeuroSolutionsNeuralNet()
{
   string terminal = TerminalInfoString(TERMINAL_PATH);
   dllPath     = terminal + "\\MQL5\\Files\\NeuroSolutions\\WeekPattern.dll";
   weightsPath = terminal + "\\MQL5\\Files\\NeuroSolutions\\WeekPattern.nsw";
}
//+------------------------------------------------------------------+
bool CNeuroSolutionsNeuralNet::Calc()
  {
   // Get current quotes for the neuronet
   MqlRates rates[], rate;
   CopyRates(Symbol(), Period(), 0, 6, rates);
   ArraySetAsSeries(rates, true);
      
   // Fill the array of input data of the neuronet
   double zlevel=0;   
   for (int bar=0; bar<=5; bar++)
     {
      rate = rates[bar];
      // 0 bar is not taken for input
      if (bar==0) zlevel=rate.open; // level of price calculation
      // 1-5 bars are inputed
      else
        {
         int i=(bar-1)*4; // input number
         in[i  ] = rate.open -zlevel;
         in[i+1] = rate.high -zlevel;
         in[i+2] = rate.low  -zlevel;
         in[i+3] = rate.close-zlevel;
        }
     }
 
   // Calculate the neuronet in the NeuroSolutions DLL (though the DLL adapter)
   int res = CalcNeuralNet(dllPath, weightsPath, in, out);
   switch (res)
     {
      case 1: Print("Error of creating neuronet from DLL \"", dllPath, "\""); return (false);
      case 2: Print("Error of loading balances to neuronet from the file \"", weightsPath, "\""); return (false);
      case 3: Print("Error of calculation of neuronet");  return (false);
     }
     
   // Output of the neuronet has appeared in the array out, you shouldn't do anything with it

   return (true);
  }
//+------------------------------------------------------------------+

CNeuroSolutionsNeuralNet NN;
double Prognoze;

//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
//+------------------------------------------------------------------+
void OnTick() 
  {
   // Get the price prediction from the neuronet
   if (NN.Calc()) Prognoze = NN.out[0];
   else           Prognoze = 0;

   // Perform necessary trade actions
   Trade();
  }
//+------------------------------------------------------------------+
void Trade() 
  {

   // Close an open position if it is opposite to the prediction

   if(PositionSelect(_Symbol)) 
     {
      long type=PositionGetInteger(POSITION_TYPE);
      bool close=false;
      if((type == POSITION_TYPE_BUY)  && (Prognoze <= 0)) close = true;
      if((type == POSITION_TYPE_SELL) && (Prognoze >= 0)) close = true;
      if(close) 
        {
         CTrade trade;
         trade.PositionClose(_Symbol);
        }
     }

   // If there is no positions, open one according to the prediction

   if((Prognoze!=0) && (!PositionSelect(_Symbol))) 
     {
      CTrade trade;
      if(Prognoze > 0) trade.Buy (Lots);
      if(Prognoze < 0) trade.Sell(Lots);
     }
  }
//+------------------------------------------------------------------+

Un bon moyen de vérifier si nous avons correctement connecté le réseau neuronal consiste à exécuter l'Expert Advisor dans le testeur de stratégie sur la même période que celle utilisée pour le formation du réseau neuronal.

Eh bien, comme le disent les traders expérimentés, le réseau neuronal est « adaptateur » pour cette période. Il est donc formé à reconnaître et à informer sur un signal de profit pour ces modèles de données exacts, qui dominent dans cette période spécifique. Un graphique de rentabilité d'un Expert Advisor tracé pour une telle période doit être ascendant.

Vérifions-le. Dans notre cas ce sera le beau tableau suivant :

Cela signifie que tout a été correctement connecté

Et pour les statistiques, voici les autres rapports sur les tests de l'Expert Advisor :

Juste au cas où, permettez-moi de donner des explications aux développeurs novices de stratégies de trading et de réseaux neuronaux.

La rentabilité d'un Expert Advisor sur une période, qui a servi à son optimisation (formation de son réseau neuronal), ne renseigne pas sur la rentabilité globale de l'EA. Autrement dit, il ne garantit pas sa rentabilité sur l'autre période. Il peut y avoir d'autres modèles dominants.

La création de stratégies de trade qui maintiennent leur rentabilité derrière la période de formation est une tâche complexe et compliquée. Vous ne devriez pas compter sur les NeuroSolutions ou toute autre application réseau neuronal pour vous régler ce problème Il ne crée qu'un réseau neuronal pour vos données.

Ce sont les raisons pour lesquelles je n'ai pas donné ici le résultat des tests avancés de l'Expert Advisor obtenu. La création d'une stratégie de trade rentable n'est pas le but de cet article. Le but est de dire comment connecter un réseau neuronal à un Expert Advisor.

Conclusion

Désormais, les traders disposent d'un autre outil puissant et simple pour l'analyse et le trading automatiques. L'utiliser avec une compréhension approfondie des principes et des possibilités des réseaux neuronaux ainsi que des règles de leur formation vous permettra de suivre la voie de la création d'Expert Advisors rentables.