LSTM Library

Biblioteca Profissional de Redes Neurais para Trading Algorítmico

LSTM Library traz o poder das redes neurais recorrentes para suas estratégias de trading em MQL5. Esta implementação de nível profissional inclui redes LSTM, BiLSTM e GRU com recursos avançados tipicamente encontrados apenas em frameworks especializados de machine learning.

Recursos Principais

• Implementação completa de LSTM, BiLSTM e GRU
• Dropout recorrente para melhor generalização
• Múltiplos algoritmos de otimização (Adam, AdamW, RAdam)
• Técnicas avançadas de normalização
• Sistema abrangente de avaliação de métricas
• Visualização do progresso de treinamento
• Suporte para dados desbalanceados com pesos de classe

Especificações Técnicas

• Implementação pura em MQL5 - sem dependências externas
• Otimizada para aplicações de trading
• Tratamento e validação abrangente de erros
• Suporte completo para salvar/carregar modelos treinados
• Documentação extensa

Instruções de Integração

Para integrar a LSTM Library ao seu Expert Advisor, siga estes passos:

1. Importação Completa da Biblioteca

#import "LSTM_Library.ex5"
   // Informações da Biblioteca
   void GetLibraryVersion(string &version);
   void GetLibraryInfo(string &info);
   
   // Gerenciamento de Modelos
   int CreateModel(string name);
   int DeleteModel(int handle);
   
   // Construção de Camadas
   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);
   
   // Compilação e Treinamento
   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);
   
   // Predição e Avaliação
   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é-processamento de Dados
   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 e Schedulers
   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ários
   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. Inicialização em OnInit()

int model_handle = 0;

int OnInit()
{
   // Criar modelo LSTM
   model_handle = CreateModel("TradingModel");
   if(model_handle <= 0)
      return INIT_FAILED;
      
   // Adicionar camadas
   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 (otimizador Adam, perda MSE)
   if(CompileModel(model_handle, 1, 0.001, 0) <= 0)
      return INIT_FAILED;
   
   // Carregar modelo existente se disponível
   if(FileIsExist("model.bin"))
      LoadModel(model_handle, "model.bin");
   
   return INIT_SUCCEEDED;
}

3. Limpeza em OnDeinit()

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

4. Uso em OnTick()

void OnTick()
{
   // Preparar características
   double features[50];  // Por exemplo, 5 características * 10 comprimento de sequência
   
   // Preencher array de características com dados do mercado
   // ...
   
   // Fazer predição
   double prediction[];
   if(PredictSingle(model_handle, features, ArraySize(features), prediction) > 0)
   {
      if(prediction[0] > 0.5)
      {
         // Sinal de alta - colocar ordem de compra
      }
      else
      {
         // Sinal de baixa - colocar ordem de venda
      }
   }
}

Recursos Avançados Disponíveis

Variantes de Camadas Recorrentes

• AddLSTMLayerEx() - LSTM com dropout recorrente para melhor generalização
• AddBiLSTMLayerEx() - BiLSTM bidirecional com dropout recorrente

Normalização e Regularização

• AddBatchNormLayer() - Normalização em batch para treinamento estável
• AddLayerNormLayer() - Normalização por camada

Tratamento de Dados Desbalanceados

• SetClassWeights() - Define pesos para classes minoritárias
• EnableConfusionMatrixTracking() - Monitora detalhadamente o desempenho por classe

Otimização Avançada

• AddCosineScheduler() - Taxas de aprendizado cíclicas com warm restarts
• AddOneCycleLR() - Implementação do One-Cycle Learning Rate

Avaliação Completa

• PredictBatch() - Previsões em lote para maior eficiência
• EvaluateModel() - Avaliação completa em dados de teste
• CalculateClassificationMetrics() - Métricas detalhadas (precisão, recall, F1)

Pré-processamento de Dados

• CreateScaler/FitScaler - Normalização de dados de entrada
• TransformData/InverseTransform - Conversão entre escalas

Requisitos

• MetaTrader 5
• Entendimento básico de conceitos de machine learning
• Habilidades intermediárias de programação em MQL5

POTENCIALIZE SEUS SISTEMAS DE TRADING

Transforme suas estratégias e indicadores existentes com o poder do aprendizado de máquina diretamente em MQL5. Esta integração direta significa sem conexões externas, sem dependências Python e sem complexidades de API - apenas poder preditivo puro dentro da sua plataforma de trading.

Se você está desenvolvendo sistemas de previsão de preços, previsão de volatilidade ou reconhecimento avançado de padrões, LSTM Library fornece a base para decisões de trading verdadeiramente inteligentes que se adaptam às condições de mercado em mudança.

Palavras-chave: Previsão de Ações LSTM, Previsão de Preços LSTM, Trading com Redes Neurais, Deep Learning MQL5, Previsão de Séries Temporais, Machine Learning Forex, Trading de Criptomoedas com IA, Reconhecimento de Padrões de Mercado, Sistema de Trading BiLSTM, Análise de Mercado GRU, Trading Algorítmico com IA, MQL5 Deep Learning, Previsão de Direção de Preço, Machine Learning para HFT