Collegare NeuroSolutions Neuronets

Introduzione

Immagino che tutti i trader che familiarizzano con i neuronet pensino a quanto sarebbe bello usarli nell'analisi di mercato. Esistono molti programmi che consentono di creare comodamente le proprie reti di qualsiasi configurazione, insegnandole e testandole in modalità visiva. È possibile esportare le informazioni necessarie dal client terminal a un programma neuronet e analizzarle lì.

Ma cosa succede se vuoi usare il neuronet creato nel trading automatico? È possibile fare in modo che un Expert Advisor si colleghi a un neuronet e faccia trading in modalità tempo reale?

Sì. Diversi programmi neuronet hanno le interfacce di programma richieste. Uno di questi si chiama NeuroSolutions. La sua ultima versione è la 6, tuttavia non tutti la possiedono e la versione più popolare al momento resta la 5^. Ecco perché questo articolo descrive l'interazione con la 5^ versione. Hai bisogno della distribuzione completa del programma, che include il Solution Wizard personalizzato di cui abbiamo bisogno.

Pensa a una strategia

La strategia per il nostro esempio di test sarà semplice. Diamole il nome di WeekPattern. Predirà il prezzo di chiusura di una barra alla sua apertura sul periodo di tempo D1 utilizzando un neuronet. A seconda delle informazioni ottenute, eseguirà un’operazione di acquisto o vendita e a manterrà per tutto il giorno. La previsione dei prezzi sarà basata sui valori OHLC di 5 barre precedenti. Per aumentare l'accuratezza del funzionamento del neuronet, invieremo solo le variazioni di prezzo relativamente al prezzo aperto dell'attuale barra (zero) invece dei prezzi stessi.

Preparazione dei dati per la formazione

Prima di iniziare a creare una rete, scriviamo uno script MQL5 che esporterà tutte le quotazioni dal client terminal nella forma richiesta. Queste informazioni sono necessarie per la formazione del neuronet. I dati verranno esportati in un file di testo. Elenca i nomi dei campi separati da una virgola nel primo elenco del file. Le righe successive verranno utilizzate per i dati separati da virgole. Ogni linea è una combinazione di ingressi e uscite del neuronet. Nel nostro caso, lo script tornerà indietro di una barra di cronologia dei prezzi su ogni riga e scriverà i valori OHLC di 6 barre nella linea (5 barre precedenti sono input e una barra corrente è l'output).

Lo script скрипт WeekPattern-Export.mq5 deve essere avviato in un intervallo di tempo richiesto di un simbolo richiesto (nel nostro esempio sarà D1 EURUSD). Nelle impostazioni è necessario specificare il nome di un file e il numero richiesto di righe (260 righe per D1 è circa la cronologia di 1 anno). Il codice completo dello 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());
  }
//+------------------------------------------------------------------+

Dopo aver esportato i dati, otteniamo il data.csv del file; le sue prime righe (ad esempio) appaiono come segue:

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

Questo è il formato che può essere compreso da NeuroSolutions. Ora possiamo iniziare a creare e formare una rete.

Creazione di Neuronet

Su NeuroSolutions puoi creare rapidamente un neuronet, anche se stai usando questo programma per la prima volta e sai poco sui neuronet. Per farlo, seleziona la procedura guidata per principianti NeuralExpert (Beginner) all'avvio del programma:

Qui è necessario specificare il tipo di problema che deve essere risolto dal neuronet:

Quindi specifica il file con le informazioni di formazione che abbiamo creato in precedenza:

Come input della rete, seleziona tutti i campi del file tranne i campi della barra dello zero:

Poiché non abbiamo campi di testo, non selezionare nulla:

Specifica di nuovo il nostro file con le informazioni:

Seleziona un solo output della nostra rete:

La procedura guidata suggerisce di creare la rete più semplice per impostazione predefinita. Facciamolo:

Il wizard ha ultimato il suo lavoro e creato un neuronet per noi (non una rete formata, ma solo una semplice struttura):

Ora possiamo lavorarci. Possiamo formarlo, testarlo e utilizzarlo per l'analisi dei dati.

Se fai clic sul pulsante Test, sarai in grado di vedere come la rete non formata risolverà il nostro problema. Rispondi alle domande della procedura guidata del test:

Esegui il test sulla base delle informazioni dello stesso file:

Il test è ultimato. Nella finestra "Output vs. Desired Plot" puoi vedere il grafico che mostra i valori ottenuti dalla rete (in rosso) sul nostro storico e i valori reali (in blu). Puoi vedere che sono piuttosto diversi:

Ora formiamo la rete. Per farlo, clicca sul pulsante verde Start sulla barra degli strumenti sotto il menu. La formazione terminerà dopo pochi secondi e il grafico cambierà:

Ora nel grafico puoi vedere che la rete mostra dei risultati che sembrano essere veri. Pertanto, è possibile utilizzarla per la formazione. Salva la rete con il nome WeekPattern.

Esportare il neuronet in un DLL

Senza uscire da NeuroSolutions, clicca sul pulsante CSW che avvia ilCustom Solution Wizard. Dobbiamo generare un DLL dal neuronet corrente.

La procedura guidata può generare DLL per programmi diversi. Per quanto ho capito, per la compilazione del DLL è necessario Visual C++ in una delle seguenti versioni: 5.0/6.0/7.0 (.NET 2002)/7.1 (.NET 2003)/8.0 (.NET 2005). Per qualche motivo, non utilizza la versione Express (ho già verificato).

MetaTrader non compare nell'elenco delle applicazioni di destinazione. Ecco perché selezionare Visual C++.

Percorso per salvare il risultato:

Se è andato tutto bene, la procedura guidata dirà che:

Molti file verranno visualizzati nella cartella specificata nel wizard. Quelli di cui abbiamo più bisogno sono: WeekPattern.dll, che contiene il nostro neuronet con l'interfaccia del programma, e il file WeekPattern.nsw, che contiene le impostazioni di bilanciamento del neuronet dopo la sua formazione. Tra gli altri file puoi trovare quello con un esempio di lavoro con questa DLL-neuronet. In questo caso si tratta del progetto Visual C++ 6.

Connessione di DLL-Neuronet a MetaTrader

Il DLL-neuronet creato precedentemente è destinato all'utilizzo nei progetti Visual C++. Funziona con gli oggetti di una struttura complessa che sarebbe difficile da descrivere in MQL5 o addirittura impossibile. Ecco perché non collegheremo direttamente questo DLL a MetaTrader. Al suo posto creeremo un piccolo adattatore DLL. Questo adattatore conterrà una funzione semplice per lavorare con il neuronet. Creerà la rete, le passerà le informazioni di input e restituirà i dati di output.

Questo adattatore sarà facilmente chiamato da MetaTrader 5. E l'adattatore si collegherà al DLL-neuronet creato su NeuroSolutions. Poiché l'adattatore verrà scritto su Visual C++, non avrà problemi con gli oggetti di questa DLL.

Non è necessario creare l'adattatore DLL da soli. A questo articolo è già allegato Il DLL pronto. L'adattatore funziona con qualsiasi DLL-neuronet creato su NeuroSolutions. Puoi saltare l'ulteriore lettura di questo capitolo.

Ma se hai esperienza nella programmazione su C ++ e se sei interessato a come creare tale adattatore, leggi questo capitolo fino alla fine. Probabilmente, avrai interesse a migliorarlo poiché alcune altre funzioni possono essere esportate da un dll-neuronet. Ad esempio, la funzione di formazione (affinché un Expert Advisor si adatti a un mercato in evoluzione, ri-formando la rete automaticamente). È possibile apprendere l'elenco completo delle funzioni analizzando l'esempio generato dal Custom Solution Wizard, illustrato in precedenza.

Avremo bisogno solo di alcuni file di quell'esempio.

Su Visual C++ (la stessa versione utilizzata sul Custom Solution Wizard) crea un progetto DLL vuoto denominato NeuroSolutionsAdapter e copia i file NSNetwork.h, NSNetwork.cpp e StdAfx.h dall'esempio. Crea anche un file main.cpp vuoto:

Scrivi il codice seguente nel file 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;
}

Build. L'adattatore DLL è pronto!

Utilizzo di Neuronet su un Expert Advisor

Bene, abbiamo già creato diversi file. Permettetemi di elencare i file che sono necessari per il funzionamento dell’Expert Advisor e le cartelle in cui è necessario inserirli. Tutti questi file sono allegati all'articolo.

File	Descrizione	Dove inserirli (nella cartella del terminale)
WeekPattern.dll	il nostro DLL-neuronet creato su NeuroSolutions	MQL5\Files\NeuroSolutions\
WeekPattern.nsw	impostazioni di bilanciamento del nostro neuronet	MQL5\Files\NeuroSolutions\
NeuroSolutionsAdapter.dll	adattatore DLL universale per qualsiasi DLL-neuronet	MQL5\Libraries\

Ecco il codice completo dell'Expert AdvisorWeekPattern.mq5. Per comodità di ricerca e ulteriore modifica, tutto ciò che riguarda il neuronet è collocato nella classe separata 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 buon modo per verificare se abbiamo collegato correttamente il neuronet è quello di avviare l'Expert Advisor nel tester di strategia nello stesso periodo di tempo utilizzato per la formazione del neuronet.

Bene, come dicono i trader esperti, il neuronet è "l’adattatore" per quel periodo. Quindi è formato per riconoscere e dare informazioni su un segnale di profitto per quei modelli di dati esatti che dominano in questo periodo specifico. Il grafico della redditività di un Expert Advisor disegnato per tale periodo deve essere crescente.

Controlliamolo. Nel nostro caso avremo questo bellissimo grafico:

Ciò significa che tutto è stato collegato correttamente.

E per le statistiche ecco gli altri report sui test dell'Expert Advisor:

Per ogni evenienza, permettetemi di fornire altre spiegazioni per gli sviluppatori di strategie di trading e neuronet alle prime armi.

La redditività di un Expert Advisor in un periodo che è stato utilizzato per la sua ottimizzazione (formazione del suo neuronet), non dice nulla redditività totale dell'EA. In altre parole, non garantisce la sua redditività nell'altro periodo. Ci possono essere altri modelli dominanti.

La creazione di strategie di trading che mantengono la loro redditività dietro il periodo di formazione è un compito complesso e complicato. Non devi contare su NeuroSolutions o su qualsiasi altra applicazione neuronet per risolvere questo problema. Crea solo un neuronet per i tuoi dati.

Questi sono i motivi per cui non ho riportato qui il risultato del forward testing dell'Expert Advisor ottenuto. La creazione di una strategia di trading redditizia non è lo scopo di questo articolo. L'obiettivo è quello di raccontare come collegare un neuronet a un Expert Advisor.

Conclusione

Ora i trader possiedono un altro strumento potente e facile per l'analisi trading automatico e per il trading. Usarlo insieme a una profonda comprensione dei principi e delle possibilità dei neuronet e delle regole di formazione ti permetterà di seguire la strada della creazione di Expert Advisor redditizi.