Praktische Anwendung von Neuronalen Netzen im Handel (Teil 2). Computerbilder

Andrey Dibrov | 10 März, 2021

Einführung

Ein wesentliches Problem bei der Vorbereitung der Daten für das Training der Neuronalen Netze, die für den Handel bestimmt sind, ist mit der Vorbereitung der notwendigen Eingangsdaten verbunden. Betrachten wir zum Beispiel den Fall, dass wir ein Dutzend Indikatoren verwenden. Diese Indikatoren können einen Satz von mehreren informativen Charts darstellen. Wenn wir diese Indikatoren bis zu einer gewissen Tiefe berechnen, dann erhalten wir als Ergebnis bis zu hundert Einträge, und in manchen Fällen sogar mehr. Können wir das Training von Neuronalen Netzwerken durch den Einsatz von Computerbilder vereinfachen? Um dieses Problem zu lösen, sollten wir Convolutional Neuronale Netzwerke verwenden, die oft zur Lösung von Klassifizierungs- und Erkennungsproblemen eingesetzt werden.

Architektur eines Convolutional Neuronalen Netzwerks

In diesem Artikel wird ein Convolutional Neuronales Netzwerk verwendet. Seine Architektur ist in der folgenden Abbildung dargestellt. Dieses Schema zeigt das allgemeine Prinzip zur Konstruktion eines Convolutional Neural Network (CNN). 

In diesem Fall haben wir:

1. CNN-Eingabe, die ein Bild der Größe 449x449 Pixel ist.
2. Die erste Convolutional-Schicht aus 96 Merkmalskarten (maps). Jede Karte ist ein Bild der Größe 447x447. Convolutional-Kernel 3x3.
3. Subsample-Schicht von 96 Merkmalskarten mit einer Größe von 223x223, mit einem Kernel 2x2.
4. Zweite Convolutional-Schicht mit 32 Merkmalskarten. Jede Karte ist ein Bild der Größe 221x221. Convolutional-Kernel 3x3.
5. Subsample-Schicht von 32 Merkmalskarten mit einer Größe von 110x110, mit einem Kernel 2x2.
6. Dritte Convolutional-Schicht mit 16 Merkmalskarten. Jede Karte ist ein Bild der Größe 108x108. Convolutional-Kernel 3x3.
7. Subsample-Schicht von 16 Merkmalskarten mit einer Größe von 54x54, mit einem Kernel 2x2. In der Abbildung nicht dargestellt.
8. Vollverknüpfte Schicht mit 64 Neuronen.
9. Ausgangsschicht aus einem Neuron. Diese beiden Schichten stellen die Klassifikationseinheit dar.

Wenn Sie neu im Bereich der Convolutional Neuronalen Netze sind, machen Sie sich keine Sorgen über die scheinbare Schwerfälligkeit und Komplexität der Konstruktion. Ein Neuronales Netz einer bestimmten Architektur wird automatisch aufgebaut. Sie müssen nur die wichtigsten Parameter einstellen. 

Vorbereiten eines Arrays von Bildern für das Training und Testen eines Neuronalen Netzwerks

Bevor Sie ein Array von Bildern vorbereiten, definieren Sie den Zweck Ihres Neuronalen Netzwerks. Ideal wäre es, das Netzwerk auf Pivots zu trainieren. Diesem Zweck entsprechend müssten wir Screenshots mit dem letzten extremen Balken erstellen. Dieses Experiment hat jedoch keinen praktischen Wert. Deshalb werden wir einen anderen Satz von Bildern verwenden. Weiterhin können Sie mit verschiedenen Arrays experimentieren, auch mit dem oben genannten. Dies kann auch zusätzliche Beweise für die Effizienz von Neuronalen Netzwerken bei der Lösung von bildbasierten Klassifizierungsaufgaben liefern. Die Antworten des Neuronalen Netzes, die auf eine kontinuierliche Zeitreihe erhalten werden, erfordern eine zusätzliche Optimierung. 

Lassen Sie uns das Experiment nicht verkomplizieren und uns auf zwei Kategorien von Bildern konzentrieren:

• Kaufen - wenn der Preis sich nach oben bewegt oder wenn der Preis das Tagestief erreicht hat
• Verkaufen - wenn sich der Preis nach unten bewegt oder wenn der Preis das Tageshoch erreicht hat

Zu Trainingszwecken des Neuronalen Netzes wird die Bewegung in eine beliebige Richtung als das Erreichen neuer Extremwerte in Trendrichtung durch den Preis bestimmt. Zu diesen Momenten werden Chart-Screenshots erstellt. Der Moment der Trendumkehr ist ebenfalls wichtig für das Training des Netzwerks. Ein Chart-Screenshot wird auch erstellt, wenn der Preis das Tageshoch oder -tief erreicht.

Bevor wir mit der Arbeit beginnen, müssen wir das Aussehen des Charts vorbereiten. Verwenden Sie die Vorlage CNN.tpl. Speichern Sie sie in \AppData\Roaming\MetaQuotes\Terminal\D0E8209F77C8CF37AD8BF550E51FF075\MQL5\Profiles\Templates.

Definieren Sie den Text in den Diagrammeigenschaften als "Weiß".

Sie können auch beliebige andere Indikatoren anhängen. Ich habe diese Indikatoren willkürlich gewählt. Es ist auch empfehlenswert, eine optimale Chartgröße entsprechend Ihrer Hardwarefähigkeiten zu finden.

Verwenden Sie das folgende Skript zum Erstellen eines Arrays von Bildern.

//+------------------------------------------------------------------+
//|                                                        CNNet.mq5 |
//|                                   Copyright 2021, Andrey Dibrov. |
//|                           https://www.mql5.com/en/users/tomcat66 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, Andrey Dibrov."
#property link      "https://www.mql5.com/en/users/tomcat66"
#property version   "1.00"
#property strict
#property script_show_inputs

input string Date="2017.01.02 00:00";
input string DateOut="2018.12.13 23:00";
input string DateTest="2019.01.02 00:00";
input string Dataset="Train";

string Date1;
int count,countB,countS;
int day;
double DibMin;
double DibMax;
int HandleDate;
long WIDTH;
long HEIGHT;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   MqlDateTime stm;
   ChartSetInteger(0,CHART_SHIFT,false);
   ChartSetInteger(0,CHART_AUTOSCROLL,false);
   ChartSetInteger(0,CHART_SHOW_OBJECT_DESCR,false);
   WIDTH=ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ChartSetInteger(0,CHART_SHOW_PRICE_SCALE,false);

   if(Dataset=="Test")
     {
      HandleDate=FileOpen(Symbol()+"Date.csv",FILE_CSV|FILE_READ|FILE_WRITE|FILE_ANSI,";");
      ChartNavigate(0,CHART_END,-(iBarShift(NULL,PERIOD_H1,StringToTime(DateTest))));
      Sleep(1000);

      for(int i=iBarShift(NULL,PERIOD_H1,StringToTime(DateTest)); i>0; i--)
        {
         Date1=TimeToString(iTime(NULL,PERIOD_H1,i));
         if(DateTest<=Date1)
           {
            if(ChartNavigate(0,CHART_END,-i))
              {
               Sleep(20);
               if(ChartScreenShot(0, (string)count + ".png", (int)WIDTH, (int)WIDTH, ALIGN_LEFT))
                 {
                  FileWrite(HandleDate,TimeToString(iTime(NULL,PERIOD_H1,i)));
                  count++;
                  Sleep(20);
                 }
              }
           }
        }
     }
   if(Dataset=="Train")
     {
      ChartNavigate(0,CHART_END,-iBarShift(NULL,PERIOD_H1,StringToTime(Date)));
      Sleep(1000);
      for(int i=iBarShift(NULL,PERIOD_H1,StringToTime(Date)); i>=iBarShift(NULL,PERIOD_H1,StringToTime(DateOut)); i--)
        {
         TimeToStruct(iTime(NULL,PERIOD_H1,i),stm);
         Date1=TimeToString(iTime(NULL,PERIOD_H1,i));
         if(DateOut>=Date1 && Date<=Date1)
           {
            if(ChartNavigate(0,CHART_END,-i))
              {
               Sleep(20);
               if(day != stm.day)
                 {
                  FileCopy("Sell" + (string)countS + ".png", 0, "Buy" + (string)(countB+1) + ".png", FILE_REWRITE);
                  FileDelete("Sell" + (string)countS + ".png", 0);
                  FileCopy("Buy" + (string)countB + ".png", 0, "Sell" + (string)(countS+1) + ".png", FILE_REWRITE);
                  FileDelete("Buy" + (string)countB + ".png", 0);
                  countB ++;
                  countS ++;
                 }
               day = stm.day;
               if(stm.hour == 0)
                 {
                  DibMin = iOpen(NULL, PERIOD_H1, i);
                  DibMax = iOpen(NULL, PERIOD_H1, i);
                 }
               if(iLow(NULL, PERIOD_H1, i+1) < DibMin)
                 {
                  DibMin = iLow(NULL, PERIOD_H1, i+1);
                  countS ++;
                  ChartScreenShot(0, "Sell" + (string)countS + ".png", (int)WIDTH, (int)WIDTH, ALIGN_LEFT);
                 }
               if(iHigh(NULL, PERIOD_H1, i+1) > DibMax)
                 {
                  DibMax = iHigh(NULL, PERIOD_H1, i+1);
                  countB ++;
                  ChartScreenShot(0, "Buy"  +(string)countB + ".png", (int)WIDTH, (int)WIDTH, ALIGN_LEFT);
                 }
               Sleep(20);
              }
           }
         else
            break;
        }
     }
  }

Das Skript arbeitet in zwei Modi: "Train" - erstellt ein Array von Bildern für das Training, und "Test" - erstellt ein Array von Bildern für den Erhalt von Antworten des Neuronalen Netzes, auf deren Basis ein Indikator generiert wird. Dieser Indikator wird dann für die Optimierung der Handelsstrategie verwendet. 

Lassen Sie das Skript im Modus "Train" laufen.

Variable "Date" — Anfangsdaten für die Stichprobe, in der Bilder für das Training ausgewählt werden. "DateOut" — das Enddatum des Stichprobenzeitraums, in dem Bilder für das Training ausgewählt werden. "DateTest" — das Startdatum für die Auswahl von Bildern, um stündliche Antworten des Neuronalen Netzes zu erhalten. Das Enddatum ist die Startstunde des Skripts. 

Eine Reihe von Kauf- (Buy..) und Verkaufsbildern (Sell..) wird im Ordner ...\MQL5\Files des Datenverzeichnisses gespeichert. Die Gesamtzahl der Bilder beträgt 6125.

Bereiten Sie als Nächstes Verzeichnisse für das Trainings-, Validierungs- und Testset vor. Legen Sie der Einfachheit halber den Ordner "CNN" auf dem Desktop an, und erstellen Sie darin drei Ordner - "Train", "Val", "Test".

Erstellen Sie in den Verzeichnissen "Train" und "Val" die Unterverzeichnisse "Buy" und "Sell". Legen Sie in "Test" das Unterverzeichnis "Resp" an.

Schneiden Sie aus dem Ordner ...\MQL5\Files alle Dateien "Buy..." aus und fügen Sie sie in ...\Train\Buy ein. Es sind 3139 Bilder. Wiederholen Sie das Gleiche für "Sell..." und fügen Sie sie in ...\Train\Sell ein. Hier sind es 2986 Bilder. Verschieben Sie aus den Ordnern "Buy" und "Sell" 30 % der letzten (mit den höchsten Zahlen) Bilder in die entsprechenden Unterordner unter "Val" ein.

Was wir jetzt haben 

• ...\Train\Buy - 2198 Bilder 
• ...\Val\Buy   - 941   Bilder
• ...\Train\Sell - 2091 Bilder
• ...\Val\Sell   - 895   Bilder
  

Training des Neuronalen Netzes

Wir werden mit Convolutional Netzen unter Verwendung der Anaconda-Umgebung arbeiten. Sie sollte so konfiguriert sein, dass sie mit CPU und GPU (wenn Sie eine NVIDIA-Grafikkarte haben) arbeitet. Diese Grafikkarte wird benötigt, um den Lernprozess zu beschleunigen. Sie bringt zwar einige Einschränkungen bei der Erstellung der Architektur des Neuronalen Netzes mit sich - Abhängigkeit von der Größe des Arbeitsspeichers der Grafikkarte. Aber die Lerngeschwindigkeit wird deutlich erhöht. In meinem Fall dauert zum Beispiel eine Trainingsepoche auf einer CPU 20 Minuten, auf einer GPU dauert es 1-2 Minuten. Wenn das Netzwerk auf 40 Epochen trainiert wird, dann würde ich 13 und 1,5 Stunden benötigen. Die Verwendung von GPU kann den Suchprozess für Neuronale Netze im Forschungsstadium erheblich beschleunigen.

1. Laden und installieren Sie die neueste Version von Anaconda Navigator. Verwenden Sie bei allen Schritten die Standardeinstellungen.
2. Starten Sie "Anaconda Prompt" über das Menü "Start\Anaconda3".
3. Führen Sie den Befehl "pip install tensorflow" aus. Installieren Sie die Programmbibliothek fürmachine learning developed by Google entwickelt wurde.
   
   
   
4. Führen Sie den Befehl "pip install keras" aus. Installieren Sie die Bibliothek für Neuronale Netze von Keras.
   
   
   
5. Erstellen Sie eine neue "conda"-Umgebung unter GPU. Geben Sie den Befehl conda create --name PythonGPU ein. Aktivieren Sie die Umgebung - activate PythonGPU. 
   
   

6. Um tensorflow gpu zu installieren, geben Sie den Befehl conda create -n PythonGPU python=3.6 tensorflow-gpu ein. Bitte beachten Sie, dass tensorflow gpu für Python 3.6 installiert sein sollte
   .  
   
   

7. Um keras gpu zu installieren, geben Sie den Befehl conda install -c anaconda keras-gpu ein.
   

8. Installieren Sie die Jupyter-Schnittstelle für die Programmierung in der Python-GPU-Umgebung. CPU Jupyter wurde bereits während der Installation von Anaconda installiert. Geben Sie den Befehl - conda install jupyter ein. 

9. Installieren Sie zwei weitere Bibliotheken, Pandas und Pillow - conda install -c anaconda pandas. Dann - conda install pillow. Diese Bibliotheken sollten auch für die CPU installiert werden, wenn Sie keine Grafikkarte verwenden wollen.
    

10. 
    
    
11. Wir können nun mit dem Training unseres Convolutional Neuronalen Netzes beginnen. Fügen Sie dem zuvor erstellten CNN-Ordner zwei Dateien hinzu: Train.ipynb und Test.ipynb. Dies sind Dateien im Format von Jupyter Notebook, mit denen wir arbeiten werden. Starten Sie Jupyter Notebook (PythonGPU) und öffnen Sie die Datei Train.    

from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Conv2D, MaxPooling2D
from tensorflow.python.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.models import load_model

# Directory with data for training
train_dir = 'train'
# Directory with data for validation
val_dir = 'val'
# Image dimensions
img_width, img_height = 449, 449
# Image-based tensor dimension for input to the neural network
# backend Tensorflow, channels_last
input_shape = (img_width, img_height, 3)
# Number of epochs
epochs = 20
# Mini-sample size
batch_size = 7
# Number of images for training
nb_train_samples = 4289
# Number of images for validation
nb_validation_samples = 1836
# Number of images for testing
#nb_test_samples = 3736

model = Sequential()
model.add(Conv2D(96, (3, 3), input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(16, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='sgd',
              metrics=['accuracy'])

datagen = ImageDataGenerator(rescale=1. / 255)

callbacks = [ModelCheckpoint('cnn_Open{epoch:1d}.hdf5')]

model.fit(
    train_generator,
    steps_per_epoch=nb_train_samples // batch_size,
    epochs=epochs,
    validation_data=val_generator,
    validation_steps=nb_validation_samples // batch_size,
    callbacks=callbacks)

from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Conv2D, MaxPooling2D
from tensorflow.python.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.models import load_model
import pandas as pd

predict_dir = 'Test'
img_width, img_height = 449, 449
nb_predict_samples = 12558

Date=pd.read_csv('EURUSDDate.csv', delimiter=';',header=None)

model=load_model('cnn_Open11.hdf5')

datagen = ImageDataGenerator(rescale=1. / 255)

predict_generator = datagen.flow_from_directory(
    predict_dir,
    target_size=(img_width, img_height),
    shuffle=False)

indicator=model.predict(predict_generator, nb_predict_samples )

print(indicator)

Date=pd.DataFrame(Date)
Date['0'] =indicator
Date.to_csv('Indicator.csv',index=False, header=False,sep=';')

//+------------------------------------------------------------------+
//|                                                          NWI.mq5 |
//|                                 Copyright © 2019, Andrey Dibrov. |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2019, Andrey Dibrov."
#property link      "https://www.mql5.com/en/users/tomcat66"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   2
#property indicator_type1   DRAW_LINE
#property indicator_type2   DRAW_LINE
#property indicator_color1  Red
#property indicator_color2  DodgerBlue


int Handle;
int i;
int h;
input int Period=5;
double    ExtBuffer[];
double    SignBuffer[];
datetime Date1;
datetime Date0;
string File_Name="Indicator.csv";

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
void OnInit()
  {
   SetIndexBuffer(0,ExtBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,SignBuffer,INDICATOR_DATA);
   IndicatorSetInteger(INDICATOR_DIGITS,5);
   Handle=FileOpen(File_Name,FILE_CSV|FILE_SHARE_READ|FILE_ANSI|FILE_COMMON,";");
   //FileClose(Handle);
  }
//+------------------------------------------------------------------+
//| Relative Strength Index                                          |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
   MqlDateTime stm;
   Date0=StringToTime(FileReadString(Handle));
   i=iBarShift(NULL,PERIOD_H1,Date0,false);
   Handle=FileOpen(File_Name,FILE_CSV|FILE_SHARE_READ|FILE_ANSI|FILE_COMMON,";");
   ArraySetAsSeries(ExtBuffer,true);
   ArraySetAsSeries(SignBuffer,true);
   while(!FileIsEnding(Handle) && !IsStopped())
     {
      Date1=StringToTime(FileReadString(Handle));
      ExtBuffer[i]=StringToDouble(FileReadString(Handle));
      h=Period-1;
      if(i>=0)
        {
         while(h>=0)
           {
            SignBuffer[i]=SignBuffer[i]+ExtBuffer[i+h];
            h--;
           }
        }
      SignBuffer[i]=SignBuffer[i]/Period;
      TimeToStruct(Date1,stm);
      i--;
     }
   FileClose(Handle);
   return(rates_total);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                      TestCNN.mq5 |
//|                                 Copyright © 2019, Andrey Dibrov. |
//+------------------------------------------------------------------+
#property copyright " Copyright © 2019, Andrey Dibrov."
#property link      "https://www.mql5.com/en/users/tomcat66"
#property version   "1.00"
#property strict

#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=Period-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++;
  }
//+------------------------------------------------------------------+

Visualisierung von Schichten des Neuronalen Netzes und Verbesserung der CNN-Qualität

Das Neuronale Netz scheint eine Art Blackbox zu sein. Das ist aber nicht ganz so, denn wir können in Merkmalskarten in Schichten sehen, welche Merkmale das Neuronale Netz hervorhebt. Dies liefert Informationen für die weitere Analyse und die Verbesserung der Netzwerkqualität. Schauen wir uns das mal an.

Führen Sie Visual.ipynb aus dem Ordner CNN aus.

Laden Sie zunächst die notwendigen Module der Bibliotheken des Neuronalen Netzes.

from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Model, load_model
import pandas as pd
from tensorflow.python.keras.preprocessing import image 
import matplotlib.pyplot as plt
import numpy as np

Laden des gesicherten Modells.

model=load_model('cnn_Open11.hdf5')

Schauen wir uns die Netzarchitektur an.

model.summary()

Was analysieren die Convolutional-Schichten?

Laden wir ein paar Bilder.

img_path='Train/Buy/Buy81.png'
img=image.load_img(img_path,target_size=(449,449))
plt.figure(figsize=(8, 8))
plt.imshow(img)
plt.show

Konvertieren wir das Bild in ein Numpy-Array und normalisieren es.

x=image.img_to_array(img)
x=np.expand_dims(x,axis=0)
x/=255

Schneiden des Modells auf ein paar Convolutional-Schichten. Die Nummern der Convolutional-Schichten sind 0, 3, 6. Beginnen wir bei Null. Tatsächlich erstellen wir ein neues, bereits trainiertes Modell, von dem wir vor der Klassifizierung ein Zwischenergebnis erhalten werden.

model=Model(inputs=model.input, outputs=model.layers[0].output)

Danach können wir die Schichten 3 und 6 anzeigen.

#model=Model(inputs=model.input, outputs=model.layers[3].output)

#model=Model(inputs=model.input, outputs=model.layers[6].output)

Ein paar Informationen über das beschnittene Modell.

model.summary()

Prüfen wir die erste Convolutional-Schicht 0.

Antwort des Neuronalen Netzes abrufen.

model=model.predict(x)

Eine der Merkmalskarten ausgeben, 18.

print(model.shape)
im=model[0,:,:,18]
plt.figure(figsize=(10, 10))
plt.imshow(im)
plt.show()

Wie Sie sehen können, hat das Netzwerk hier Aufwärtskerzen hervorgehoben. In diesem Stadium ist es für das Neuronale Netz schwer, zwischen Abwärtskerzen und den Punkten der Parabolic zu unterscheiden. Das liegt daran, dass für sie die gleiche Farbe verwendet wird. Daher sollten alle Elemente des Charts in verschiedenen Farben dargestellt werden. 

Alle Merkmalskarten prüfen

rows=12
filters=model.shape[-1]
size=model.shape[1]
cols=filters//rows
display_grid=np.zeros((cols*size,rows*size))
for col in range(cols):
    for row in range(rows):
        channel_image=model[0,:,:,col*rows+row]
        channel_image-=channel_image.mean()
        channel_image/=channel_image.std()
        channel_image*=64
        channel_image+=128
        channel_image=np.clip(channel_image,0,255).astype('uint8')
        display_grid[col*size:(col+1)*size,row*size:(row+1)*size]=channel_image
scale=1./size
plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[1]))
plt.grid(False)
plt.imshow(display_grid,aspect='auto',cmap='viridis')

Schauen Sie auf die dritte Merkmalskarte (2).

Hier hebt das Neuronale Netz alle Kerzen hervor, allerdings mit unterschiedlichen Dochten. Dadurch ähnelt das Bild einem dreidimensionalen Bild. Aber auch hier können Sie sehen, dass die Dochte der Abwärtskerzen und Parabolic die gleiche Farbe haben.

Betrachten Sie nun die Karte 5 der nächsten Convolutional-Schicht (3).

Hier überschneiden sich die Punkte von Parabolic, und das CNN identifiziert sie als Zeichen für das Muster einer Seitwärtsbewegung. Gemäß der vorherigen Abbildung hat das Neuronale Netz diesen Abschnitt anders gerendert. Daraus können wir schließen, dass sich die Kategorien der Bilder für das Training erweitert haben. Wir müssen eine weitere Kategorie einführen, um das Neuronale Netz zu trainieren - Seitwärtsbewegung (Flat).

Die visuelle Untersuchung der Merkmalskarten des Convolutional Neuronalen Netzes ermöglicht also eine klarere Spezifikation der Trainingsaufgaben. Dies kann auch bei der Erweiterung der vom CNN identifizierten Merkmalskategorien sowie bei der Reduzierung des Rauschens helfen.

Schlussfolgerung

Durch die Verwendung öffentlich verfügbarer Tools und Fähigkeiten von Convolutional Neuronalen Netzen können wir einen interessanten und unkonventionellen Ansatz zur technischen Analyse anwenden. Gleichzeitig kann dadurch die Aufbereitung der Daten für das Training des Neuronalen Netzes stark vereinfacht werden. Die Visualisierung der darin ablaufenden Prozesse hilft bei der Analyse, welche Eingangsdaten die Qualität des Trainings am meisten beeinflussen. 

Zum Schluss möchte ich noch die Optimierung erwähnen. Wie ich bereits geschrieben habe, handelt es sich um eine sehr einfache Optimierung. Sie sollte jedoch mit den Aufgaben in Einklang gebracht werden, die wir für unser Netzwerk gestellt haben. In Übereinstimmung mit diesen Aufgaben sollte das Trainingsfeld in Kategorien eingeteilt werden. Außerdem sollten diese Bedingungen bei der Erstellung eines Handelsroboters verwendet werden.