Справочник MQL5Методы матриц и векторовМашинное обучение

Машинное обучение

Методы для использования в машинном обучении.

Функция активации в нейронной сети определяет выходное значение нейрона в зависимости от результата взвешенной суммы входов. Выбор функции активации имеет большое влияние на возможности и производительность нейронной сети. В разных частях модели (слоях) могут использоваться различные функции активации.

В MQL5 реализованы не только все известные функции активации, но и их производные. Производные функций позволяют эффективно обновлять параметры модели на основании полученной в процессе обучения ошибки.

Задача обучения нейронной сети заключается в поиске алгоритма, минимизирующего ошибку на обучающей выборке, для чего используется функция потерь (loss function). Значение функции потерь характеризует величину отклонения предсказываемого моделью значения от реального. В зависимости от типа решаемой задачи используются различные функции потерь. Например: для задачи регрессии mean squared error (MSE), для бинарной классификации — binary cross-entropy (BCE).

Функция	Действие
Activation	Вычисляет значения функции активации и записывает в переданный вектор/матрицу
Derivative	Вычисляет значения производной активационной функции и записывает в переданный вектор/матрицу
Loss	Вычисляет значения функции потерь и записывает в переданный вектор/матрицу
LossGradient	Вычисляет вектор или матрицу градиентов функции потерь
RegressionMetric	Вычисляет регрессионную метрику для оценки качества предсказанных данных по отношению к истинным данным
ConfusionMatrix	Вычисляет матрицу ошибок. Метод применяется к вектору предсказанных значений
ConfusionMatrixMultilabel	Вычисляет матрицу ошибок для каждой метки. Метод применяется к вектору предсказанных значений
ClassificationMetric	Вычисляет классификационную метрику для оценки качества предсказанных данных по отношению к истинным данным. Метод применяется к вектору предсказанных значений
ClassificationScore	Вычисляет классификационную метрику для оценки качества предсказанных данных по отношению к истинным данным
PrecisionRecall	Вычисляет значения для построения кривой precision-recall. Данный метод, как и метод ClassificationScore, применяется к вектору истинных значений
ReceiverOperatingCharacteristic	Вычисляет значения для построения кривой Receiver Operating Characteristic (ROC). Данный метод, как и метод ClassificationScore, применяется к вектору истинных значений

Пример:

Этот пример демонстрирует обучение модели с использованием матричных операций. Модель обучается функции (a + b + c)^2 / (a^2 + b^2 + c^2). На вход подается матрица исходных данных, в которых a, b и c содержатся в отдельных колонках. На выходе модели возвращается результат функции.

matrix weights1, weights2, weights3;               // матрицы весовых коэффициентов
matrix output1, output2, result;                   // матрицы выходов нейронных слоев
input int layer1 = 200;                            // размер 1-го скрытого слоя
input int layer2 = 200;                            // размер 2-го скрытого слоя
input int Epochs = 20000;                          // количество эпох обучения
input double lr = 3e-6;                            // коэффициент скорости обучения
input ENUM_ACTIVATION_FUNCTION ac_func = AF_SWISH; // функция активации
//+------------------------------------------------------------------+
//| Функция запуска скрипта                                          |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int train = 1000;    // размер обучающей выборки
   int test = 10;       // размер тестовой выборки
   matrix m_data, m_target;
//--- генерируем обучающую выборку
   if(!CreateData(m_data, m_target, train))
      return;
//--- обучаем модель
   if(!Train(m_data, m_target, Epochs))
      return;
//--- генерируем тестовую выборку
   if(!CreateData(m_data, m_target, test))
      return;
//--- тестирование модели
   Test(m_data, m_target);
  }
//+------------------------------------------------------------------+
//| Метод генерации выборки                                          |
//+------------------------------------------------------------------+
bool CreateData(matrix &data, matrix &target, const int count)
  {
//--- инициализируем матрицы исходных данных и результатов
   if(!data.Init(count, 3) || !target.Init(count, 1))
      return false;
//--- заполняем матрицу исходных данных случайными значениями
   data.Random(-10, 10);
//--- рассчитываем целевые значения для обучающей выборки
   vector X1 = MathPow(data.Col(0) + data.Col(1) + data.Col(1), 2);
   vector X2 = MathPow(data.Col(0), 2) + MathPow(data.Col(1), 2) + MathPow(data.Col(2), 2);
   if(!target.Col(X1 / X2, 0))
      return false;
//--- возвращаем результат
   return true;
  }
//+------------------------------------------------------------------+
//| Метод обучения модели                                            |
//+------------------------------------------------------------------+
bool Train(matrix &data, matrix &target, const int epochs = 10000)
  {
//--- создаем модель
   if(!CreateNet())
      return false;
//--- обучаем модель
   for(int ep = 0; ep < epochs; ep++)
     {
      //--- прямой проход
      if(!FeedForward(data))
         return false;
      PrintFormat("Epoch %d, loss %.5f", ep, result.Loss(target, LOSS_MSE));
      //--- обратный проход и обновление матриц весов
      if(!Backprop(data, target))
         return false;
     }
//--- возвращаем результат
   return true;
  }
//+------------------------------------------------------------------+
//| Метод создания модели                                            |
//+------------------------------------------------------------------+
bool CreateNet()
  {
//--- инициализируем матрицы весов
   if(!weights1.Init(4, layer1) || !weights2.Init(layer1 + 1, layer2) || !weights3.Init(layer2 + 1, 1))
      return false;
//--- заполняем матрицы весов случайными значениями
   weights1.Random(-0.1, 0.1);
   weights2.Random(-0.1, 0.1);
   weights3.Random(-0.1, 0.1);
//--- возвращаем результат
   return true;
  }
//+------------------------------------------------------------------+
//| Метод прямого прохода                                            |
//+------------------------------------------------------------------+
bool FeedForward(matrix &data)
  {
//--- проверяем размер исходных данных
   if(data.Cols() != weights1.Rows() - 1)
      return false;
//--- вычисляем первый нейронный слой
   matrix temp = data;
   if(!temp.Resize(temp.Rows(), weights1.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights1.Rows() - 1))
      return false;
   output1 = temp.MatMul(weights1);
//--- вычисяем функцию активации
   if(!output1.Activation(temp, ac_func))
      return false;
//--- вычисляем второй нейронный слой
   if(!temp.Resize(temp.Rows(), weights2.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights2.Rows() - 1))
      return false;
   output2 = temp.MatMul(weights2);
//--- вычисляем функцию активации
   if(!output2.Activation(temp, ac_func))
      return false;
//--- вычисляем третий нейронный слой
   if(!temp.Resize(temp.Rows(), weights3.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights3.Rows() - 1))
      return false;
   result = temp.MatMul(weights3);
//--- возвращаем результат
   return true;
  }
//+------------------------------------------------------------------+
//| Метод обратного прохода                                          |
//+------------------------------------------------------------------+
bool Backprop(matrix &data, matrix &target)
  {
//--- проверяем размерность матрицы целевых значений
   if(target.Rows() != result.Rows() ||
      target.Cols() != result.Cols())
      return false;
//--- определяем отклонение расчетных значений от целевых
   matrix loss = (target - result) * 2;
//--- проводим градиент до предыдущего слоя
   matrix gradient = loss.MatMul(weights3.Transpose());
//--- обновляем матрицу весов последнего слоя
   matrix temp;
   if(!output2.Activation(temp, ac_func))
      return false;
   if(!temp.Resize(temp.Rows(), weights3.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights3.Rows() - 1))
      return false;
   weights3 = weights3 + temp.Transpose().MatMul(loss) * lr;
//--- корректируем градиент ошибки на производную функции активации
   if(!output2.Derivative(temp, ac_func))
      return false;
   if(!gradient.Resize(gradient.Rows(), gradient.Cols() - 1))
      return false;
   loss = gradient * temp;
//--- опускаем градиент на слой ниже
   gradient = loss.MatMul(weights2.Transpose());
//--- обновляем матрицу весов 2-го скрытого слоя
   if(!output1.Activation(temp, ac_func))
      return false;
   if(!temp.Resize(temp.Rows(), weights2.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights2.Rows() - 1))
      return false;
   weights2 = weights2 + temp.Transpose().MatMul(loss) * lr;
//--- корректируем градиент ошибки на производную функции активации
   if(!output1.Derivative(temp, ac_func))
      return false;
   if(!gradient.Resize(gradient.Rows(), gradient.Cols() - 1))
      return false;
   loss = gradient * temp;
//--- обновляем матрицу весов 1-го скрытого слоя
   temp = data;
   if(!temp.Resize(temp.Rows(), weights1.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights1.Rows() - 1))
      return false;
   weights1 = weights1 + temp.Transpose().MatMul(loss) * lr;
//--- возвращаем результат
   return true;
  }
//+------------------------------------------------------------------+
//| Метод тестирования модели                                        |
//+------------------------------------------------------------------+
bool Test(matrix &data, matrix &target)
  {
//--- прямой проход на тестовых данных
   if(!FeedForward(data))
      return false;
//--- выводим в лог результаты расчета модели и истинные значения
   PrintFormat("Test loss %.5f", result.Loss(target, LOSS_MSE));
   ulong total = data.Rows();
   for(ulong i = 0; i < total; i++)
      PrintFormat("(%.2f + %.2f + %.2f)^2 / (%.2f^2 + %.2f^2 + %.2f^2) =  Net %.2f, Target %.2f", data[i, 0], data[i, 1], data[i, 2],
                  data[i, 0], data[i, 1], data[i, 2], result[i, 0], target[i, 0]);
//--- возвращаем результат
   return true;
  }
//+------------------------------------------------------------------+

PInv

Activation