LSTM Library

Bibliothèque Professionnelle de Réseaux de Neurones pour le Trading Algorithmique

LSTM Library apporte la puissance des réseaux neuronaux récurrents à vos stratégies de trading en MQL5. Cette implémentation de niveau professionnel comprend des réseaux LSTM, BiLSTM et GRU avec des fonctionnalités avancées généralement disponibles uniquement dans des frameworks spécialisés d'apprentissage automatique.

Caractéristiques Principales

• Implémentation complète de LSTM, BiLSTM et GRU
• Dropout récurrent pour une meilleure généralisation
• Algorithmes d'optimisation multiples (Adam, AdamW, RAdam)
• Techniques avancées de normalisation
• Système complet d'évaluation des métriques
• Visualisation de la progression de l'entraînement
• Support pour les données déséquilibrées avec pondération des classes

Spécifications Techniques

• Implémentation pure en MQL5 - sans dépendances externes
• Optimisée pour les applications de trading
• Gestion et validation complètes des erreurs
• Support complet pour sauvegarder/charger les modèles entraînés
• Documentation extensive

Instructions d'Intégration

Pour intégrer la LSTM Library dans votre Expert Advisor, suivez ces étapes :

1. Importation Complète de la Bibliothèque

#import "LSTM_Library.ex5"
   // Informations sur la Bibliothèque
   void GetLibraryVersion(string &version);
   void GetLibraryInfo(string &info);
   
   // Gestion des Modèles
   int CreateModel(string name);
   int DeleteModel(int handle);
   
   // Construction des Couches
   int AddLSTMLayer(int handle, int units, int input_size, int seq_len, bool return_seq);
   int AddLSTMLayerEx(int handle, int units, int input_size, int seq_len, bool return_seq, double recurrent_dropout);
   int AddGRULayer(int handle, int units, int input_size, int seq_len, bool return_seq);
   int AddBiLSTMLayer(int handle, int units, int input_size, int seq_len, bool return_seq);
   int AddBiLSTMLayerEx(int handle, int units, int input_size, int seq_len, bool return_seq, double recurrent_dropout);
   int AddDenseLayer(int handle, int input_size, int units, int activation);
   int AddDropoutLayer(int handle, double rate);
   int AddBatchNormLayer(int handle, int size);
   int AddLayerNormLayer(int handle, int size);
   
   // Compilation et Entraînement
   int CompileModel(int handle, int optimizer, double lr, int loss);
   int SetClassWeights(int handle, double &weights[], int n_classes);
   int EnableConfusionMatrixTracking(int handle, int n_classes);
   int GetConfusionMatrix(int handle, int &confusion_matrix[]);
   int FitModel(int handle, double &X_train[], double &y_train[], int n_train, int input_dim,
             double &X_val[], double &y_val[], int n_val, int epochs, int batch);
   
   // Prédiction et Évaluation
   int PredictSingle(int handle, double &input_data[], int input_size, double &output_data[]);
   int PredictBatch(int handle, double &X[], int n_samples, int input_dim, double &predictions[]);
   double EvaluateModel(int handle, double &X[], double &y[], int n_samples, int input_dim);
   double CalculateClassificationMetrics(double &y_true[], double &y_pred[], int n_samples, int n_classes,
                               double &precision[], double &recall[], double &f1[]);
   
   // Prétraitement des Données
   int CreateScaler();
   int DeleteScaler(int handle);
   int FitScaler(int handle, double &data[], int samples, int features);
   int TransformData(int handle, double &data[], double &transformed[], int samples, int features);
   int InverseTransform(int handle, double &transformed[], double &original[], int samples, int features);
   int FitTransformData(int scaler, double &data[], double &transformed[], int samples, int features);
   
   // Callbacks et Planificateurs
   int AddEarlyStopping(int handle, int patience, double min_delta);
   int AddProgressBar(int handle, int epochs);
   int AddCosineScheduler(int handle, double base_lr, int T_0, int T_mult);
   int AddOneCycleLR(int handle, double max_lr, int total_steps);
   
   // Utilitaires
   int PrintModelSummary(int handle);
   int SetModelTrainingMode(int handle, int training);
   int GetModelTrainingMode(int handle);
   int SaveModel(int handle, string filename);
   int LoadModel(int handle, string filename);
   int SaveHistory(int handle, string filename);
   void CleanupAll();
   int GetActiveModelsCount();
   int GetActiveScalersCount();
#import

2. Initialisation dans OnInit()

int model_handle = 0;

int OnInit()
{
   // Créer un modèle LSTM
   model_handle = CreateModel("TradingModel");
   if(model_handle <= 0)
      return INIT_FAILED;
      
   // Ajouter des couches
   if(AddLSTMLayer(model_handle, 32, 5, 10, false) <= 0)
      return INIT_FAILED;
      
   if(AddDropoutLayer(model_handle, 0.2) <= 0)
      return INIT_FAILED;
      
   if(AddDenseLayer(model_handle, 32, 1, 1) <= 0)
      return INIT_FAILED;
   
   // Compiler le modèle (optimiseur Adam, perte MSE)
   if(CompileModel(model_handle, 1, 0.001, 0) <= 0)
      return INIT_FAILED;
   
   // Charger un modèle existant si disponible
   if(FileIsExist("model.bin"))
      LoadModel(model_handle, "model.bin");
   
   return INIT_SUCCEEDED;
}

3. Nettoyage dans OnDeinit()

void OnDeinit(const int reason)
{
   if(model_handle > 0)
   {
      SaveModel(model_handle, "model.bin");
      DeleteModel(model_handle);
   }
   
   CleanupAll();
}

4. Utilisation dans OnTick()

void OnTick()
{
   // Préparer les caractéristiques
   double features[50];  // Par exemple, 5 caractéristiques * 10 longueur de séquence
   
   // Remplir le tableau de caractéristiques avec les données du marché
   // ...
   
   // Faire une prédiction
   double prediction[];
   if(PredictSingle(model_handle, features, ArraySize(features), prediction) > 0)
   {
      if(prediction[0] > 0.5)
      {
         // Signal haussier - placer un ordre d'achat
      }
      else
      {
         // Signal baissier - placer un ordre de vente
      }
   }
}

Fonctionnalités Avancées Disponibles

Variantes de Couches Récurrentes

• AddLSTMLayerEx() - LSTM avec dropout récurrent pour une meilleure généralisation
• AddBiLSTMLayerEx() - BiLSTM bidirectionnel avec dropout récurrent

Normalisation et Régularisation

• AddBatchNormLayer() - Normalisation par lots pour un entraînement stable
• AddLayerNormLayer() - Normalisation de couche

Gestion des Données Déséquilibrées

• SetClassWeights() - Définir les poids pour les classes minoritaires
• EnableConfusionMatrixTracking() - Suivi détaillé des performances par classe

Optimisation Avancée

• AddCosineScheduler() - Taux d'apprentissage cycliques avec redémarrages à chaud
• AddOneCycleLR() - Implémentation du One-Cycle Learning Rate

Évaluation Complète

• PredictBatch() - Prédictions par lots pour une efficacité accrue
• EvaluateModel() - Évaluation complète sur les données de test
• CalculateClassificationMetrics() - Métriques détaillées (précision, rappel, F1)

Prétraitement des Données

• CreateScaler/FitScaler - Normalisation des données d'entrée
• TransformData/InverseTransform - Conversion entre échelles

Exigences

• MetaTrader 5
• Compréhension de base des concepts de machine learning
• Compétences intermédiaires en programmation MQL5

BOOSTEZ VOS SYSTÈMES DE TRADING

Transformez vos stratégies et indicateurs existants avec la puissance de l'apprentissage automatique directement en MQL5. Cette intégration directe signifie pas de connexions externes, pas de dépendances Python et pas de complexités d'API - seulement une puissance prédictive pure à l'intérieur de votre plateforme de trading.

Que vous développiez des systèmes de prédiction de prix, de prévision de volatilité ou de reconnaissance avancée de motifs, LSTM Library fournit la base pour des décisions de trading véritablement intelligentes qui s'adaptent aux conditions changeantes du marché.

Mots-clés : Prédiction d'Actions LSTM, Prévision de Prix LSTM, Trading par Réseaux de Neurones, Deep Learning MQL5, Prévision de Séries Temporelles, Machine Learning Forex, Trading de Cryptomonnaies avec IA, Reconnaissance de Motifs de Marché, Système de Trading BiLSTM, Analyse de Marché GRU, Trading Algorithmique avec IA, MQL5 Deep Learning, Prédiction de Direction de Prix, Machine Learning pour HFT