Référence MQL5Méthodes sur les Matrices et les VecteursMachine learning

Machine learning

Ces méthodes sont utilisées en apprentissage automatique.

La fonction d'activation du réseau neuronal détermine la valeur de sortie d'un neurone en fonction de la somme pondérée des entrées. La sélection de la fonction d'activation a un impact important sur les performances du réseau neuronal. Différentes parties de modèle (couches) peuvent utiliser différentes fonctions d'activation.

En plus de toutes les fonctions d'activation connues, MQL5 propose également leurs dérivés. Les dérivées de fonction permettent une mise à jour efficace des paramètres du modèle en fonction de l'erreur reçue lors de l'apprentissage.

Un réseau de neurones vise à trouver un algorithme qui minimise l'erreur d'apprentissage, pour lequel la fonction de perte est utilisée. La valeur de la fonction de perte indique de combien la valeur prédite par le modèle s'écarte de la valeur réelle. Différentes fonctions de perte sont utilisées en fonction du problème. Par exemple, l'Erreur Quadratique Moyenne (Mean Squared Error, MSE) est utilisée pour les problèmes de régression, et l'Entropie Croisée Binaire (Binary Cross-Entropy, BCE) est utilisé à des fins de classification binaire.

Fonction	Action
Activation	Calcule les valeurs de la fonction d'activation et les écrit dans le vecteur/matrice passé
Derivative	Calcule les valeurs dérivées de la fonction d'activation et les écrit dans le vecteur/matrice passé
Loss	Calcule les valeurs de la fonction de perte et les écrit dans le vecteur/matrice passé
Loss	Calcule un vecteur ou une matrice de gradients de fonction de perte
RegressionMetric	Calculer la métrique de régression en tant qu'erreur d'écart par rapport à la ligne de régression construite sur le tableau de données spécifié
ConfusionMatrix	Calcule la matrice de confusion. La méthode est appliquée au vecteur de valeurs prédites
ConfusionMatrixMultilabel	Calcule la matrice de confusion pour chaque étiquette. La méthode est appliquée au vecteur de valeurs prédites
ClassificationMetric	Calcule la métrique de classification pour évaluer la qualité des données prédites par rapport aux données vraies. La méthode est appliquée au vecteur de valeurs prédites
ClassificationScore	Calcule la métrique de classification pour évaluer la qualité des données prédites par rapport aux données réelles
PrecisionRecall	Calcule les valeurs pour construire une courbe de rappel de précision. De la même manière que ClassificationScore, cette méthode est appliquée au vecteur de valeurs vraies
ReceiverOperatingCharacteristic	Calcule les valeurs pour construire la courbe des Caractéristiques de Fonctionnement du Récepteur (Receiver Operating Characteristic, ROC). De la même manière que ClassificationScore, cette méthode est appliquée au vecteur de valeurs vraies

Exemple

Cet exemple illustre la formation d'un modèle à l'aide d'opérations matricielles. Le modèle est entraîné pour la fonction (a + b + c)^2 / (a^2 + b^2 + c^2). Nous saisissons la matrice de données initiale, dans laquelle a, b et c sont contenus dans des colonnes différentes. Le résultat de la fonction est obtenu en sortie du modèle.

matrix weights1, weights2, weights3;               // matrices de poids
matrix output1, output2, result;                   // matrices des sorties de la couche neuronale
input int layer1 = 200;                            // la taille de la première couche masquée
input int layer2 = 200;                            // la taille de la deuxième couche masquée
input int Epochs = 20000;                          // le nombre de passes d'entraînement
input double lr = 3e-6;                            // taux d'apprentissage
input ENUM_ACTIVATION_FUNCTION ac_func = AF_SWISH; // fonction d'activation
//+------------------------------------------------------------------+
//| Fonction de démarrage du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int train = 1000;    // taille de l'échantillon d'entraînement
   int test = 10;       // taille de l'échantillon de test
   matrix m_data, m_target;
//--- génére un échantillon d'apprentissage
   if(!CreateData(m_data, m_target, train))
      return;
//--- entraîne le modèle
   if(!Train(m_data, m_target, Epochs))
      return;
//--- génére un échantillon de test
   if(!CreateData(m_data, m_target, test))
      return;
//--- teste le modèle
   Test(m_data, m_target);
  }
//+------------------------------------------------------------------+
//| Méthode de génération d'échantillons                             |
//+------------------------------------------------------------------+
bool CreateData(matrix &data, matrix &target, const int count)
  {
//--- initialise les données initiales et les matrices de résultats
   if(!data.Init(count, 3) || !target.Init(count, 1))
      return false;
//--- remplit la matrice de données initiale avec des valeurs aléatoires
   data.Random(-10, 10);
//--- calcule les valeurs cibles pour l'échantillon d'apprentissage
   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;
//--- retourne le résultat
   return true;
  }
//+------------------------------------------------------------------+
//| Méthode d'entraînement du modèle                                 |
//+------------------------------------------------------------------+
bool Train(matrix &data, matrix &target, const int epochs = 10000)
  {
//--- crée le modèle
   if(!CreateNet())
      return false;
//--- entraîne le modèle
   for(int ep = 0; ep < epochs; ep++)
     {
      //--- passe anticipée
      if(!FeedForward(data))
         return false;
      PrintFormat("Passe %d, loss %.5f", ep, result.Loss(target, LOSS_MSE));
      //--- rétropropagation et mise à jour de la matrice de poids
      if(!Backprop(data, target))
         return false;
     }
//--- retourne le résultat
   return true;
  }
//+------------------------------------------------------------------+
//| Méthode de création du modèle                                    |
//+------------------------------------------------------------------+
bool CreateNet()
  {
//--- initialise les matrices de poids
   if(!weights1.Init(4, layer1) || !weights2.Init(layer1 + 1, layer2) || !weights3.Init(layer2 + 1, 1))
      return false;
//--- remplit les matrices de poids avec des valeurs aléatoires
   weights1.Random(-0.1, 0.1);
   weights2.Random(-0.1, 0.1);
   weights3.Random(-0.1, 0.1);
//--- retourne le résultat
   return true;
  }
//+------------------------------------------------------------------+
//| Méthode d'anticipation                                          |
//+------------------------------------------------------------------+
bool FeedForward(matrix &data)
  {
//--- vérifie la taille initiale des données
   if(data.Cols() != weights1.Rows() - 1)
      return false;
//--- calcule la première couche neuronale
   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);
//--- calcule la fonction d'activation
   if(!output1.Activation(temp, ac_func))
      return false;
//--- calcule la deuxième couche neuronale
   if(!temp.Resize(temp.Rows(), weights2.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights2.Rows() - 1))
      return false;
   output2 = temp.MatMul(weights2);
//--- calcule la fonction d'activation
   if(!output2.Activation(temp, ac_func))
      return false;
//--- calcule la troisième couche neurale
   if(!temp.Resize(temp.Rows(), weights3.Rows()) ||
      !temp.Col(vector::Ones(temp.Rows()), weights3.Rows() - 1))
      return false;
   result = temp.MatMul(weights3);
//--- retourne le résultat
   return true;
  }
//+------------------------------------------------------------------+
//| Méthode de rétropropagation                                   |
//+------------------------------------------------------------------+
bool Backprop(matrix &data, matrix &target)
  {
//--- vérifie la taille de la matrice des valeurs cibles
   if(target.Rows() != result.Rows() ||
      target.Cols() != result.Cols())
      return false;
//--- détermine l'écart des valeurs calculées par rapport à la cible
   matrix loss = (target - result) * 2;
//--- propage le gradient à la couche précédente
   matrix gradient = loss.MatMul(weights3.Transpose());
//--- met à jour la matrice de poids de la dernière couche
   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;
//--- ajuste le gradient d'erreur par la dérivée de la fonction d'activation
   if(!output2.Derivative(temp, ac_func))
      return false;
   if(!gradient.Resize(gradient.Rows(), gradient.Cols() - 1))
      return false;
   loss = gradient * temp;
//--- propage le gradient à une couche inférieure
   gradient = loss.MatMul(weights2.Transpose());
//--- met à jour la matrice de poids de la deuxième couche cachée
   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;
//--- ajuste le gradient d'erreur par la dérivée de la fonction d'activation
   if(!output1.Derivative(temp, ac_func))
      return false;
   if(!gradient.Resize(gradient.Rows(), gradient.Cols() - 1))
      return false;
   loss = gradient * temp;
//--- met à jour la matrice de poids de la première couche cachée
   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;
//--- retourne le résultat
   return true;
  }
//+------------------------------------------------------------------+
//| Méthode de test du modèle                                        |
//+------------------------------------------------------------------+
bool Test(matrix &data, matrix &target)
  {
//--- propagation avant (feed forward) des données de test
   if(!FeedForward(data))
      return false;
//--- journalise les résultats du calcul du modèle et les valeurs vraies
   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]);
//--- retourne le résultat
   return true;
  }
//+------------------------------------------------------------------+

PInv

Activation