Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Avancé

Modèles ONNX dans MQL5 : intégrer un modèle de machine learning dans un Expert Advisor

Embarquer un modèle entraîné en Python dans un EA : ressource #resource, OnnxCreateFromBuffer, formes d’entrée et de sortie, OnnxRun et surtout cohérence du prétraitement entre entraînement et production.

Mis à jour le 23 octobre 2026Lecture : 10 minPar Alix, OptiBot Trading

MQL5 sait exécuter directement des modèles au format ONNX (Open Neural Network Exchange), le format ouvert d’échange de modèles d’apprentissage automatique. Le principe est simple : vous entraînez un modèle en Python (avec la bibliothèque de votre choix), vous l’exportez en fichier .onnx, vous l’incluez dans votre Expert Advisor comme ressource, puis vous créez une session avec OnnxCreateFromBuffer, déclarez les formes des tenseurs avec OnnxSetInputShape et OnnxSetOutputShape, exécutez le modèle avec OnnxRun et libérez la session avec OnnxRelease. Le modèle tourne dans le terminal, sans Python ni serveur externe, et peut être testé dans le Strategy Tester comme n’importe quel EA.

Cette page appartient à la rubrique MQL5 avancé. Elle suppose que vous êtes à l’aise avec les types matrix et vector, présentés dans Matrices et vecteurs, car ce sont eux qui transportent les données vers le modèle et depuis celui-ci.

Les fonctions ONNX de MQL5

La documentation officielle liste les fonctions suivantes :

FonctionRôle
OnnxCreatecrée une session à partir d’un fichier .onnx
OnnxCreateFromBuffercrée une session à partir d’un tableau de données
OnnxReleaseferme une session
OnnxRunexécute le modèle
OnnxGetInputCount, OnnxGetOutputCountnombre d’entrées et de sorties
OnnxGetInputName, OnnxGetOutputNamenom d’une entrée ou d’une sortie par indice
OnnxGetInputTypeInfo, OnnxGetOutputTypeInfodescription du type d’une entrée ou d’une sortie
OnnxSetInputShape, OnnxSetOutputShapefixe la forme d’une entrée ou d’une sortie par indice

La signature de création depuis un tampon est long OnnxCreateFromBuffer(const uchar &buffer[], ulong flags). Elle renvoie le handle de la session, ou INVALID_HANDLE en cas d’erreur (le code est alors lisible avec GetLastError()). OnnxRun a la forme bool OnnxRun(long onnx_handle, ulong flags, ...) : après le handle et les drapeaux viennent les entrées puis les sorties du modèle.

Les drapeaux ENUM_ONNX_FLAGS

Les drapeaux se combinent avec l’opérateur |. Les plus utiles :

  • ONNX_LOGLEVEL_VERBOSE, ONNX_LOGLEVEL_INFO, ONNX_LOGLEVEL_WARNING (niveau par défaut) et ONNX_LOGLEVEL_ERROR règlent la quantité de messages journalisés. ONNX_LOGLEVEL_INFO remplace l’ancien drapeau ONNX_DEBUG_LOGS, que vous croiserez encore dans des exemples plus anciens.
  • ONNX_NO_CONVERSION désactive la conversion automatique : vos données sont transmises telles quelles, ce qui impose qu’elles aient exactement le type attendu par le modèle.
  • ONNX_COMMON_FOLDER charge le fichier depuis le dossier commun Common\Files (pour OnnxCreate).
  • ONNX_USE_CPU_ONLY force l’exécution sur le processeur ; ONNX_GPU_DEVICE_0 à ONNX_GPU_DEVICE_7 choisissent un périphérique CUDA.
  • ONNX_ENABLE_PROFILING active un profilage du modèle avec rapport JSON.

Inclure le modèle comme ressource

Plutôt que de livrer le fichier .onnx à côté de l’EA, la pratique recommandée consiste à l’incorporer au fichier compilé grâce à la directive #resource, sous forme de tableau d’octets : #resource "model.onnx" as uchar ExtModel[]. Le chemin est relatif au fichier source. La taille d’une ressource est limitée à 128 Mo, ce qui laisse de la marge pour la plupart des modèles de trading. L’avantage est double : un seul fichier .ex5 à déployer sur votre VPS, et aucun risque de désynchroniser le modèle et le code qui l’utilise.

Exemple complet : prévision normalisée de la prochaine clôture

Supposons un modèle entraîné en Python qui reçoit les 10 dernières bougies H1 (ouverture, plus haut, plus bas, clôture), chaque colonne étant normalisée par sa moyenne et son écart-type sur ces 10 bougies, et qui renvoie la clôture suivante normalisée. Entrée de forme {1,10,4}, sortie de forme {1,1}, en float. C’est la configuration de l’exemple officiel ; adaptez-la à votre modèle.

//+------------------------------------------------------------------+
//| OnnxForecast.mq5 : exécution d'un modèle ONNX dans un EA         |
//+------------------------------------------------------------------+
#resource "model.onnx" as uchar ExtModel[]   // modèle incorporé à l'EX5

#define SAMPLE_SIZE 10                       // nombre de bougies en entrée
#define FEATURES    4                        // O, H, L, C

const ulong ExtInputShape[] ={1,SAMPLE_SIZE,FEATURES};
const ulong ExtOutputShape[]={1,1};
long       g_onnx=INVALID_HANDLE;
datetime   g_last_bar=0;

int OnInit()
  {
   g_onnx=OnnxCreateFromBuffer(ExtModel,ONNX_LOGLEVEL_WARNING);
   if(g_onnx==INVALID_HANDLE)
     {
      Print("OnnxCreateFromBuffer : erreur ",GetLastError());
      return(INIT_FAILED);
     }
   //--- les formes doivent correspondre exactement au modèle exporté
   if(!OnnxSetInputShape(g_onnx,0,ExtInputShape) ||
      !OnnxSetOutputShape(g_onnx,0,ExtOutputShape))
     {
      Print("Forme refusée : erreur ",GetLastError());
      OnnxRelease(g_onnx);
      g_onnx=INVALID_HANDLE;
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   if(g_onnx!=INVALID_HANDLE)
      OnnxRelease(g_onnx);
  }

//--- renvoie la clôture prévue, ou 0 en cas d'échec
double Predict()
  {
   matrix rates;
   //--- 10 bougies clôturées (à partir de la bougie 1), une série par colonne
   if(!rates.CopyRates(_Symbol,PERIOD_H1,COPY_RATES_OHLC|COPY_RATES_VERTICAL,1,SAMPLE_SIZE))
      return(0.0);
   if(rates.Rows()!=SAMPLE_SIZE || rates.Cols()!=FEATURES)
      return(0.0);

   //--- normalisation colonne par colonne, comme à l'entraînement
   double close_mean=0.0,close_std=0.0;
   for(ulong j=0;j<FEATURES;j++)
     {
      vector col=rates.Col(j);
      double m=col.Mean(),s=col.Std();
      if(s==0.0) return(0.0);              // série plate : pas de prévision
      rates.Col((col-m)/s,j);
      if(j==3) { close_mean=m; close_std=s; }
     }

   //--- conversion en float, type attendu par le modèle
   matrixf x;
   x.Assign(rates);
   vectorf y(1);
   if(!OnnxRun(g_onnx,ONNX_NO_CONVERSION,x,y))
     {
      Print("OnnxRun : erreur ",GetLastError());
      return(0.0);
     }
   //--- dénormalisation de la sortie
   return(y[0]*close_std+close_mean);
  }

void OnTick()
  {
   //--- une prévision par nouvelle bougie H1 suffit
   datetime bar=iTime(_Symbol,PERIOD_H1,0);
   if(bar==g_last_bar) return;
   g_last_bar=bar;
   double forecast=Predict();
   if(forecast>0.0)
      PrintFormat("Clôture H1 prévue : %s",DoubleToString(forecast,_Digits));
  }

L’EA calcule une prévision par bougie H1, pas par tick : inutile de solliciter le modèle des dizaines de fois par minute pour une entrée qui ne change qu’à la clôture. La prévision n’est ici qu’affichée ; en faire un signal de trading suppose de définir une règle (par exemple un écart minimal entre prévision et prix actuel) et de la valider comme toute autre stratégie.

Le point critique : le prétraitement

La majorité des échecs d’intégration ne viennent pas des fonctions ONNX mais d’un décalage entre l’entraînement et la production. Le modèle ne connaît que les nombres qu’il a vus pendant l’entraînement. Il faut donc reproduire à l’identique, dans l’EA :

  1. L’ordre des bougies : du plus ancien au plus récent, ou l’inverse ? Vérifiez l’ordre produit par CopyRates côté MQL5 et par votre script Python, et alignez-les.
  2. L’ordre des colonnes : O, H, L, C dans le même ordre qu’à l’entraînement.
  3. La normalisation : même fenêtre, même formule, même écart-type (population ou échantillon : Std() utilise par défaut un diviseur N, comme NumPy par défaut).
  4. Le type : float32 à l’entraînement implique matrixf et vectorf côté MQL5, surtout avec ONNX_NO_CONVERSION.
  5. La bougie en cours : n’utilisez que des bougies clôturées, sinon le modèle reçoit en production des données qu’il n’a jamais vues à l’entraînement.

Un test simple consiste à exporter depuis Python quelques entrées et les sorties attendues, puis à vérifier dans un script MQL5 que le modèle renvoie les mêmes valeurs. Pour récupérer les données d’entraînement directement depuis le terminal, utilisez le module Python MetaTrader5.

Tester un modèle ONNX

Un EA qui embarque un modèle se teste dans le Strategy Tester comme un autre. Mais attention au biais le plus dangereux : tester sur la période qui a servi à l’entraînement. Le modèle y paraîtra excellent puisqu’il a mémorisé ces données. Réservez une période postérieure, jamais vue, et évaluez-y l’EA ; la méthode est expliquée dans Forward testing. Pour les ressources consommées, le drapeau ONNX_ENABLE_PROFILING et le profileur de MetaEditor vous aideront à mesurer le coût d’une inférence.

Pièges fréquents

  • Forme incorrecte : une forme {10,4} au lieu de {1,10,4} fait échouer OnnxRun. Inspectez votre modèle avec OnnxGetInputTypeInfo ou dans un outil de visualisation avant de coder les formes.
  • Oubli de OnnxRelease : libérez la session dans OnDeinit.
  • Opérateurs non pris en charge : certains modèles exportés utilisent des opérateurs exotiques ; testez l’export avec un modèle simple avant d’investir dans une architecture complexe.
  • Sur-apprentissage : un modèle très précis sur l’historique d’entraînement n’a aucune valeur démontrée. Seule la période hors échantillon compte.
Un modèle d’apprentissage automatique ne prédit pas le marché de façon fiable. Ses performances passées, même hors échantillon, ne garantissent rien. Testez-le longuement en démo, avec une gestion du risque stricte, avant tout usage sur un compte réel.

Questions fréquentes

Faut-il installer Python sur le VPS pour exécuter un modèle ONNX ?

Non. Python sert uniquement à entraîner et exporter le modèle. L’exécution se fait dans le terminal MetaTrader 5 via les fonctions ONNX natives ; si le modèle est incorporé comme ressource, seul le fichier .ex5 est à déployer.

Quelle différence entre OnnxCreate et OnnxCreateFromBuffer ?

OnnxCreate charge un fichier .onnx présent sur le disque, OnnxCreateFromBuffer crée la session à partir d’un tableau d’octets, typiquement une ressource incorporée avec #resource ... as uchar Nom[]. La seconde approche est plus robuste pour le déploiement.

Pourquoi OnnxRun renvoie-t-il false ?

Les causes les plus fréquentes sont une forme de tenseur différente de celle du modèle, un type de données inattendu (double au lieu de float avec ONNX_NO_CONVERSION) ou des tailles de matrice incorrectes. Consultez GetLastError() et augmentez le niveau de journalisation avec ONNX_LOGLEVEL_INFO pour obtenir des détails.

Un EA avec modèle ONNX peut-il être publié sur le Market ?

Rien dans les fonctions ONNX ne l’empêche, et le modèle incorporé en ressource est livré dans le fichier EX5. Le produit doit cependant passer la validation automatique et respecter les règles de présentation, notamment l’interdiction de promettre des profits.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.