Praktische Anwendung von neuronalen Netzen im Handel Es wird Zeit zum Üben

Einführung

In meinem vorherigen Artikel "Praktische Anwendung von neuronalen Netzen im Handel" habe ich die allgemeinen Punkte bei der Schaffung eines Handelssystems unter Verwendung von Neuronale Netzwerkmodule (NNM) beschrieben. In diesem Artikel werden wir das NNM in der Praxis testen. Wir werden auch versuchen, ein NNM-basiertes automatisiertes Handelssystem zu schaffen.

Alle Operationen werden für das EURUSD-Paar durchgeführt. Das Modul des neuronalen Netzes ist jedoch als Programm universell und kann mit verschiedenen Handelsinstrumenten und deren Kombinationen arbeiten. So ist es möglich, ein NNM zu verwenden, das mehrere für verschiedene Währungspaare trainierte neuronale Netze integriert.

Die Technologie bezüglich der Aufbereitung historischer Daten, die für das Training neuronaler Netze erforderlich ist, würde den Rahmen dieses Artikels sprengen. Unser NNM wird neuronale Netze verwenden, die auf historischen Daten nahe der Veröffentlichungszeit des Artikels trainiert werden.

Das resultierende NNM ist vollständig für den Handel bereit. Um den Komplex in einem Artikel vorstellen zu können, musste ich ihn so modifizieren, dass mehrere Funktionen des neuronalen Netzwerkmoduls in einem Programm kombiniert werden konnten. Außerdem habe ich bestimmte Bedingungen für die Ausführung von Geschäften von einem Handelsexpertenberater an die NNM verschoben. Letztere betreffen nur den NNM-Teil, der für den realen Handel bestimmt ist. Was das Testen des neuronalen Netzes und seine Reaktionsoptimierung im Offline-Modus betrifft, so werden alle relevanten Funktionen und Geschäftsausführungsbedingungen nach wie vor von den entsprechenden Expertenberatern ausgeführt. Was mich betrifft, so ziehe ich es vor, dass das NNM-Modul nur eine Handelsfunktion hat. Meiner Meinung nach muss das für den Handel verwendete NNM so einfach wie möglich sein, und es sollte keine zusätzlichen Funktionen enthalten. Die Funktionen selbst sollten außerhalb des Handelskomplexes implementiert werden. In unserem Fall umfassen diese Funktionen Schulung, Test und Optimierung. Die Ausführungsbedingungen für den Handel sollten besser im NNM implementiert werden, so dass die Signale in binärer Form empfangen werden können. Obwohl alle Ausführungsoptionen des NNM ihre Realisierbarkeit in der Praxis bestätigt haben.

Die Technologie der NNM-Vorbereitung und -Ausbildung auf der Matlab-Plattform wird im nächsten Artikel ausführlicher beschrieben.

Das System könnte in Zukunft auch in Python übersetzt werden. Ein entsprechendes kurzes Video ist am Ende dieses Artikels verfügbar.

NNMs erzielen in einer längeren Testphase positive Ergebnisse, wenn sie anhand von historischen Daten getestet werden, die Sie von den Brokern erhalten haben, mit denen Sie handeln. Dieser Teil könnte auch vereinheitlicht werden, aber ich glaube nicht, dass dies nützlich wäre. 

Das Modul EURUSD_MT5 Neuronales Netzwerk

Die folgende Abbildung zeigt, wie das Neuronale Netzwerkmodul bei der ersten Inbetriebnahme aussieht.

1. Der Online-Block wurde entwickelt, um neuronale Netze während des realen Handels und beim Testen im visuellen Modus zu starten und zu stoppen.
2. Informationsfelder mit den Bedingungen für die Signallinie, die die Ergebnislinie von neuronalen Netzwerken kreuzt, wenn der Online-Block aktiviert ist. 
3. "Train" ist ein Demonstrationsblock, der für Training und "Re-Training" (?) von neuronalen Netzen konzipiert ist.
4. Felder zur Ausgabe der Ergebniswerte von neuronalen Netzen. Links - die Ergebnisse neuronaler Netze; rechts - die Signallinie. Unten - aktueller Balken, oben - vorheriger Balken.
5. Der Offline-Block dient zur Ausgabe der Ergebnisse neuronaler Netze in einer Testprobe an ein Array.
6. Feld zur Eingabe für den Mittelwert der Ergebnis des neuronalen Netzes bei Verwendung des Online-Blocks. (Periodenlänge des Signals). Editierbarer Wert.
7. Blöcke "Netz1,2,3" — drei Untermodule von Netzwerken, die in verschiedenen Segmenten einer Zeitreihe trainiert werden. Jeder Block enthält zwei neuronale Netze.
8. NNM-Operationsendezeit bei Verwendung des Online-Blocks.
9. Feld zur Eingabe der NNM-Betriebsdauer in Stunden, wenn der Online-Block verwendet wird. Editierbarer Wert.
10. Zählung der seit NNM-Start verstrichenen Zeit, wenn der Online-Block verwendet wird.

Anlagen

1. MyAppInstaller_mcr.exe — Installationsdatei.
2. EURUSD_MT5.exe — das neuronale Netzwerkmodul selbst.
3. EURUSD_MT5var.exe — eine Variante des Neuronalen Netzwerk-Moduls.
4. net1-net6.mat — Neuronale Netze aus drei Subnetzen, Net1-Net3. Als Beispiel für ihr Training und Testen zu verwenden. 

1. ExpertMatlabPodkach_MT5.mq5 und ExpertMatlab_MT5.mq5 — zwei EA, die für die Vorbereitung historischer Daten für NNM-Offline-Tests erforderlich sind.
2. NWI.mq5 — Indikator, der die NNM-Ergebnisse visuell anzeigt.
3. Matlab_MT5.mq5 — eine EA zum Testen und Optimieren von NNM-Ergebnisse im Strategietester.
4. ExpertMatlabReal_MT5.mq5 — ein EA für den Online-Betrieb auf Real- oder Demokonten, sowie für den Test im Visualisierungsmodus.
5. EURUSDData.csv — Datei mit Trainingsdaten.

Installation des Programms

Vor der ersten Verwendung von Anwendungen, die von Matlab kompiliert wurden, müssen Sie MyAppInstaller_mcr.exe verwenden. Diese Anwendung wird zur Installation der MATLAB Runtime und des neuronalen Netzwerkmoduls selbst verwendet.

Nach der Programminstallation legen Sie die Verknüpfung EURUSD_MT5.exe in den Ordner ...\Common\Files im Datenverzeichnis ab. Auf diese Weise bieten wir eine bequeme Möglichkeit, das System zu starten. Alle Expert Advisors und NNMs schreiben Dateien in diesen Ordner. Der NNM bietet an, Dateien in dem Verzeichnis zu suchen, in dem sich die Verknüpfung befindet. 

1. Verknüpfung EURUSD_MT5

Festlegen eines Arbeitsverzeichnisses

2. Angabe des Pfads

Praktische Verwendung

Als Nächstes beschäftigen wir uns mit vier Optionen für den Einsatz des NNM:

1. Online-Handel auf Demo- oder Realkonten
2. NNM-Tests im visuellen Modus
3. Training des Neuronalen Netzes
4. Empfangen von Ergebnisse der Blöcke des neuronalen Netzes zur Optimierung einer Handelsstrategie

Man könnte sagen, dass die logische Reihenfolge der oben genannten Punkte anders wäre. Das Module des Neuronalen Netzes wurde jedoch ursprünglich erstellt, um den ersten Punkt auszuführen. Daher ziehe ich diese Implementierung vor. Die zweite, die dritte und die vierte Option gehen über den NNM hinaus, da sie während der allgemeinen Systemeinrichtung durchgeführt werden können. Für diesen Artikel habe ich alle diese Stufen zu einem Monoblock zusammengefasst, um den Prozess der allgemeinen Systemvorbereitung für die reale Arbeit besser zu verstehen.

Lassen Sie uns diese Optionen im Detail betrachten.

1. Online-Handel auf Demo- oder Realkonten

Wie wir sehen können, dauert das Hochfahren des Systems weniger als fünf Minuten.

Davor ist es notwendig, Excel zu konfigurieren. Der Zweck der Konfiguration besteht darin, sicherzustellen, dass die Daten von Skripten und Expert Advisors in einem numerischen Format geschrieben werden. Andernfalls liest Matlab diese Daten fehlerhaft. Legen Sie den Punkt als Trennzeichen zwischen den ganzzahligen und den reellen Zahlenteil fest. Dies kann direkt oder unter Verwendung des Systemtrennzeichens erfolgen.

3. Excel-Parameter

Erstellen Sie vor dem Erststart des NNM mit Hilfe des Expert Advisors eine Datei zum Herunterladen der Historie. Starten von ExpertMatlabPodkach_MT5.ex5 im Strategietester. 

   

4. Starten von ExpertMatlabPodkach_MT5.ex5

Wie Sie sehen, sollte die EA-Startzeit so gewählt werden, dass sie den Zeitraum von drei Tagen vor Betriebsbeginn abdeckt.

Als Ergebnis erhalten wir die Datei EURUSDTestPodkach.csv.

5. Die Datei EURUSDTestPodkach.csv

Öffnen Sie die Datei und bearbeiten Sie sie, indem Sie alle Zeilen mit Ausnahme der Daten bezüglich der Eröffnung der letzten Stunde am Tag vor dem Tag des Systemstarts löschen.

6. Löschen unnötiger Zeilen

Jetzt können wir ExpertMatlabReal_MT5.ex5 starten

#include<Trade\Trade.mqh>
//--- An object for performing trading operations
CTrade  trade;

input int LossBuy;
input int ProfitBuy;
input int LossSell;
input int ProfitSell;

int BarMax;
int BarMin;
int handleInput;
int handleInputPodkach;
int handleBar;
int Con;
int Bar;

double DibMax;
double DibMin;

double in[32];

int Order01;
int Order1;

ulong TicketBuy1;
ulong TicketSell0;

bool send1;
bool send0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   handleInputPodkach=FileOpen("EURUSDTestPodkach.csv",FILE_READ|FILE_CSV|FILE_ANSI|FILE_COMMON,";");
   if(handleInputPodkach==INVALID_HANDLE)
      Alert("No file EURUSDTestPodkach.csv");

   in[0]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[1]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[2]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[3]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[4]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[5]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[6]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[7]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[8]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[9]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[10]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[11]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[12]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[13]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[14]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[15]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[16]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[17]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[18]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[19]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[20]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[21]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[22]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[23]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[24]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[25]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[26]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[27]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[28]=1/StringToDouble(FileReadString(handleInputPodkach))-1;
   in[29]=1/StringToDouble(FileReadString(handleInputPodkach))-1;

   FileClose(handleInputPodkach);

//--- Setting MagicNumber to identify EA's orders
   int MagicNumber=123456;
   trade.SetExpertMagicNumber(MagicNumber);
//--- Setting allowable slippage in points for buying/selling
   int deviation=10;
   trade.SetDeviationInPoints(deviation);
//--- order filling mode, use the mode that is allowed by the server
   trade.SetTypeFilling(ORDER_FILLING_RETURN);
//--- The function to be used for trading: true - OrderSendAsync(), false - OrderSend()
   trade.SetAsyncMode(true);

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   FileClose(handleInput);
   FileClose(handleBar);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   MqlDateTime stm;
   TimeToStruct(TimeCurrent(),stm);

   if(stm.hour==1)
      DibMax=iHigh(NULL,PERIOD_H1,1);
   if(stm.hour>0)
     {
      if(iHigh(NULL,PERIOD_H1,1)>DibMax && iTime(NULL,PERIOD_H1,0)>1)
        {
         in[20]=iOpen(NULL,PERIOD_D1,0)-iLow(NULL,PERIOD_H1,1);
         in[21]=iHigh(NULL,PERIOD_H1,1)-iOpen(NULL,PERIOD_D1,0);
         in[22]=iHigh(NULL,PERIOD_D1,1)-iLow(NULL,PERIOD_D1,1);
         in[23]=iHigh(NULL,PERIOD_D1,1)-iOpen(NULL,PERIOD_H1,0);
         in[24]=iOpen(NULL,PERIOD_H1,0)-iLow(NULL,PERIOD_D1,1);
        }
     }
   if(iHigh(NULL,PERIOD_H1,1)>DibMax)
      DibMax=iHigh(NULL,PERIOD_H1,1);
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   if(stm.hour==1)
      DibMin=iLow(NULL,PERIOD_H1,1);
   if(stm.hour>0)
     {
      if(iLow(NULL,PERIOD_H1,1)<DibMin && iTime(NULL,PERIOD_H1,0)>1)
        {
         in[25]=iOpen(NULL,PERIOD_D1,0)-iLow(NULL,PERIOD_H1,1);
         in[26]=iHigh(NULL,PERIOD_H1,1)-iOpen(NULL,PERIOD_D1,0);
         in[27]=iHigh(NULL,PERIOD_D1,1)-iLow(NULL,PERIOD_D1,1);
         in[28]=iHigh(NULL,PERIOD_D1,1)-iOpen(NULL,PERIOD_H1,0);
         in[29]=iOpen(NULL,PERIOD_H1,0)-iLow(NULL,PERIOD_D1,1);
        }
     }
   if(iLow(NULL,PERIOD_H1,1)<DibMin)
      DibMin=iLow(NULL,PERIOD_H1,1);

   in[30]=iHigh(NULL,PERIOD_D1,1)-iOpen(NULL,PERIOD_H1,0);
   in[31]=iOpen(NULL,PERIOD_H1,0)-iLow(NULL,PERIOD_D1,1);

   if(Bar<Bars(NULL,PERIOD_H1)&& stm.hour==0)
     {
      for(int i=19; i>=10; i--)
        {
         in[i-10]=in[i];
        }

      for(int i=29; i>=20; i--)
        {
         in[i-10]=in[i];
        }
     }


   handleInput=FileOpen("Input_mat.txt",FILE_TXT|FILE_WRITE|FILE_ANSI|FILE_SHARE_READ|FILE_COMMON,";");

   FileWrite(handleInput,

             1/(in[0]+1),1/(in[1]+1),1/(in[2]+1),1/(in[3]+1),1/(in[4]+1),1/(in[5]+1),1/(in[6]+1),1/(in[7]+1),1/(in[8]+1),1/(in[9]+1),1/(in[10]+1),1/(in[11]+1),1/(in[12]+1),1/(in[13]+1),1/(in[14]+1),1/(in[15]+1),
             1/(in[16]+1),1/(in[17]+1),1/(in[18]+1),1/(in[19]+1),1/(in[20]+1),1/(in[21]+1),1/(in[22]+1),1/(in[23]+1),1/(in[24]+1),1/(in[25]+1),1/(in[26]+1),1/(in[27]+1),1/(in[28]+1),1/(in[29]+1),1/(in[30]+1),1/(in[31]+1));

   FileClose(handleInput);

   handleBar=FileOpen("Bar.txt",FILE_TXT|FILE_WRITE|FILE_ANSI|FILE_SHARE_READ|FILE_COMMON,";");

   FileWrite(handleBar,stm.hour);

   FileClose(handleBar);

   Order01=FileOpen("Open1.txt",FILE_CSV|FILE_READ|FILE_ANSI|FILE_SHARE_READ|FILE_COMMON," ");

   Order1=StringToInteger(FileReadString(Order01));
   
   FileClose(Order01);

   int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
   double PriceAsk=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double PriceBid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

   double SL1=NormalizeDouble(PriceBid-LossBuy*point,digits);
   double TP1=NormalizeDouble(PriceAsk+ProfitBuy*point,digits);
   double SL0=NormalizeDouble(PriceAsk+LossSell*point,digits);
   double TP0=NormalizeDouble(PriceBid-ProfitSell*point,digits);

   if(Bar<Bars(NULL,PERIOD_H1))
      Con=0;

   Comment(Order1,"  ",Con);

   if(LossBuy==0)
      SL1=0;

   if(ProfitBuy==0)
      TP1=0;

   if(LossSell==0)
      SL0=0;

   if(ProfitSell==0)
      TP0=0;

   if(Order1==0 && Bar<Bars(NULL,PERIOD_H1) && Con==0)
      send0=true;

   if(Order1==1 && Bar<Bars(NULL,PERIOD_H1) && Con==0)
      send1=true;


//---------Buy0

   if(send1==false  &&  Bar==Bars(NULL,PERIOD_H1) && Order1==1 && Con>=1 && iLow(NULL,PERIOD_H1,1)<iLow(NULL,PERIOD_H1,2) && stm.hour>15 && stm.hour<20)
     {
      send1=trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,1,PriceAsk,SL1,TP1);
      TicketBuy1 = trade.ResultDeal();
     }

   if(send1==true &&  Bar==Bars(NULL,PERIOD_H1) && Order1==0 && Con>=1 && iHigh(NULL,PERIOD_H1,1)>iHigh(NULL,PERIOD_H1,2))
     {
      trade.PositionClose(TicketBuy1);
      send1=false;
     }
//---------Sell0
   if(send0==false  &&  Bar==Bars(NULL,PERIOD_H1) && Order1==0 && Con>=1 && iHigh(NULL,PERIOD_H1,1)>iHigh(NULL,PERIOD_H1,2) && stm.hour>
        11 && stm.hour<14)
     {
      send0=trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,1,PriceBid,SL0,TP0);
      TicketSell0 = trade.ResultDeal();
     }

   if(send0==true &&  Bar==Bars(NULL,PERIOD_H1) && Order1==1 && Con>=1 && iLow(NULL,PERIOD_H1,1)<iLow(NULL,PERIOD_H1,2))
     {
      trade.PositionClose(TicketSell0);
      send0=false;
     }
//-----------------------------------------------------------------------
   Bar=Bars(NULL,PERIOD_H1);
   Con++;
  }
//------------------------------------------------------------------------

Was die Zeitbeschränkungen in dem für den Handel konzipierten EA betrifft, so ziehe ich es vor, sie nach der Optimierung direkt in den Code einzufügen. Ich tue dies, um das Risiko eines Fehlers zu minimieren, der bei externen Variablen auftreten könnte.

7. Starten von ExpertMatlabPodkach_MT5.ex5

Was den für die Optimierung konzipierten Expert Advisor betrifft, so sollten sie als externe Variablen angegeben werden.

7.1 Matlab_MT5.ex5

Wenn Sie vergessen, die Datei zum Herunterladen der Historie zu generieren, erhalten Sie eine Warnung, um zu verhindern, dass der EA falsche Signale erzeugt.

8. Warnung

Der EA schreibt zwei Dateien in den Ordner ...\Common\Files. Die Datei Input_mat.txt enthält Eingabedaten für den NNM.

9. Antwort des Expert Advisors

Starten des Moduls Neuronales Netz EURUSD_MT5.exe. Es erscheint der Arbeitsbereich.

10. NNM Arbeitsbereich

Die modifizierbaren Parameter der Blöcke Net2 und Net3 in dieser Programmvariante können nicht geändert werden.

Drücken Sie "Start" und wählen Sie die Datei net1.m (oder eine andere Datei des Neuronalen Netzes).

11. Drücken Sie "Start".

Sie haben vielleicht bemerkt, dass sich das Erscheinungsbild von NNM seit dem ersten Artikel etwas verändert hat. Seine funktionellen Fähigkeiten sind jedoch gleich geblieben.

Das Neuronale Netzwerk-Modul wird seine Arbeit aufnehmen.

12. NNM im Status des Handelns

Während der Operation des NNM können wir keinen seiner Parameter ändern.

In der linken oberen Ecke des Diagramms sind die Zahlen angegeben, die der Expertenberater vom NNM erhalten hat: 1,0, -1,0 und 0,0. Dies bedeutet, dass der EA ein Signal zum Kauf (Verkauf) erhalten hat. Von Net2 — bleiben Sie dem Markt fern. Von Net3 — ein Signal zum Kauf (Verkauf). Da diese Programmversion für Evaluierungszwecke gedacht ist, erhalten wir keine variablen Signale von Net1 und Net2.

In diesem Beispiel verwendet unser System die Signallinie der 5-Stunden-geglätteten NNM-Ergebnis. Um zu vermeiden, dass ein falsches Anfangssignal empfangen wird, muss das Modul fünf Stunden vor der Handelszeit gestartet werden, basierend auf den Bedingungen der Positionseröffnung. Die Zeit hängt vom Glättungsparameter ab.

Bitte beachten Sie, dass die Verwendung von History-Downloads, der Datenaustausch über eine Diskette und das Warten auf Daten mit der Notwendigkeit verbunden sind, die eingehenden Daten in beide Richtungen zu kontrollieren. Die Daten im NNM-Fenster, auf dem Diagramm und in den Dateien Open1,2,3 müssen identisch sein.

13. Informationskontrolle

Die Abbildung zeigt eine Variante des Neuronalen Netzwerkmoduls, das dem EA nur die Ergebnisse von Netz1, Netz2 und Netz3 übergibt. Die Bedingungen für die Positionseröffnung werden im Expert Advisor angegeben. Dies ist mein bevorzugter Weg. In unserem Fall liefert das NNM ein Bereitschaftssignal, und der EA handelt nur unter Zeitbeschränkung.

Eine solche Kontrolle ist besonders beim Debugging eines Systems nützlich. Außerdem ist es notwendig, die Leistung während der Tests und des Handels visuell zu kontrollieren.

14. NNM-Variante

Die obige Abbildung zeigt eine weitere Variante eines neuronalen Netzwerkmoduls. Bei dieser Variante sollten neuronale Netze besser direkt in die ausführbare Datei integriert werden. Wenn Sie auf die grüne Schaltfläche klicken, wählen Sie einfach die Datei Input_mat.txt aus. Ich würde empfehlen, ein ähnliches Modell für die Arbeit zu verwenden. Diese Variante hat nur einen Handelsblock, ohne Trainings- und Testblöcke. Vergessen Sie nicht, dass die scheinbare Komplexität der Systemvorbereitungsphase für maximale Einfachheit beim Handel sorgt. Die Hauptmarktanalyse wird in NNM durchgeführt - dieser Schritt erfolgt aufgrund der Verwendung neuronaler Netze sofort. Wenn Sie keine anderen Optimierungsbedingungen verwenden, muss der Handelsroboter nur zwei empfangene Ziffern interpretieren. 

 if(send1==false && Order1==1)
     {
      send1=trade.Buy(1);
      TicketBuy1 = trade.ResultDeal();
     }

 if(send1==true && Order1==0)
     {
      trade.PositionClose(TicketBuy1);
      send1=false;
     }

Abschließend möchte ich noch auf einige Unterschiede beim Start des ExpertMatlabReal_MT4.ex4 für die Arbeit im MetaTrader 4 Terminal eingehen. Dies hängt mit den spezifischen Eigenschaften von Strategietestern zusammen, nämlich mit der Art und Weise, wie sie Kontrollpunkte beim Testen bestimmen. In MetaTrader 5 endet der Test mit dem letzten Balken des Vortages. In MetaTrader 4 wird der aktuelle Balken verwendet. Deshalb habe ich in der EA für MetaTrader 4 die externe Variable "Hours" (Stunden) eingeführt.

14.1 Externe Variable "Hours".

Mit ExpertMatlabPodkach_MT4.ex4 erzeugen wir eine History-Download-Datei mit einer aktuellen Balkenzeile, weshalb der aktuelle Zeitbalken beim ersten Start in der Variable "Hours" angegeben werden sollte. Nach dem Start des EAs öffnen Sie dessen Eigenschaften und setzen Sie die Variable wieder auf 0. Dadurch wird sichergestellt, dass weitere Datenverschiebungen um 00:00 Uhr durchgeführt werden.

14.2 Hours-0

2. NNM-Test im visuellen Modus

Dieser Test schließt die Vorbereitung ab. Das Modul Neuronale Netze wird uns also das gewünschte Ergebnis liefern, entsprechend der Vorbereitung, dem Training des neuronalen Netzes, der erhaltenen Ergebnismenge, der Visualisierung der Ergebnisse und der weiteren Optimierung. Nun wiederholen wir die Aktionen von Punkt 1, d.h. wir starten NNM wie für den Handel. Starten Sie außerdem ExpertMatlabReal_MT5.ex5 im Strategietester unter Verwendung der Visualisierung. Aktivieren Sie den Modus "1 Minute OHLC" in MetaTrader 5. Aktivieren Sie in MetaTrader 4 "Kontrollpunkte". Diese Modelle sollten verwendet werden, um verlässliche Testergebnisse zu erhalten, da die Geschäfte bei Verwendung des NNM auf dem Tick nach der Eröffnung des Balkens ausgeführt werden. Wenn wir das Modell "Nur Öffnungspreise" verwenden, wird die Positionseröffnung während des Tests um einen Balken verzögert. In diesem Modus kann die Ergebnisverzögerung mit Hilfe des Moduls EURUSD_MT5var.exe leicht berücksichtigt werden. Im realen Handel wird dies natürlich nicht passieren. Im Allgemeinen zeigt dieses System fast identische Ergebnisse für alle Arten von Tests. Dies ist eine weitere Bestätigung seiner Funktionsfähigkeit.

15. Visueller Mode

3. Trainieren der Neuronalen Netze

Dieser Modus des Neuronalen Netzwerkmoduls in der bereitgestellten Version dient zur Demonstration des Trainingsprozesses für neuronale Netzwerke sowie zur Vorbereitung auf die reale Arbeit. Es handelt sich um ein Demonstrationsmodell, da diese neuronalen Netze nicht neu-trainiert werden können, da das Modul bereits trainierte neuronale Netze verwendet. Es besteht keine Notwendigkeit, ein solches Untermodul zu Ihrem Arbeitsprogramm hinzuzufügen, da das Training im Offline-Modus durchgeführt wird und die effizienteste und zuverlässigste Art und Weise ist, das neuronale Netz direkt in der MATLAB-Umgebung zu trainieren.

 Um zwei neuronale Netze für das Submodul Net1 zu testen, benötigen wir die neuronalen Netze net1-2 und die Datei EURUSDData.csv mit Trainingsdaten im Verzeichnis ...\Common\Files.

16. Datendatei

Die Trainingsdaten sind real - dies sind die Daten, die zur Vorbereitung des Handelssystems mit Hilfe des Online-Blocks verwendet werden. Ich möchte noch einmal auf den Vorteil der Verwendung neuronaler Netze zur Beurteilung der Marktsituation hinweisen. Die Tabelle EURUSDData.csv hat 90 Spalten, die einen Satz von sequentiellen Werten darstellen, die als Eingabedaten für das neuronale Netz verwendet werden. Einfach ausgedrückt sind dies die Eingaben. Stellen Sie sich vor, dass jede Spalte ein separater Indikator ist, der vom Expertenberater vorläufig berechnet und dann als Daten für das Training des neuronalen Netzes extrahiert wird. All dies geschieht im Offline-Modus, wenn das System vorbereitet wird. Nun stellen Sie sich vor, dass wir versuchen würden, diesen beeindruckenden Datensatz während des Handels direkt in einem funktionierenden Expert Advisor zu analysieren.

Als ich diesen Artikel schrieb, habe ich die Namen der Schaltflächen zum besseren Verständnis der Reihenfolge der Aktionen umbenannt.

17. Aktualisierte Namen der Schaltflächen

Wir drücken "Train net1", öffnen die Datei net1.mat und trainieren zwei Netze, net1 und net2, für den Net1-Block. Und so weiter: Netz3,4 für Netz2 und Netz5,6 für Netz3.

18. Trainieren von net1

Auch hier ist es am bequemsten, die Programmverknüpfung in den Ordner zu legen, in dem sich die Arbeitsdateien befinden, und den Pfad in seinen Eigenschaften in "Arbeitsordner" zu ändern. Als Nächstes wird NNM die Netzwerke trainieren.

4. Empfangen von Ergebnissen von Blöcken neuronaler Netze zur Optimierung einer Handelsstrategie

Im Modul für neuronale Netzwerke habe ich die Möglichkeit hinzugefügt, neuronale Netzwerke im Offline-Modus zu testen. Mit anderen Worten, es handelt sich um die Möglichkeit, Ergebnisse neuronaler Netze auf der Grundlage historischer Daten zu erhalten, um einen Signalindikator zu schaffen, der es erlaubt, das System zu optimieren. Hier ist ein Beispiel für die von Net1 erhaltenen Ergebnisse.

Bereiten Sie zunächst die Datei EURUSDTestPodkach_MT5.csv im Ordner ...\AppData\Roaming\MetaQuotes\Terminal\Common\Files vor. Starten Sie dazu den EA ExpertMatlabPodkach_MT5 im Strategietester. Dieser sollte mit dem Datum vor dem Startdatum des Tests beginnen (bitte stellen Sie sicher, dass das erforderliche Ausmaß der Historie heruntergeladen wird).

Zum Beispiel:

19. Starten von ExpertMatlabPodkach_MT5.ex5

Löschen Sie alle Zeilen außer einer in der Ergebnisdatei.

20. Die einzige, übriggebliebene Zeile

Um eine Datei mit den Daten des Testzeitraums zu erzeugen, starten Sie ExpertMatlab_MT5.ex5 im Strategietester.

21. Start von ExpertMatlab_MT5.ex5

Achten Sie darauf, wie die Daten des Zeitraumes ausgewählt wurden.

22. Wir erhalten EURUSDTest.csv und EURUSDDate.csv

ExpertMatlab_MT5.ex5 wird zwei Testdateien EURUSDDate.csv und EURUSDTest.csv erzeugen. Starten Sie das neuronale Netzwerkmodul, klicken Sie auf "Testnetz1" und wählen Sie net1.mat.

23. Drücken Sie "Test net1"

Warten Sie etwas bis die Datei Indicator1.csv erstellt ist.

24. Die Datei Indicator1.csv mit den Ergebnisse wird generiert

Sichern Sie Indicator1 als Indikator. Wenn der Block des neuronalen Netzes "Indikator1.csv" im "Compatibility mode" gespeichert hat, sollten Sie ihn im csv-Format über die Registerkarte "Sichern als" speichern.

25. Indicator1.csv als Indicator.csv speichern

Lassen Sie uns die Ergebnisse des NNM im visuellen Modus auf dem Chart von EURUSD H1 überprüfen. Verwenden Sie dazu den Indikator NWI.ex5.

26. Start des Indikators NWI.ex5

Die standardmäßige Periodenlänge beträgt 5. Nach meinen Versuchen liefert dieser Periodenwert für die Signallinie das beste Ergebnis für EURUSD H1. Sie können jedoch versuchen, Ihren eigenen Wert zu finden.

27. NWI Visualisierung

Mit Matlab_MT5.ex5 können wir die erhaltenen Ergebnisse testen und weiter optimieren.

#include<Trade\Trade.mqh>

CTrade  trade;

input int Period=5;
input int H1;
input int H2;
input int H3;
input int H4;

input int LossBuy;
input int ProfitBuy;
input int LossSell;
input int ProfitSell;

ulong TicketBuy1;
ulong TicketSell0;

datetime Count;

double Per;
double Buf_0[];
double Buf_1[];

bool send1;
bool send0;

int h=4;
int k;
int K;
int bars;
int Handle;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   Handle=FileOpen("Indicator.csv",FILE_CSV|FILE_SHARE_READ|FILE_ANSI|FILE_COMMON,";");

   while(!FileIsEnding(Handle)&& !IsStopped())
     {
      StringToTime(FileReadString(Handle));
      bars++;
     }
   FileClose(Handle);

   ArrayResize(Buf_0,bars);
   ArrayResize(Buf_1,bars);

   Handle=FileOpen("Indicator.csv",FILE_CSV|FILE_SHARE_READ|FILE_ANSI|FILE_COMMON,";");

   while(!FileIsEnding(Handle)&& !IsStopped())
     {
      Count=StringToTime(FileReadString(Handle));
      Buf_0[k]=StringToDouble(FileReadString(Handle));
      h=Период-1;
      if(k>=h)
        {
         while(h>=0)
           {
            Buf_1[k]=Buf_1[k]+Buf_0[k-h];
            h--;
           }
         Buf_1[k]=Buf_1[k]/Period;
        }
      k++;
     }
   FileClose(Handle);

   int deviation=10;
   trade.SetDeviationInPoints(deviation);
   trade.SetTypeFilling(ORDER_FILLING_RETURN);
   trade.SetAsyncMode(true);

//---
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   MqlDateTime stm;
   TimeToStruct(TimeCurrent(),stm);

   int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
   double PriceAsk=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double PriceBid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

   double SL1=NormalizeDouble(PriceBid-LossBuy*point,digits);
   double TP1=NormalizeDouble(PriceAsk+ProfitBuy*point,digits);
   double SL0=NormalizeDouble(PriceAsk+LossSell*point,digits);
   double TP0=NormalizeDouble(PriceBid-ProfitSell*point,digits);

   if(LossBuy==0)
      SL1=0;

   if(ProfitBuy==0)
      TP1=0;

   if(LossSell==0)
      SL0=0;

   if(ProfitSell==0)
      TP0=0;

//---------Buy1
   if(send1==false && K>0 && Buf_0[K-1]<Buf_1[K-1] && Buf_0[K]>Buf_1[K] && iLow(NULL,PERIOD_H1,1)<iLow(NULL,PERIOD_H1,2) && stm.hour>H1 && stm.hour<H2 && H1<H2)
     {
      send1=trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,1,PriceAsk,SL1,TP1);
      TicketBuy1 = trade.ResultDeal();
     }

   if(send1==true && K>0 && Buf_0[K-1]>Buf_1[K-1] && Buf_0[K]<Buf_1[K] && iHigh(NULL,PERIOD_H1,1)>iHigh(NULL,PERIOD_H1,2))
     {
      trade.PositionClose(TicketBuy1);
      send1=false;
     }

//---------Sell0

   if(send0==false && K>0 && Buf_0[K-1]>Buf_1[K-1] && Buf_0[K]<Buf_1[K] && iHigh(NULL,PERIOD_H1,1)>iHigh(NULL,PERIOD_H1,2) && stm.hour>H3 && stm.hour<H4 && H3<H4)
     {
      send0=trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,1,PriceBid,SL0,TP0);
      TicketSell0 = trade.ResultDeal();
     }

   if(send0==true && K>0 && Buf_0[K-1]<Buf_1[K-1] && Buf_0[K]>Buf_1[K] && iLow(NULL,PERIOD_H1,1)<iLow(NULL,PERIOD_H1,2))
     {
      trade.PositionClose(TicketSell0);
      send0=false;
     }
   K++;
  }

//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
//---
   double ret=0.0;
//---

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

28. Starten Sie Matlab_MT5.ex5

29. Saldo

Es macht keinen Sinn, einen Vorwärtstest durchzuführen. Nach einem Backtest beginnt ein Forward-Test mit dem nächsten Datum, jedoch wird die Datei mit dem Startdatum geladen, mit dem der Backtest begonnen hat. Daher werden die Ergebnisse nicht korrekt sein.

Lassen Sie uns eine Optimierung durchführen. Der vorherige Test wurde ohne einschränkende Stufen und nach dem im Buch beschriebenen Prinzip der Systemvorbereitung durchgeführt. Es wurden weitere Stufen zur Optimierung eingeführt.

30. Durchführung einer Optimierung

Optimierungszeitraum ist 2011-2013, vor der roten Linie. Danach wird der Zeitraum von 2013-2016 für Tests genutzt. Natürlich würde in der Praxis niemand für eine solche Verweildauer nach der Optimierung handeln, da neuronale Netze von Zeit zu Zeit neu trainiert werden müssen. Aus meiner Praxis heraus sollten die Tests innerhalb eines Monats durchgeführt werden. In der Grafik beträgt der Zeitraum zwischen der roten und der blauen Linie 4 Monate.

Lassen Sie uns diesen Zeitraum separat testen.

31. Referenztest

Ich hatte diese Tests zuvor noch nicht durchgeführt, also geschah all dies im Laufe des Schreibens dieses Abschnitts des Artikels. Natürlich können auch andere Optionen verwendet werden. Und es ist auch notwendig, die Absicherung neuronaler Netze vorzubereiten. Ich möchte nur hervorheben, wie sehr neuronale Netze die Vorbereitung des Systems und den Handelsprozess vereinfachen.

Wir können sagen, dass die bei diesem Test nachgebildeten Handelsgeschäfte ideale Bedingungen hatten. Deshalb werden wir das Ergebnis dieses Tests als Referenz nehmen.

5. Fehlerkorrektur

Während ich mit diesem Teil arbeitete, beschloss ich, zum Anfang zurückzukehren und zu erklären, warum dieser Teil so umfangreich ist. Tatsache ist, dass die "Correction of errors" (Fehlerkorrektur) in Echtzeit durchgeführt wurde, während ich diesen Artikelabschnitt schrieb. Dies betrifft auch den vorhergehenden Abschnitt. Für MetaTrader 4 war alles vorbereitet, aber für MetaTrader 5 musste ich im Echtzeitmodus arbeiten. Dies war eine sehr nützliche Erfahrung für mich. Wie auch immer, bitte beachten Sie, dass der Vorbereitungsschritt extrem wichtig ist und Sie daher sehr vorsichtig sein sollten.

Es ist notwendig, zu Punkt 2 zurückzukehren und das Ergebnis (das wir eine Referenz genannt haben) im Visualisierungsmodus zu testen.

Hier ist, was wir haben.

32. Fehlgeschlagene Tests

Obwohl das Ergebnis positiv ist, ist es völlig anders als das vorherige. Das bedeutet, dass es einen Fehler im Programmcode gibt, den wir finden müssen. Die nützliche Funktion besteht darin, daß wir alle Datenübertragungsschritte zurückverfolgen können.

Vergleichen wir die Ergebnisse in den Ausgabefeldern (4) des Net1-Untermoduls und die NNM-Ergebnisse, die wir mit dem ExpertMtatlab_MT5.ex5 EA erhalten haben. Verwenden Sie den gleichen Balken.

33. Vergleich der Ergebnisse

Wie Sie sehen können, stimmen die Ergebnisse des Net1-Submoduls und die Ergebnisse des NNM nicht überein. Da wir den gleichen Block neuronaler Netze verwenden, können wir daraus schließen, dass die Dateneingabe während dieser beiden Tests unterschiedlich ist. 

Vergleichen Sie die Daten in den Dateien EURUSDTest.csv und Input_mat.txt, indem Sie einen beliebigen Balken auswählen.

34. Vergleich bei passenden Daten

Wir haben recht, die Daten sind wirklich unterschiedlich Überprüfen wir also den Programmcode von ExpertMtatlab_MT5.ex5 und ExpertMatlabReal_MT5.ex5. 

ExpertMtatlab_MT5.ex5
if(stm.hour==0)
     {
      for(int i=19; i>=10; i--)
        {
         in[i-10]=in[i];
        }

      for(int i=29; i>=20; i--)
        {
         in[i-10]=in[i];
        }
     }
ExpertMatlabReal_MT5.ex5
if(Bar<Bars(NULL,PERIOD_H1) && stm.hour==0)
     {
      for(int i=19; i>=10; i--)
        {
         in[i-10]=in[i];
        }

      for(int i=29; i>=20; i--)
        {
         in[i-10]=in[i];
        }
     }

Es wurde ein Fehler im Code ExpertMatlabReal_MT5.ex5 gefunden. Die Datei enthielt nicht die Hauptbedingung für die Datumsumstellung um 00 Uhr. In der realen Arbeit würde unser NNM vom Terminal die Informationen erhalten, die nicht mit den Informationen übereinstimmen, die die Netzwerke erhalten sollten. Dies würde zu "falschen Ergebnissen" führen. Ich habe die Anführungszeichen gesetzt, weil das neuronale Netz in der Tat eine normale Ergebnis erzeugt, aber sie wird für uns falsch sein, da wir dem Netz falsche Informationen zur Verfügung gestellt haben.

Vergleichen wir nochmals die Ergebnisse in den Ausgabefeldern (4) des Net1-Untermoduls und die NNM-Ergebnisse, die wir mit dem ExpertMtatlab_MT5.ex5 EA erhalten haben. 

35. Vergleich der Ergebnisse

Jetzt sehen wir, dass die in den NNM eingegebenen Informationen korrekt sind.

Testen Sie noch einmal im visuellen Modus, nachdem Sie den Fehler behoben haben.

36. Der Test unterscheidet sich von der Referenz

Auch wenn das Ergebnis etwas näher liegt, so ist es doch deutlich anders. Außerdem endete das Modul des neuronalen Netzes von selbst.

Nach der Überprüfung wurde ein Fehler in der Bedingung für das Schließen eine Verkaufsposition in ExpertMatlabReal_MT5.mq5 gefunden. Testen Sie noch einmal in 1 Minute OHLC, im Visualisierungsmodus.

37. Test, ohne auf Ticks zu warten

Das Ergebnis stimmt nicht mit dem Referenzwert überein.

38. Reference

Nach der Analyse können wir zu dem Schluss kommen, dass dies das Ergebnis eines emulierten Handels unter ungünstigen Bedingungen ist. Dies hat zu einer größeren Anzahl von falschen Signalen und unnötigen Handelsgeschäften geführt. Eine solche Situation tritt auf, wenn ein Signal zur Eröffnung einer Position auf dem vorherigen Barren und ein Signal zur Eröffnung eines entgegengesetzten Handels oder zum Ausbleiben aus dem Markt auf dem nächsten Barren auftaucht. Da das Testen in einem beschleunigten Modus durchgeführt wird, können Informationen aus dem NNM verspätet eintreffen, so dass der EA einen Handel auf der Grundlage des vorherigen Signals durchführen kann. Aber in diesem Fall sind solche Tests nützlich, da sie uns die Möglichkeit geben, zu sehen, wie sich das System unter ungünstigen Marktbedingungen verhalten würde.

Lassen Sie uns das Ergebnis sehen, nachdem wir die EA-Positionseröffnungsbeschränkungen für die oben beschriebenen Situationen hinzugefügt haben.

 if(Order1==0 && Bar<Bars(NULL,PERIOD_H1) && Con==0)
      send0=true;
   
 if(Order1==1 && Bar<Bars(NULL,PERIOD_H1) && Con==0)
      send1=true;

//---------Buy

Der Test wird unter Verwendung der Ticks und mit der höchsten Visualisierungsgeschwindigkeit durchgeführt. Sie können sich den Prozess im Video ansehen.

39. Das Ergebnis ist nahe an der Referenz

Wie Sie sehen, liegt das Ergebnis nahe an der Referenz. Obwohl ich denke, dass auch der vorherige Test nahe an der Referenz liegen würde, wenn wir die Testgeschwindigkeit reduzieren würden. Versuchen Sie es selbst.

Lassen Sie uns nun herausfinden, warum der NNM sich beendete. Ich könnte diesen Teil überspringen. Aber es ist gut, dass wir diesen Fehler im Testmodus gefunden haben. Es wäre viel schlimmer, wenn das Problem während des realen Handels entdeckt würde. Wenn die neuronalen Netze im NNM untrainiert sind oder wenn wir das Modul vor dem Start des EA-Handels starten, wird die Datei Input_mat.txt bis dahin nicht generiert worden sein, und das NNM wird keine Ergebnisse liefern, nachdem wir auf "Start" geklickt haben. Ursprünglich fügte ich das Warnfenster und einen erzwungenen Ausgang des internen Zeitgebers hinzu. Ich habe diesen logischen Fehler entfernt, aber die Warnung belassen. Wenn das Fenster jedoch während der Arbeit auftaucht, sollten Sie einfach auf "OK" klicken, um das Fenster auszublenden. Das Programm arbeitet dann weiter.

40. Fehler-Fenster

Es gibt ein weiteres Problem, auf das Sie achten sollten. Wenn wir in MetaTrader 5 Daten mit Hilfe der Strategiedaten schreiben, ist die Anzahl der erzeugten Balken größer als im Chart angezeigt wird. Aus diesem Grund ist der resultierende Indikator etwas "länger". Dies hat jedoch keinen Einfluss auf die Qualität der Tests. Der zusätzliche Balken wird in einem Testdurchlauf berücksichtigt, aber er wird nicht im Diagramm angezeigt. Dies kann in einem Schritt-für-Schritt-Durchlauf überprüft werden.

41. Der Indikator im MetaTrader 5

42. Es gibt eine Zeitverschiebung

Das Problem existiert nicht im MetaTrader 4.

43. Indikator 1_MT4 im MetaTrader 4

44. Keine Verschiebung

Die Figur unten zeigt, warum das passiert.

45. Der Grund für die Verschiebung

Schlussfolgerung

Was ist der Zweck des Einsatzes neuronaler Netze?

1. Neuronale Netze ermöglichen die Verarbeitung einer beträchtlichen Menge an Informationen außerhalb des Marktes.
2. Da die Informationen im Offline-Modus verarbeitet werden, können wir dem Markt vorausgehen, anstatt ihm hinterherzulaufen. Oder zumindest können wir mit dem Markt Schritt halten.
3. Infolgedessen ermöglichen neuronale Netze eine rechtzeitige Reaktion auf Veränderungen der Marktsituation, nicht nur während des Handels, sondern sogar in der Vorbereitungsphase. So können wir große Verluste im Falle einer Trendwende oder wenn andere Faktoren den Markt beeinflussen, eliminieren.
4. Was das im Artikel vorgestellte spezifische neuronale Netz und seine Trainingsmethode anbelangt, so besteht der unbestreitbare Vorteil dieser Kombination darin, dass wir die EA anhand der in der Zeit, in der das neuronale Netz trainiert wurde, erhaltenen Ergebnisse optimieren können. Neuronale Netze, die auf anderen Architekturen basieren, können im Trainingsmodus gute Ergebnisse zeigen, während sie in einer Testperiode deutlich andere Ergebnisse aufweisen. In unseren Fällen sind die Ergebnisse ungefähr gleich. Dies ermöglicht es uns, das NN in der Nähe des aktuellen Datums zu testen und die Marktfaktoren zu berücksichtigen, die in der Geschichte verfügbar sind. Dieser Teil wird in dem Artikel nicht behandelt, aber Sie können ihn selbst erforschen.

Als ich diesen Artikel schrieb, wollte ich zunächst nur die Neuronalen Netze Net1 in das NNM integrieren, die bis zum Zeitpunkt der Veröffentlichung des Artikels trainiert worden sind. Nach Fertigstellung beschloss ich jedoch, die bis zum 31.12.2019 trainierten neuronalen Netze für Net2 zu integrieren. Sowie Daten bis zum 31.12.2010 für Net3. Es ist interessant, sie unter den aktuellen Marktbedingungen zu testen. Für alle anderen Arbeiten innerhalb des NNM werden nur neuronale Netze für Net1 verwendet.

Nachdem Sie die Dateien heruntergeladen haben

Ich entschuldige mich für das lange Video, der Prozess wurde praktisch in einer Aufnahme gefilmt.

Python