Fixed-Width Fractional Differencing (FFD) - indicateur pour MetaTrader 5

Les cours bruts du Forex et des contrats à terme sont non stationnaires : les modèles standard de régression et de classification entraînés sur ces données sont confrontés à un biais d’anticipation important et à des corrélations fallacieuses. La solution naïve — la différenciation en nombres entiers — élimine la non-stationnarité mais détruit toute la mémoire des cours au passage, supprimant ainsi la structure d’autocorrélation dont un modèle prédictif a justement besoin.

La différenciation fractionnaire à largeur fixe (FFD), présentée au chapitre 5 de l’ouvrage *Advances in Financial Machine Learning* (López de Prado, 2018), résout ce problème en effectuant une différenciation d’ordre non entier d ∈ (0, 1), juste suffisante pour assurer la stationnarité tout en conservant un maximum de mémoire. Cette contribution fournit une implémentation MQL5 de qualité opérationnelle de cette méthode.

Illustration en deux panneaux du résultat de la FFD : cours brut non stationnaire (a) et série FFD stationnaire (b) avec la fenêtre de rétrospective indiquée

Composants

• FFDEngine.mqh — Bibliothèque « header-only » contenant la classe CFFDEngine. Fournit les fonctions Init(), Compute() (une seule barre) et ComputeBuffer() (tampon complet de l’indicateur avec optimisation « prev_calculated » ). Aucune allocation dynamique de mémoire après OnInit().
• FFD.mq5 — Indicateur personnalisé qui encapsule CFFDEngine. Trace la série FFD dans une fenêtre de graphique distincte. Prend en charge toutes les valeurs ENUM_APPLIED_PRICE.

Fonctionnement de l’algorithme

Le vecteur de poids est défini par la récurrence (équation 5.4 de l’AFML) :

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

L'itération s'arrête lorsque |w[k]| < seuil. Le vecteur est ensuite inversé de sorte que le cours le plus ancien de la fenêtre de rétrospective reçoive le poids le plus faible et que le cours le plus récent reçoive 1,0. La valeur FFD à la barre i correspond au produit scalaire du vecteur de poids inversé et de la fenêtre de cours logarithmiques [i−largeur, …, i].

Pour d = 0,4 et seuil = 1e-5, la largeur de la fenêtre est de 1 457 barres. Pour un seuil = 1e-3, elle est de 54 barres. Le seuil contrôle le compromis entre stationnarité et mémoire : des valeurs plus faibles préservent davantage de mémoire au prix d’une fenêtre rétrospective plus large.

Paramètres d’entrée

Installation

1. Copiez FFDEngine.mqh dans votre dossier MQL5\Include\ (ou dans le sous-dossier spécifié lors du téléchargement depuis CodeBase — voir les emplacements des fichiers ci-dessous).
2. Copiez FFD.mq5 dans le dossier MQL5\Indicators\Downloads\ (il y est placé automatiquement lors du téléchargement depuis CodeBase).
3. Compilez les deux fichiers dans MetaEditor. L’indicateur devrait se compiler sans avertissement sous #property strict.
4. Ajoutez FFD à n'importe quel graphique. La fenêtre de l'indicateur apparaîtra sous le graphique principal une fois que la fenêtre de rétrospective (largeur + 1 barre) aura été remplie.

Utilisation de CFFDEngine dans votre propre EA ou indicateur

FFDEngine.mqh est une bibliothèque « header-only ». Incluez-la et appelez Init() une fois dans OnInit():

#include <FFDEngine.mqh>

//--- Instance globale du moteur de différenciation fractionnaire à largeur fixe
CFFDEngine g_engine;

//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Initialisation du moteur FFD avec d = 0,4, seuil = 1e-5 et transformation logarithmique activée
//--- Cette configuration crée une fenêtre de pondération de mémoire statique pendant la phase d'initialisation de l'EA
   if(!g_engine.Init(0.4, 1 e-5, true))
     {
      Print("FFD engine init failed");
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Fonction « tick » d'Expert                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Interroger le moteur pour déterminer exactement le nombre de barres historiques nécessaires
//--- pour calculer une valeur FFD valide en fonction du seuil de coupure
   int need = g_engine.GetMinBars();
   double close[];

//--- Récupérer l'historique des cours sur la période souhaitée.
//--- Si l'historique n'est pas encore synchronisé ou s'il est insuffisant, ignorer l'exécution pour éviter les erreurs.
   if(CopyClose(_Symbol, _Period, 0, need, close) < need)
      return;

//--- S'assurer que l'indexation du tableau correspond à l'ordre chronologique (le graphique le plus ancien à l'index 0)
//--- pour s'aligner correctement avec les transformations de la matrice du vecteur de poids FFD inversée
   ArraySetAsSeries(close, false);

//--- Calculer la valeur de sortie stationnaire, obtenue par différences fractionnaires, pour la barre actuelle
   double ffd_value = g_engine.Compute(close, need);

//--- Utilisez ffd_value comme caractéristique pour votre modèle.
  }

Validation croisée avec Python

Le fichier associé FFDValidation.mq5 (disponible dans le téléchargement de l’article) exporte les valeurs FFD vers un fichier CSV. Le script Python ffd_cross_validate.py recalcule les mêmes valeurs à l’aide de la bibliothèque afml et effectue une comparaison barre par barre. Sur 5 000 barres de l’EURUSD en H1 avec d = 0,4 et un seuil = 1e-5, la différence absolue maximale est inférieure à 1e-12.

Remarques sur les performances

• Allocation du vecteur de poids : une seule fois dans OnInit(). Aucune allocation sur le chemin des ticks.
• Calcul par barre : produit scalaire de complexité O(largeur). Sur du matériel moderne, un produit scalaire sur 1 457 éléments s’effectue en moins de 50 μs.
• La fonction ComputeBuffer() utilise l’argument prev_calculated pour ignorer les barres déjà calculées — seule la barre incomplète actuelle est recalculée à chaque tick.

Références et article associé

• López de Prado, M. (2018). Advances in Financial Machine Learning, chapitre 5 (Différentiation fractionnaire), pp. 76–95. Wiley.
• Théorie complète, implémentation en Python et recherche de paramètres basée sur l’ADF : Feature Engineering for ML — Partie 2 : Implémentation de la différentiation fractionnaire à largeur fixe en MQL5 par Patrick M. Njoroge.
• Outils de validation complémentaires : FFDValidation.mq5 et ffd_cross_validate.py — inclus dans le pack de téléchargement de l’article.