LSTM Library

Biblioteca Profesional de Redes Neuronales para Trading Algorítmico

LSTM Library trae el poder de las redes neuronales recurrentes a sus estrategias de trading en MQL5. Esta implementación de nivel profesional incluye redes LSTM, BiLSTM y GRU con características avanzadas típicamente encontradas solo en frameworks especializados de aprendizaje automático.

Características Principales

• Implementación completa de LSTM, BiLSTM y GRU
• Dropout recurrente para mejor generalización
• Múltiples algoritmos de optimización (Adam, AdamW, RAdam)
• Técnicas avanzadas de normalización
• Sistema integral de evaluación de métricas
• Visualización del progreso de entrenamiento
• Soporte para datos desbalanceados con pesos de clase

Especificaciones Técnicas

• Implementación pura en MQL5 - sin dependencias externas
• Optimizada para aplicaciones de trading
• Tratamiento y validación integral de errores
• Soporte completo para guardar/cargar modelos entrenados
• Documentación extensa

Instrucciones de Integración

Para integrar LSTM Library en su Expert Advisor, siga estos pasos:

1. Importación Completa de la Biblioteca

#import "LSTM_Library.ex5"
   // Información de la Biblioteca
   void GetLibraryVersion(string &version);
   void GetLibraryInfo(string &info);
   
   // Gestión de Modelos
   int CreateModel(string name);
   int DeleteModel(int handle);
   
   // Construcción de Capas
   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);
   
   // Compilación y Entrenamiento
   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);
   
   // Predicción y Evaluación
   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[]);
   
   // Preprocesamiento de Datos
   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 y Planificadores
   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);
   
   // Utilidades
   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. Inicialización en OnInit()

int model_handle = 0;

int OnInit()
{
   // Crear modelo LSTM
   model_handle = CreateModel("TradingModel");
   if(model_handle <= 0)
      return INIT_FAILED;
      
   // Agregar capas
   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;
   
   // Compilar modelo (optimizador Adam, pérdida MSE)
   if(CompileModel(model_handle, 1, 0.001, 0) <= 0)
      return INIT_FAILED;
   
   // Cargar modelo existente si está disponible
   if(FileIsExist("model.bin"))
      LoadModel(model_handle, "model.bin");
   
   return INIT_SUCCEEDED;
}

3. Limpieza en OnDeinit()

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

4. Uso en OnTick()

void OnTick()
{
   // Preparar características
   double features[50];  // Por ejemplo, 5 características * 10 longitud de secuencia
   
   // Llenar array de características con datos del mercado
   // ...
   
   // Hacer predicción
   double prediction[];
   if(PredictSingle(model_handle, features, ArraySize(features), prediction) > 0)
   {
      if(prediction[0] > 0.5)
      {
         // Señal alcista - colocar orden de compra
      }
      else
      {
         // Señal bajista - colocar orden de venta
      }
   }
}

Características Avanzadas Disponibles

Variantes de Capas Recurrentes

• AddLSTMLayerEx() - LSTM con dropout recurrente para mejor generalización
• AddBiLSTMLayerEx() - BiLSTM bidireccional con dropout recurrente

Normalización y Regularización

• AddBatchNormLayer() - Normalización por lotes para entrenamiento estable
• AddLayerNormLayer() - Normalización por capas

Manejo de Datos Desbalanceados

• SetClassWeights() - Establece pesos para clases minoritarias
• EnableConfusionMatrixTracking() - Monitoreo detallado del rendimiento por clase

Optimización Avanzada

• AddCosineScheduler() - Tasas de aprendizaje cíclicas con reinicios calientes
• AddOneCycleLR() - Implementación de One-Cycle Learning Rate

Evaluación Completa

• PredictBatch() - Predicciones por lotes para mayor eficiencia
• EvaluateModel() - Evaluación completa en datos de prueba
• CalculateClassificationMetrics() - Métricas detalladas (precisión, recall, F1)

Preprocesamiento de Datos

• CreateScaler/FitScaler - Normalización de datos de entrada
• TransformData/InverseTransform - Conversión entre escalas

Requisitos

• MetaTrader 5
• Entendimiento básico de conceptos de machine learning
• Habilidades intermedias de programación en MQL5

POTENCIE SUS SISTEMAS DE TRADING

Transforme sus estrategias e indicadores existentes con el poder del aprendizaje automático directamente en MQL5. Esta integración directa significa sin conexiones externas, sin dependencias Python y sin complejidades de API - solo poder predictivo puro dentro de su plataforma de trading.

Ya sea que esté desarrollando sistemas de predicción de precios, previsión de volatilidad o reconocimiento avanzado de patrones, LSTM Library proporciona la base para decisiones de trading verdaderamente inteligentes que se adaptan a las condiciones cambiantes del mercado.

Palabras clave: Predicción de Acciones LSTM, Predicción de Precios LSTM, Trading con Redes Neuronales, Deep Learning MQL5, Previsión de Series Temporales, Machine Learning Forex, Trading de Criptomonedas con IA, Reconocimiento de Patrones de Mercado, Sistema de Trading BiLSTM, Análisis de Mercado GRU, Trading Algorítmico con IA, MQL5 Deep Learning, Predicción de Dirección de Precio, Machine Learning para HFT