我们已经准备了一组图像用于训练网络。我有449x449像素的图像。

准备一组图像进行测试。以“Test”模式运行脚本。

一组连续的每小时屏幕截图将保存到 ...\MQL5\文件中。它们现在是12558个。不要将它们分开或分组，因为神经网络应该自己进行分组。更准确地说，网络应该显示图像与网络训练条件相对应的概率。向上和向下移动。向下移动并向上翻转。 

将这些文件剪切粘贴到 ...CNN\Test\Resp。

我们准备了一组图像，用于测试响应和优化策略。日期和时间为 EURUSDDate 的文件，保留在..\MQL5\files下，应该移动到CNN文件夹。

我想指出 MetaTrader 5 的一个特殊特性。在策略测试器中使用专家顾问来准备一组图像将更加方便和可靠。但是，MetaTrader 5不提供在策略测试器中创建屏幕截图的功能。无论如何，这个特定功能不会影响交易机器人的创建。

让我们探讨一下程序代码的每个部分。

首先加载必要的神经网络库模块。

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

让我们创建网络架构。

• 建立序列卷积神经网络结构
• 输入图像大小为449x449像素，三通道（红色、绿色和蓝色）。这里我们使用彩色图像,你也可以尝试单色图像
• 创建第一个用于处理二维数据的卷积层：96个特征图，每个特征图都有3x3卷积内核。卷积层的每个神经元连接到图像的一个3x3的正方形部分 
• 激活层使用“relu”函数，计算量较小
• 为了减少维数，添加一个带有2x2内核的子采样层，从这个正方形中选择最大值
• 接下来，再添加两个卷积层（32核和16核）、两个激活层和两个子样本
• 将二维数据转换为一维格式
• 将转换后的数据传递到具有64个神经元的完全连接层
• 使用Dropout（0.5）正则化层函数尽量避免过拟合
• 添加一个带有一个神经元的完全连接的输出层。使用了两个图像类，因此网络响应将以二进制响应的形式接收。也可以尝试几个类。例如，两个表示趋势，一个表示横盘。在这种情况下，输出层将有三个神经元。另外，我们需要将图像分为三类。
• “sigmoid”激活函数。它很适合用于分类，并且在我的实验中已显示出最好的性能

这个架构的例子可以很容易地更新-我们可以增加层的数量和它们的大小，根据序列改变它们的位置，改变卷积核的维数，修改激活函数和使用完全连接的层。然而，这里出现了一个难题：当使用GPU时，为了增加神经网络的结构，有必要增加显卡的RAM。或者，应该减小图像大小。否则，我们会花很多时间使用CPU。

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'))

编译神经网络。使用偏差函数：二进制交叉熵（binary-crossentropy）。在本例中，我们将使用由两个类组成的响应，理想情况下，这两个类的值应该是0或1。但是，实际值将从0到1分布。选择梯度下降（Gradient Descent）优化器。它似乎是最适合神经网络训练的。选择准确度指标，即正确答案的百分比。 

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

对图像像素强度数据进行归一化处理。

datagen = ImageDataGenerator(rescale=1. / 255)

使用Keras生成器从磁盘读取数据，并为神经网络创建训练和验证图像阵列。同样, class_mode 是 'binary'. 将 Shuffle 设置为“False”。这样，图像打乱被禁用。

train_generator = datagen.flow_from_directory(
    train_dir,
    target_size=(img_width, img_height),
    batch_size=batch_size,
    class_mode='binary',
    shuffle=False)
val_generator = datagen.flow_from_directory(
    val_dir,
    target_size=(img_width, img_height),
    batch_size=batch_size,
    class_mode='binary',
    shuffle=False)

回调函数在每个历元后保存训练好的神经网络。这允许根据错误值和命中率选择最合适的网络。

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)

12. 如图所示运行程序。

如果前面的步骤已经正确执行，神经网络将开始学习。

After the end of the training process, 20 trained neural networks will appear under the CNN folder.

Let us view training results and select a neural network for further use.

乍一看，在第18个epoch时，神经网络的学习错误率为30%，正确率为85%。然而，当在验证集上运行神经网络时，我们看到错误增加，正确答案的百分比下降。所以，我们应该选择一个在第11 epoch 训练的网络。它在验证集有最合适的结果：val_loss=0.6607 和 val_accuracy=0.6129。理想情况下，误差值应趋于0（或至少不超过35-40%），而精度应接近1（至少不低于55-60%）。在这种情况下，可以省略优化，也可以通过使用最小参数来提高交易质量。即使有了这些训练结果，也有可能建立一个有利可图的交易系统。

解释神经网络响应

现在让我们来看看上述工作是否有实际意义。

在不支持GPU的设置下运行 Jupyter Notebook 并从CNN目录中打开Test.jpynb。

让我们看一下代码块。

首先加载必要的神经网络库模块。

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)

加载第11 epoch 后保存的神经网络。

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=';')

运行程序，完成后 Indicator.csv 文件将在CNN目录下创建。

把它移动到 C:\Users\...\AppData\Roaming\MetaQuotes\Terminal\Common\Files.

在 EURUSD H1 图表上运行 NWI 指标.

//+------------------------------------------------------------------+
//|                                                          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 专家顾问.

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

让我们同时优化的信号线期间，时间和止损订单的交易在两个方向上。

在图表线之前的一段时间内对神经网络进行训练，并对垂直红线进行优化。然后对优化后的神经网络响应进行测试。上面的图表显示了两个随机的正优化结果，优化器将其显示为最高优先级的结果。