Таким образом мы подготовили набор изображений для обучения нашей сети. Изображения в данном случае у меня получились размером 449х449 пикселей.

Подготовим набор изображений для тестирования. Запустим скрипт в режиме "Test".

В папке ...\MQL5\Files каталога данных мы получим набор последовательных почасовых снимков. На данный момент — 12558. Мы их никак не разделяем, поскольку нейросеть должна сама проводить это разделение. Вернее, давать нам рекомендацию с какой вероятностью тот или иной снимок соответствует тем условиям на которых мы обучали сеть. Движение вверх и разворот внизу. Движение вниз и разворот вверху. 

Вырежем эти файлы и вставим в папку ...CNN\Test\Resp.

Итак, набор изображений для дальнейшего тестирования откликов и оптимизации стратегии мы подготовили. Оставшийся в папке ...\MQL5\Files файл с датами и временем EURUSDDate перенесем в папку 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

Задаем необходимые гиперпараметры.

# Каталог с данными для обучения
train_dir = 'train'
# Каталог с данными для проверки
val_dir = 'val'
# Размеры изображения
img_width, img_height = 449, 449
# Размерность тензора на основе изображения для входных данных в нейронную сеть
# backend Tensorflow, channels_last
input_shape = (img_width, img_height, 3)
# Количество эпох
epochs = 20
# Размер мини-выборки
batch_size = 7
# Количество изображений для обучения
nb_train_samples = 4289
# Количество изображений для проверки
nb_validation_samples = 1836
# Количество изображений для тестирования
#nb_test_samples = 3736

Создаем архитектуру сети.

• Задаем последовательную архитектуру CNN (convolutional neural network)
• Входное изображение 449х449 пикселей, трех канальное (красный, зеленый и синий). Мы используем цветное изображение. Можно будет поэкспериментировать с двухцветным
• Создаем первый слой свертки для работы с двухмерными данными - 96 карт признаков каждая с собственным ядром свертки размером 3х3. Каждый нейрон сверточного слоя подключен к квадратному участку изображения размером 3х3 
• Слой активации, использующий функцию "relu" - поскольку она менее требовательна к вычислительным ресурсам
• Для уменьшения размерности добавляем слой подвыборки с ядром 2х2 с выбором максимального значения из этого квадрата
• Далее добавляем еще два слоя свертки с 32 и 16 ядрами и по два слоя активации и подвыборки
• Преобразуем данные из двумерного формата в одномерный
• Передаем преобразованные данные на полносвязный слой, у которого 64 нейрона
• С помощью функции слоя регуляризации Dropout(0.5) пытаемся избежать переобучения
• Добавляем полносвязный выходной слой с одним нейроном. Поскольку мы используем два класса изображений и будем получать отклик от NN в бинарном виде. Мы можем экспериментировать и с несколькими классами. Допустим - два тренда и флэт. Тогда бы в выходном слое было бы три нейрона. И естественно изображения нам надо было бы разделить на три класса.
• Функция активации "sigmoid". Подходит для классификации и лучше других зарекомендовала в наших экспериментах

Этот пример архитектуры мы можем легко модернизировать — увеличивать количество слоев, их размерность, менять местами в зависимости от последовательности размерности, размерность ядер свертки, функции активации, поработать с полно связными слоями. Однако здесь возникает дилемма — при использовании GPU необходимо увеличивать оперативную память видеокарты — если мы хотим наращивать архитектуру нейросети. Либо уменьшать размер изображений. Либо жертвовать своим временем и использовать 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. Оптимизатор выбираем градиентного спуска. В данном случае исходя из экспериментов, он наиболее подходит для обучения NN.  Выбираем метрику аккуратность (accuracy) — процентное соотношение правильных ответов. 

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

Нормализуем данные о интенсивности пикселов изображений.

datagen = ImageDataGenerator(rescale=1. / 255)

Используем генераторы Keras для чтения данных с диска и создания обучающего и валидационного массивов для NN из наших изображений. Опять-таки, 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 сохраняет обученную NN после каждой эпохи. Это дает нам возможность выбрать наиболее подходящую сеть по значениям ошибки и процентам "попадания".

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. Запустим программу на выполнение, как показано на рисунке.

Если все было сделано правильно, то нейросеть начнет обучаться.

После окончания процесса обучения в папке CNN будет находится 20 обученных NN.

Посмотрим на результаты обучения и определимся, какую нейронную сеть нам выбрать для дальнейшего использования.

На первый взгляд на 18 й эпохе нейросеть обучилась с результатом ошибки 30% и 85% верных результатов. Однако при проверке NN на валидационном множестве мы видим, что ошибка растет, а процент положительных ответов падает. Значит, нам необходимо выбрать нейросеть обученную на 11 й эпохе. Как мы видим, здесь наиболее подходящие результаты проверки при валидации val_loss: 0.6607 и val_accuracy: 0.6129. В идеале, конечно, необходимо стремиться к получению значений ошибки, стремящейся к 0 (или хотя бы ниже примерно 35-40%), а аккуратность стремящейся к 1 (или хотя бы выше примерно 55-60%). Тогда оптимизацию можно было бы и не делать, либо проводить по минимальным параметрам для повышения качества торгов. Но и на данных результатах обучения можно создать положительную торговую систему.

Интерпретация отклика нейронной сети

Давайте теперь проверим, имеют ли все наши труды какое-либо практическое значение.

Запустим Jupyter Notebook без поддержки GPU и откроем файл Test.jpynb из каталога CNN.

Рассмотрим поблочно.

Загружаем необходимые модули нейросетевых библиотек.

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 й эпохи NN.

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)

Получаем отклики от NN.

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

Запустим программу и после окончания ее работы в папке CNN получим файл Indicator.csv.

И перенесем его в папку 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/ru/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 Период=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=Период-1;
      if(i>=0)
        {
         while(h>=0)
           {
            SignBuffer[i]=SignBuffer[i]+ExtBuffer[i+h];
            h--;
           }
        }
      SignBuffer[i]=SignBuffer[i]/Период;
      TimeToStruct(Date1,stm);
      i--;
     }
   FileClose(Handle);
   return(rates_total);
  }
//+------------------------------------------------------------------+

Для упрощения интерпретировать отклики от CNN будем с помощью пересечения основной лини индикатора простой средней. Воспользуемся советником TestCNN.

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

#include<Trade\Trade.mqh>

CTrade  trade;

input int Период=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]/Период;
        }
      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++;
  }
//+------------------------------------------------------------------+

Оптимизировать будем одновременно по периоду сигнальной линии, времени и стоп приказам по сделкам в обоих направлениях.

Нейронная сеть обучалась на временном периоде, находящемся до линии графика, и оптимизация проводилась до вертикальной красной линии. После — тест по оптимизированным откликам от NN. На графиках выше показаны два случайных положительных результата оптимизации, которые оптимизатор показал как результат с наибольшим приоритетом.