280 lines
22 KiB
MQL5
280 lines
22 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| NeuronDropout.mqh |
|
|
//| Copyright 2021, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2021, MetaQuotes Ltd."
|
|
#property link "https://www.mql5.com"
|
|
//+------------------------------------------------------------------+
|
|
//| Подключаем библиотеки |
|
|
//+------------------------------------------------------------------+
|
|
#include "neuronbase.mqh"
|
|
//+------------------------------------------------------------------+
|
|
//| Class CNeuronDropout |
|
|
//| Назначение: Класс реализации метода Dropout |
|
|
//+------------------------------------------------------------------+
|
|
class CNeuronDropout : public CNeuronBase
|
|
{
|
|
protected:
|
|
double m_dOutProbability;
|
|
int m_iOutNumber;
|
|
double m_dInitValue;
|
|
|
|
CBufferDouble *m_cDropOutMultiplier;
|
|
|
|
public:
|
|
CNeuronDropout(void);
|
|
~CNeuronDropout(void);
|
|
//---
|
|
virtual bool Init(CLayerDescription *description);
|
|
virtual bool FeedForward(CNeuronBase *prevLayer);
|
|
virtual bool CalcHiddenGradient(CNeuronBase *prevLayer);
|
|
virtual bool CalcDeltaWeights(CNeuronBase *prevLayer) { return true; }
|
|
virtual bool UpdateWeights(int batch_size, double learningRate,
|
|
double &Beta[], double &Lambda[])
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//--- Методы работы с файлами
|
|
virtual bool Save(const int file_handle);
|
|
virtual bool Load(const int file_handle);
|
|
//--- Метод идентификации объекта
|
|
virtual int Type(void) const { return(defNeuronDropout); }
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Конструктор класса |
|
|
//+------------------------------------------------------------------+
|
|
CNeuronDropout::CNeuronDropout(void) : m_dInitValue(1.0),
|
|
m_dOutProbability(0),
|
|
m_iOutNumber(0)
|
|
{
|
|
m_cDropOutMultiplier = new CBufferDouble();
|
|
m_bTrain = false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Деструктор класса |
|
|
//+------------------------------------------------------------------+
|
|
CNeuronDropout::~CNeuronDropout(void)
|
|
{
|
|
if(CheckPointer(m_cDropOutMultiplier) != POINTER_INVALID)
|
|
delete m_cDropOutMultiplier;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Метод инициализации класса |
|
|
//+------------------------------------------------------------------+
|
|
bool CNeuronDropout::Init(CLayerDescription *description)
|
|
{
|
|
//--- Блок контролей
|
|
if(!CheckPointer(description) == POINTER_INVALID ||
|
|
description.count != description.window)
|
|
return false;
|
|
description.window = 0;
|
|
if(!CNeuronBase::Init(description))
|
|
return false;
|
|
//--- Расчёт коэффициентов
|
|
m_dOutProbability = MathMin(description.probability, 0.9);
|
|
if(m_dOutProbability < 0)
|
|
return false;
|
|
m_iOutNumber = (int)(m_cOutputs.Total() * m_dOutProbability);
|
|
m_dInitValue = 1.0 / (1.0 - m_dOutProbability);
|
|
if(CheckPointer(m_cDropOutMultiplier) == POINTER_INVALID)
|
|
{
|
|
m_cDropOutMultiplier = new CBufferDouble();
|
|
if(CheckPointer(m_cDropOutMultiplier) == POINTER_INVALID)
|
|
return false;
|
|
}
|
|
//--- Инициируем буфер маскирования
|
|
if(!m_cDropOutMultiplier.BufferInit(m_cOutputs.Total(), m_dInitValue))
|
|
return false;
|
|
m_bTrain = true;
|
|
//---
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Метод прямого прохода |
|
|
//+------------------------------------------------------------------+
|
|
bool CNeuronDropout::FeedForward(CNeuronBase *prevLayer)
|
|
{
|
|
//--- Блок контролей
|
|
if(CheckPointer(prevLayer) == POINTER_INVALID ||
|
|
CheckPointer(prevLayer.GetOutputs()) == POINTER_INVALID ||
|
|
CheckPointer(m_cOutputs) == POINTER_INVALID ||
|
|
CheckPointer(m_cDropOutMultiplier) == POINTER_INVALID)
|
|
return false;
|
|
//--- Провеверка флага режима работы
|
|
if(!m_bTrain)
|
|
return m_cOutputs.AssignArray(prevLayer.GetOutputs());
|
|
//--- Генерируем тензор маскирования данных
|
|
int total = m_cOutputs.Total();
|
|
if(!m_cDropOutMultiplier.BufferInit(total, m_dInitValue))
|
|
return false;
|
|
for(int i = 0; i < m_iOutNumber; i++)
|
|
{
|
|
int pos = (int)(MathRand() * MathRand() / MathPow(32767.0, 2) * total);
|
|
if(m_cDropOutMultiplier[pos] == 0)
|
|
{
|
|
i--;
|
|
continue;
|
|
}
|
|
if(!m_cDropOutMultiplier.Update(pos, 0))
|
|
return false;
|
|
}
|
|
//--- Разветвление алгоритма в зависимости от устройста выполнениия операций
|
|
if(CheckPointer(m_cOpenCL) == POINTER_INVALID)
|
|
{
|
|
double out[];
|
|
double prev[];
|
|
if(ArrayResize(out, total) < total)
|
|
return false;
|
|
if(!prevLayer.GetOutputs().GetData(prev, false) ||
|
|
ArraySize(prev) != total)
|
|
return false;
|
|
for(int i = 0; i < total; i++)
|
|
out[i] = prev[i] * m_cDropOutMultiplier[i];
|
|
if(!m_cOutputs.AssignArray(out))
|
|
return false;
|
|
}
|
|
else // Блок OpenCL
|
|
{
|
|
//--- Создание буферов данных
|
|
CBufferDouble *inputs = prevLayer.GetOutputs();
|
|
if(inputs.GetIndex() < 0 && !inputs.BufferCreate(m_cOpenCL))
|
|
return false;
|
|
if(m_cDropOutMultiplier.GetIndex() < 0 && !m_cDropOutMultiplier.BufferCreate(m_cOpenCL))
|
|
return false;
|
|
if(m_cOutputs.GetIndex() < 0 && !m_cOutputs.BufferCreate(m_cOpenCL))
|
|
return false;
|
|
//--- Передача параметров кернелу
|
|
if(!m_cOpenCL.SetArgumentBuffer(def_k_MaskMult, def_mask_inputs, inputs.GetIndex()))
|
|
return false;
|
|
if(!m_cOpenCL.SetArgumentBuffer(def_k_MaskMult, def_mask_mask, m_cDropOutMultiplier.GetIndex()))
|
|
return false;
|
|
if(!m_cOpenCL.SetArgumentBuffer(def_k_MaskMult, def_mask_outputs, m_cOutputs.GetIndex()))
|
|
return false;
|
|
if(!m_cOpenCL.SetArgument(def_k_MaskMult, def_mask_total, total))
|
|
return false;
|
|
//--- Постановка в очередь выполнения
|
|
int off_set[] = {0};
|
|
int s = total;
|
|
int d = s % 4;
|
|
s = (s - d) / 4 + (d > 0 ? 1 : 0);
|
|
int NDRange[] = {s};
|
|
if(!m_cOpenCL.Execute(def_k_MaskMult, 1, off_set, NDRange))
|
|
return false;
|
|
//--- Получение результатов
|
|
if(!m_cOutputs.BufferRead())
|
|
return false;
|
|
//--- Очистка памяти кернела
|
|
inputs.BufferFree();
|
|
m_cDropOutMultiplier.BufferFree();
|
|
}
|
|
//---
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Метод распределения градиента через скрытый слой |
|
|
//+------------------------------------------------------------------+
|
|
bool CNeuronDropout::CalcHiddenGradient(CNeuronBase *prevLayer)
|
|
{
|
|
//--- Блок контролей
|
|
if(CheckPointer(prevLayer) == POINTER_INVALID ||
|
|
CheckPointer(prevLayer.GetGradients()) == POINTER_INVALID ||
|
|
CheckPointer(m_cGradients) == POINTER_INVALID ||
|
|
CheckPointer(m_cDropOutMultiplier) == POINTER_INVALID)
|
|
return false;
|
|
//--- Провеверка флага режима работы
|
|
if(!m_bTrain)
|
|
return prevLayer.GetGradients().AssignArray(m_cGradients);
|
|
//--- Разветвление алгоритма в зависимости от устройста выполнениия операций
|
|
int total = m_cOutputs.Total();
|
|
if(CheckPointer(m_cOpenCL) == POINTER_INVALID)
|
|
{
|
|
double gradient[];
|
|
double prev[];
|
|
if(ArrayResize(prev, total) < total)
|
|
return false;
|
|
if(!m_cGradients.GetData(gradient, false) ||
|
|
ArraySize(gradient) != total)
|
|
return false;
|
|
for(int i = 0; i < total; i++)
|
|
prev[i] = gradient[i] * m_cDropOutMultiplier[i];
|
|
if(!prevLayer.GetGradients().AssignArray(prev))
|
|
return false;
|
|
}
|
|
else // Блок OpenCL
|
|
{
|
|
//--- Создание буферов данных
|
|
CBufferDouble *prev = prevLayer.GetGradients();
|
|
if(prev.GetIndex() < 0 && !prev.BufferCreate(m_cOpenCL))
|
|
return false;
|
|
if(m_cDropOutMultiplier.GetIndex() < 0 && !m_cDropOutMultiplier.BufferCreate(m_cOpenCL))
|
|
return false;
|
|
if(m_cGradients.GetIndex() < 0 && !m_cGradients.BufferCreate(m_cOpenCL))
|
|
return false;
|
|
//--- Передача параметров кернелу
|
|
if(!m_cOpenCL.SetArgumentBuffer(def_k_MaskMult, def_mask_inputs, m_cGradients.GetIndex()))
|
|
return false;
|
|
if(!m_cOpenCL.SetArgumentBuffer(def_k_MaskMult, def_mask_mask, m_cDropOutMultiplier.GetIndex()))
|
|
return false;
|
|
if(!m_cOpenCL.SetArgumentBuffer(def_k_MaskMult, def_mask_outputs, prev.GetIndex()))
|
|
return false;
|
|
if(!m_cOpenCL.SetArgument(def_k_MaskMult, def_mask_total, total))
|
|
return false;
|
|
//--- Постановка в очередь выполнения
|
|
int off_set[] = {0};
|
|
int s = total;
|
|
int d = s % 4;
|
|
s = (s - d) / 4 + (d > 0 ? 1 : 0);
|
|
int NDRange[] = {s};
|
|
if(!m_cOpenCL.Execute(def_k_MaskMult, 1, off_set, NDRange))
|
|
return false;
|
|
//--- Получение результатов
|
|
if(!prev.BufferRead())
|
|
return false;
|
|
//--- Очистка памяти кернела
|
|
m_cGradients.BufferFree();
|
|
m_cDropOutMultiplier.BufferFree();
|
|
}
|
|
//---
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Метод сохранения элементов класса в файл |
|
|
//+------------------------------------------------------------------+
|
|
bool CNeuronDropout::Save(const int file_handle)
|
|
{
|
|
//--- Вызов метода родительского класса
|
|
if(!CNeuronBase::Save(file_handle))
|
|
return false;
|
|
//--- Сохраняем константу вероятности "выкидывания" элементов
|
|
if(FileWriteDouble(file_handle, m_dOutProbability) <= 0)
|
|
return false;
|
|
//---
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Метод восстановления класса из сохранённых данных |
|
|
//+------------------------------------------------------------------+
|
|
bool CNeuronDropout::Load(const int file_handle)
|
|
{
|
|
//--- Вызов метода родительского класса
|
|
if(!CNeuronBase::Load(file_handle))
|
|
return false;
|
|
//--- Считывание и восстановление констант
|
|
m_dOutProbability = FileReadDouble(file_handle);
|
|
m_iOutNumber = (int)(m_cOutputs.Total() * m_dOutProbability);
|
|
m_dInitValue = 1.0 / (1.0 - m_dOutProbability);
|
|
//--- Инициализация буфера маскированиия данных
|
|
if(CheckPointer(m_cDropOutMultiplier) == POINTER_INVALID)
|
|
{
|
|
m_cDropOutMultiplier = new CBufferDouble();
|
|
if(CheckPointer(m_cDropOutMultiplier) == POINTER_INVALID)
|
|
return false;
|
|
}
|
|
if(!m_cDropOutMultiplier.BufferInit(m_cOutputs.Total(), m_dInitValue))
|
|
return false;
|
|
//---
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|