LSTM Library

Professionelle Neuronale Netzwerk-Bibliothek für Algorithmischen Handel

LSTM Library bringt die Leistung rekurrenter neuronaler Netzwerke in Ihre MQL5-Handelsstrategien. Diese professionelle Implementierung umfasst LSTM-, BiLSTM- und GRU-Netzwerke mit fortschrittlichen Funktionen, die typischerweise nur in spezialisierten Machine-Learning-Frameworks zu finden sind.

Hauptmerkmale

• Vollständige Implementierung von LSTM, BiLSTM und GRU
• Rekurrenter Dropout für bessere Generalisierung
• Mehrere Optimierungsalgorithmen (Adam, AdamW, RAdam)
• Fortgeschrittene Normalisierungstechniken
• Umfassendes Metriken-Bewertungssystem
• Visualisierung des Trainingsfortschritts
• Unterstützung für unausgewogene Daten mit Klassengewichten

Technische Spezifikationen

• Reine MQL5-Implementierung - keine externen Abhängigkeiten
• Optimiert für Handelsanwendungen
• Umfassende Fehlerbehandlung und Validierung
• Vollständige Unterstützung zum Speichern/Laden trainierter Modelle
• Umfangreiche Dokumentation

Integrationsanweisungen

Um die LSTM Library in Ihren Expert Advisor zu integrieren, folgen Sie diesen Schritten:

1. Vollständiger Bibliotheksimport

#import "LSTM_Library.ex5"
   // Bibliotheksinformationen
   void GetLibraryVersion(string &version);
   void GetLibraryInfo(string &info);
   
   // Modellverwaltung
   int CreateModel(string name);
   int DeleteModel(int handle);
   
   // Schichterstellung
   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);
   
   // Kompilierung und Training
   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);
   
   // Vorhersage und Bewertung
   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[]);
   
   // Datenvorverarbeitung
   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 und 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);
   
   // Hilfsfunktionen
   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. Initialisierung in OnInit()

int model_handle = 0;

int OnInit()
{
   // LSTM-Modell erstellen
   model_handle = CreateModel("TradingModel");
   if(model_handle <= 0)
      return INIT_FAILED;
      
   // Schichten hinzufügen
   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;
   
   // Modell kompilieren (Adam-Optimierer, MSE-Verlust)
   if(CompileModel(model_handle, 1, 0.001, 0) <= 0)
      return INIT_FAILED;
   
   // Vorhandenes Modell laden, falls verfügbar
   if(FileIsExist("model.bin"))
      LoadModel(model_handle, "model.bin");
   
   return INIT_SUCCEEDED;
}

3. Bereinigung in OnDeinit()

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

4. Verwendung in OnTick()

void OnTick()
{
   // Merkmale vorbereiten
   double features[50];  // Zum Beispiel 5 Merkmale * 10 Sequenzlänge
   
   // Feature-Array mit Marktdaten füllen
   // ...
   
   // Vorhersage treffen
   double prediction[];
   if(PredictSingle(model_handle, features, ArraySize(features), prediction) > 0)
   {
      if(prediction[0] > 0.5)
      {
         // Bullisches Signal - Kaufauftrag platzieren
      }
      else
      {
         // Bärisches Signal - Verkaufsauftrag platzieren
      }
   }
}

Verfügbare erweiterte Funktionen

Varianten rekurrenter Schichten

• AddLSTMLayerEx() - LSTM mit rekkurentem Dropout für bessere Generalisierung
• AddBiLSTMLayerEx() - Bidirektionales BiLSTM mit rekkurentem Dropout

Normalisierung und Regularisierung

• AddBatchNormLayer() - Batch-Normalisierung für stabiles Training
• AddLayerNormLayer() - Layer-Normalisierung

Umgang mit unausgewogenen Daten

• SetClassWeights() - Gewichte für Minderheitsklassen festlegen
• EnableConfusionMatrixTracking() - Detaillierte Leistungsüberwachung nach Klasse

Fortgeschrittene Optimierung

• AddCosineScheduler() - Zyklische Lernraten mit Warm Restarts
• AddOneCycleLR() - One-Cycle-Lernrate-Implementierung

Umfassende Bewertung

• PredictBatch() - Batch-Vorhersagen für höhere Effizienz
• EvaluateModel() - Vollständige Bewertung mit Testdaten
• CalculateClassificationMetrics() - Detaillierte Metriken (Präzision, Recall, F1)

Datenvorverarbeitung

• CreateScaler/FitScaler - Normalisierung von Eingabedaten
• TransformData/InverseTransform - Konvertierung zwischen Skalen

Anforderungen

• MetaTrader 5
• Grundlegendes Verständnis von Machine-Learning-Konzepten
• Mittlere MQL5-Programmierfähigkeiten

STÄRKEN SIE IHRE HANDELSSYSTEME

Transformieren Sie Ihre bestehenden Strategien und Indikatoren mit der Leistung des maschinellen Lernens direkt in MQL5. Diese direkte Integration bedeutet keine externen Verbindungen, keine Python-Abhängigkeiten und keine API-Komplexität - nur reine Vorhersagekraft innerhalb Ihrer Handelsplattform.

Ob Sie Preisvorhersagesysteme, Volatilitätsvorhersagen oder fortgeschrittene Mustererkennung entwickeln - die LSTM Library bietet die Grundlage für wirklich intelligente Handelsentscheidungen, die sich an verändernde Marktbedingungen anpassen.

Schlüsselwörter: LSTM-Aktienvorhersage, LSTM-Preisvorhersage, Neuronale-Netzwerk-Handel, MQL5-Deep-Learning, Zeitreihenvorhersage, Forex-maschinelles-Lernen, Kryptowährungs-KI-Handel, Marktmustererkennung, BiLSTM-Handelssystem, GRU-Marktanalyse, KI-algorithmischer-Handel, MQL5-Deep-Learning, Preisrichtungsvorhersage, Maschinelles Lernen für HFT