LSTM Library

Libreria Professionale di Reti Neurali per il Trading Algoritmico

LSTM Library porta la potenza delle reti neurali ricorrenti alle tue strategie di trading in MQL5. Questa implementazione di livello professionale include reti LSTM, BiLSTM e GRU con funzionalità avanzate tipicamente disponibili solo in framework specializzati di machine learning.

Caratteristiche Principali

• Implementazione completa di LSTM, BiLSTM e GRU
• Dropout ricorrente per una migliore generalizzazione
• Algoritmi di ottimizzazione multipli (Adam, AdamW, RAdam)
• Tecniche avanzate di normalizzazione
• Sistema completo di valutazione delle metriche
• Visualizzazione del progresso dell'addestramento
• Supporto per dati sbilanciati con pesi delle classi

Specifiche Tecniche

• Implementazione pura in MQL5 - nessuna dipendenza esterna
• Ottimizzata per applicazioni di trading
• Gestione e convalida degli errori completa
• Supporto completo per salvare/caricare modelli addestrati
• Documentazione estesa

Istruzioni per l'Integrazione

Per integrare la LSTM Library nel tuo Expert Advisor, segui questi passaggi:

1. Importazione Completa della Libreria

#import "LSTM_Library.ex5"
   // Informazioni sulla Libreria
   void GetLibraryVersion(string &version);
   void GetLibraryInfo(string &info);
   
   // Gestione dei Modelli
   int CreateModel(string name);
   int DeleteModel(int handle);
   
   // Costruzione dei Layer
   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);
   
   // Compilazione e Addestramento
   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);
   
   // Previsione e Valutazione
   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[]);
   
   // Preprocessing dei Dati
   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);
   
   // Callback e Scheduler
   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);
   
   // Utilità
   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. Inizializzazione in OnInit()

int model_handle = 0;

int OnInit()
{
   // Creare modello LSTM
   model_handle = CreateModel("TradingModel");
   if(model_handle <= 0)
      return INIT_FAILED;
      
   // Aggiungere layer
   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;
   
   // Compilare modello (ottimizzatore Adam, perdita MSE)
   if(CompileModel(model_handle, 1, 0.001, 0) <= 0)
      return INIT_FAILED;
   
   // Caricare modello esistente se disponibile
   if(FileIsExist("model.bin"))
      LoadModel(model_handle, "model.bin");
   
   return INIT_SUCCEEDED;
}

3. Pulizia in OnDeinit()

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

4. Utilizzo in OnTick()

void OnTick()
{
   // Preparare caratteristiche
   double features[50];  // Per esempio, 5 caratteristiche * 10 lunghezza sequenza
   
   // Riempire array di caratteristiche con dati di mercato
   // ...
   
   // Fare previsione
   double prediction[];
   if(PredictSingle(model_handle, features, ArraySize(features), prediction) > 0)
   {
      if(prediction[0] > 0.5)
      {
         // Segnale rialzista - piazzare ordine di acquisto
      }
      else
      {
         // Segnale ribassista - piazzare ordine di vendita
      }
   }
}

Funzionalità Avanzate Disponibili

Varianti di Layer Ricorrenti

• AddLSTMLayerEx() - LSTM con dropout ricorrente per una migliore generalizzazione
• AddBiLSTMLayerEx() - BiLSTM bidirezionale con dropout ricorrente

Normalizzazione e Regolarizzazione

• AddBatchNormLayer() - Normalizzazione batch per un addestramento stabile
• AddLayerNormLayer() - Normalizzazione di layer

Gestione dei Dati Sbilanciati

• SetClassWeights() - Imposta pesi per classi minoritarie
• EnableConfusionMatrixTracking() - Monitoraggio dettagliato delle prestazioni per classe

Ottimizzazione Avanzata

• AddCosineScheduler() - Tassi di apprendimento ciclici con warm restart
• AddOneCycleLR() - Implementazione del One-Cycle Learning Rate

Valutazione Completa

• PredictBatch() - Previsioni in batch per maggiore efficienza
• EvaluateModel() - Valutazione completa su dati di test
• CalculateClassificationMetrics() - Metriche dettagliate (precisione, recall, F1)

Preprocessing dei Dati

• CreateScaler/FitScaler - Normalizzazione dei dati di input
• TransformData/InverseTransform - Conversione tra scale

Requisiti

• MetaTrader 5
• Comprensione di base dei concetti di machine learning
• Competenze intermedie di programmazione in MQL5

POTENZIA I TUOI SISTEMI DI TRADING

Trasforma le tue strategie e indicatori esistenti con la potenza dell'apprendimento automatico direttamente in MQL5. Questa integrazione diretta significa niente connessioni esterne, niente dipendenze Python e niente complessità API - solo pura potenza predittiva all'interno della tua piattaforma di trading.

Che tu stia sviluppando sistemi di previsione dei prezzi, previsione della volatilità o riconoscimento avanzato di pattern, LSTM Library fornisce la base per decisioni di trading veramente intelligenti che si adattano alle condizioni di mercato in evoluzione.

Parole chiave: Previsione Azioni LSTM, Previsione Prezzi LSTM, Trading con Reti Neurali, Deep Learning MQL5, Previsione Serie Temporali, Machine Learning Forex, Trading Criptovalute con IA, Riconoscimento Pattern di Mercato, Sistema di Trading BiLSTM, Analisi di Mercato GRU, Trading Algoritmico con IA, MQL5 Deep Learning, Previsione Direzione Prezzo, Machine Learning per HFT