Fixed-Width Fractional Differencing (FFD) - Indikator für den MetaTrader 5

Rohdaten von Devisen- und Terminkursen sind nichtstationär: Standard-Regressions- und Klassifikationsmodelle, die darauf trainiert werden, sind mit erheblichen Vorausschauverzerrungen und Scheinkorrelationen konfrontiert. Die naive Lösung – die ganzzahlige Differenzierung – beseitigt zwar die Nichtstationarität, zerstört dabei jedoch jegliches Kursgedächtnis und verworfen genau jene Autokorrelationsstruktur, die ein Vorhersagemodell benötigt.

Die in Kapitel 5 von „Advances in Financial Machine Learning“ (López de Prado, 2018) vorgestellte fraktionale Differenzierung mit fester Breite (FFD) löst dieses Problem durch Differenzierung mit einer nicht-ganzzahligen Ordnung d ∈ (0, 1), die gerade ausreicht, um Stationarität zu erreichen, und gleichzeitig ein Maximum an „Memory“ bewahrt. Dieser Beitrag liefert eine produktionsreife MQL5-Implementierung dieser Methode.

Zweifeld-Darstellung der FFD-Ausgabe: nichtstationärer Rohkurs (a) und stationäre FFD-Reihe (b) mit markiertem Lookback-Fenster

Komponenten

• FFDEngine.mqh — reine Header-Bibliothek, die die Klasse CFFDEngine enthält. Bietet Init(), Compute() (einzelner Balken) und ComputeBuffer() (vollständiger Indikatorpuffer mit „prev_calculated“-Optimierung ). Keine dynamische Speicherzuweisung nach OnInit().
• FFD.mq5 – Benutzerdefinierter Indikator, der CFFDEngine umschließt. Zeichnet die FFD-Reihe in einem separaten Chartfenster. Unterstützt alle ENUM_APPLIED_PRICE-W erte.

So funktioniert der Algorithmus

Der Gewichtsvektor wird durch die Rekursionsformel (AFML Gl. 5.4) definiert:

w[0] = 1 w[k] = -w[k-1] * (d - k + 1) / k, k = 1, 2, ...

Die Iteration endet, wenn |w[k]| < Schwellenwert ist. Der Vektor wird anschließend umgekehrt, sodass der älteste Kurs im Rückblickfenster das geringste Gewicht erhält und der neueste Kurs den Wert 1,0. Der FFD-Wert am Balken i ist das Skalarprodukt des umgekehrten Gewichtsvektors mit dem Log-Kurs-Fenster [i−Breite, …, i].

Für d = 0,4 und Schwellenwert = 1e-5 beträgt die Fensterbreite 1 457 Balken. Für Schwellenwert = 1e-3 beträgt sie 54 Balken. Der Schwellenwert steuert den Kompromiss zwischen Stationarität und Gedächtnis: Kleinere Werte bewahren mehr Gedächtnis auf Kosten einer größeren erforderlichen Rückblickperiode.

Eingabeparameter

Installation

1. Kopieren Sie FFDEngine.mqh in Ihren Ordner „MQL5\Include\ “ (oder in den beim CodeBase-Download angegebenen Unterordner – siehe Dateipfade unten).
2. Kopieren Sie FFD.mq5 in den Ord ner „MQL5\Indicators\Downloads\ “ (wird beim Herunterladen von CodeBase automatisch dort abgelegt).
3. Kompilieren Sie beide Dateien im MetaEditor. Der Indikator sollte unter #property strict ohne Warnungen kompiliert werden.
4. Fügen Sie FFD zu einem beliebigen Chart hinzu. Das Indikatorfenster erscheint unterhalb des Hauptcharts, sobald das Rückblickfenster (Breite + 1 Bar) gefüllt ist.

Verwendung von CFFDEngine in Ihrem eigenen EA oder Indikator

FFDEngine.mqh ist eine reine Header-Bibliothek. Binden Sie sie ein und rufen Sie Init() einmal in OnInit() auf:

#include <FFDEngine.mqh>

//--- Globale Instanz der Engine für die fraktionierte Differenzierung mit fester Breite
CFFDEngine g_engine;

//+------------------------------------------------------------------+
//| Initialisierungsfunktion für „Expert“                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- FFD-Engine mit d=0,4, Schwellenwert=1e-5 und aktivierter Log-Transformation initialisieren
//--- Diese Konfiguration erstellt während der Initialisierungsphase des EA ein statisches Speichergewichtsfenster
   if(!g_engine.Init(0.4, 1 e-5, true))
     {
      Print("FFD engine init failed");
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert-Tick-Funktion                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Die Engine abfragen, um herauszufinden, wie viele historische Balken genau benötigt werden
//--- zur Berechnung eines gültigen FFD-Werts auf der Grundlage des Schwellenwerts
   int need = g_engine.GetMinBars();
   double close[];

//--- Die gewünschte Tiefe der historischen Kursdaten abrufen.
//--- Falls der Verlauf noch nicht synchronisiert oder unvollständig ist, wird die Ausführung übersprungen, um Fehler zu vermeiden.
   if(CopyClose(_Symbol, _Period, 0, need, close) < need)
      return;

//--- Sicherstellen, dass die Indizierung des Arrays der chronologischen Reihenfolge entspricht (ältester Balken am Index 0)
//--- zur korrekten Ausrichtung mit den umgekehrten FFD-Gewichtsvektor-Matrix-Transformationen
   ArraySetAsSeries(close, false);

//--- Berechne den stationären, fraktional differenzierten Ausgabewert für den aktuellen Live-Balken
   double ffd_value = g_engine.Compute(close, need);

//--- Verwenden Sie ffd_value als Merkmal für Ihr Modell.
  }

Kreuzvalidierung mit Python

Die Begleitdatei FFDValidation.mq5 (im Download des Artikels verfügbar) exportiert FFD-Werte in eine CSV-Datei. Das Python-Skript ffd_cross_validate.py berechnet dieselben Werte mithilfe der afml-Bibliothek neu und vergleicht sie Bar für Bar. Bei 5.000 Bars des EURUSD-H1-Charts mit d = 0,4 und Schwellenwert = 1e-5 liegt die maximale absolute Differenz unter 1e-12.

Hinweise zur Performance

• Zuweisung des Gewichtsvektors: einmalig in OnInit(). Keine Zuweisung auf dem Tick-Pfad.
• Berechnung pro Bar: O(Breite) Skalarprodukt. Auf moderner Hardware dauert ein Skalarprodukt über 1.457 Elemente weniger als 50 μs.
• ComputeBuffer() verwendet das Argument „prev_calculated“, um bereits berechnete Balken zu überspringen – bei jedem Tick wird nur der aktuelle, noch unvollständige Balken neu berechnet.

Literaturhinweise und Begleitartikel

• López de Prado, M. (2018). Advances in Financial Machine Learning, Kapitel 5 (Fractional Differentiation), S. 76–95. Wiley.
• Vollständige Theorie, Python-Implementierung und ADF-basierte Parametersuche: Feature Engineering für ML – Teil 2: Implementierung der fraktionalen Differentiation mit fester Breite in MQL5 von Patrick M. Njoroge.
• Begleitende Validierungstools: FFDValidation.mq5 und ffd_cross_validate.py – im Download-Paket des Artikels enthalten.