5 Modèles ONNX pour Trading MT5 : LSTM, XGBoost, CNN, Random Forest, Transformer

Cinq architectures de machine learning, cinq cas d’usage de trading réels, toutes exportables vers ONNX et consommables dans les Expert Advisors MT5.

⚠️ Avertissement honnête : Aucun modèle, aussi sophistiqué soit-il, ne garantit le profit. La différence entre trader professionnel et amateur n’est pas dans le modèle — c’est dans le feature engineering, la validation rigoureuse, la gestion du risque et la discipline.

Comparaison rapide

1. Random Forest — le baseline honnête

Framework : Sklearn · Entraînement : minutes · Inférence : < 1 ms

Classification binaire de direction (haut/bas) ou multi-classe. Le premier modèle que tout projet d’IA en trading devrait essayer — si RF avec 200 arbres ne bat pas le hasard (50%), votre problème est dans les features, pas le modèle. S’entraîne en 1 minute.

from sklearn.ensemble import RandomForestClassifier
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

model = RandomForestClassifier(n_estimators=200, max_depth=8)
model.fit(X_train, y_train)

initial_type = [('input', FloatTensorType([None, n_features]))]
onnx_model = convert_sklearn(model, initial_types=initial_type, target_opset=15)

with open("rf.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

2. XGBoost — vainqueur Kaggle appliqué aux marchés

Framework : XGBoost · Inférence : ~1-3 ms

Identique à RF mais typiquement 2-5% plus précis en tabulaire. Brille avec beaucoup de features (50+ indicateurs, orderbook, sentiment). Attention : plus sujet au surapprentissage en séries temporelles — utilisez early_stopping_rounds.

import xgboost as xgb
from onnxmltools.convert import convert_xgboost
from onnxconverter_common.data_types import FloatTensorType

model = xgb.XGBClassifier(n_estimators=300, max_depth=6,
                          learning_rate=0.05, early_stopping_rounds=20)
model.fit(X_train, y_train, eval_set=[(X_val, y_val)])

3. CNN 1D — trouve les motifs visuels

Framework : PyTorch/TF · Inférence : ~1-5 ms

Identifie les motifs locaux dans les séries temporelles — comme un ‘scanner qui cherche des formations de bougie’ mais apprend les motifs lui-même. Fonctionne bien pour les motifs courts 5-30 bougies, surtout les indices synthétiques (Deriv V75). Plus rapide à entraîner que LSTM, s’exporte proprement vers ONNX.

import torch.nn as nn

class CNN1D(nn.Module):
    def __init__(self, in_channels=4, seq_len=30, n_classes=2):
        super().__init__()
        self.conv1 = nn.Conv1d(in_channels, 32, kernel_size=5, padding=2)
        self.conv2 = nn.Conv1d(32, 64, kernel_size=3, padding=1)
        self.pool  = nn.MaxPool1d(2)
        self.fc    = nn.Linear(64 * (seq_len // 4), n_classes)
    
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        return self.fc(x.flatten(1))

4. LSTM / GRU — mémoire pour les longues dépendances

Framework : PyTorch/TF · Inférence : ~2-10 ms

L’architecture ‘standard’ pour séries temporelles avant les Transformers. LSTM garde un état interne (mémoire) portant l’information sur dizaines/centaines de timesteps. Utile pour swing trading H1/H4/D1, régimes de volatilité qui changent lentement. Attention : data leakage facile — toujours split temporel strict, jamais de shuffle. GRU est le petit cousin simple de LSTM, performe souvent égal/mieux avec moins de paramètres.

5. Transformer — quand vous avez besoin de plus

Framework : PyTorch · Inférence : ~10-50 ms

L’architecture qui a dominé le NLP, adaptée aux séries temporelles (Informer, Autoformer, PatchTST). Apprend des relations ‘attention’ entre tous les timesteps simultanément. Brille en multi-actif (prédire EURUSD avec EURUSD + DXY + or + bonds + VIX).

⚠️ Reality check : Le papier ‘Are Transformers Effective for Time Series Forecasting?’ (Zeng et al., AAAI 2023) a montré que de simples MLPs linéaires battent parfois les Transformers. N’utilisez pas Transformer par mode — utilisez-le quand le problème le justifie.

Lequel choisir pour votre projet ?

Pipeline standard pour tout modèle

1. Collecte de données via mt5.copy_rates_from_pos()
2. Feature engineering — retours lagged, indicateurs, contexte
3. Split temporel 80/20 — jamais de shuffle
4. Entraînez sur train, validez sur test holdout
5. Exportez vers ONNX avec l’exportateur du framework
6. Validez avec onnxruntime en Python
7. Intégrez dans l’EA via #resource + OnnxCreateFromBuffer
8. Backtest dans MT5 Strategy Tester
9. Démo trade 30+ jours avec risk management
10. Live avec mise minimale, scaling graduel

Principes universels :
1. Modèle simple qui fonctionne > modèle complexe qui pourrait fonctionner
2. Feature engineering bat l’architecture 9/10 fois
3. Validation temporelle est sacrée — jamais de shuffle
4. Backtest professionnel utilise 6+ mois out-of-sample
5. Gestion du risque tue plus de bots que les mauvais modèles