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.
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 :
| Fonction | Rôle |
|---|---|
OnnxCreate | crée une session à partir d’un fichier .onnx |
OnnxCreateFromBuffer | crée une session à partir d’un tableau de données |
OnnxRelease | ferme une session |
OnnxRun | exécute le modèle |
OnnxGetInputCount, OnnxGetOutputCount | nombre d’entrées et de sorties |
OnnxGetInputName, OnnxGetOutputName | nom d’une entrée ou d’une sortie par indice |
OnnxGetInputTypeInfo, OnnxGetOutputTypeInfo | description du type d’une entrée ou d’une sortie |
OnnxSetInputShape, OnnxSetOutputShape | fixe 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) etONNX_LOGLEVEL_ERRORrèglent la quantité de messages journalisés.ONNX_LOGLEVEL_INFOremplace l’ancien drapeauONNX_DEBUG_LOGS, que vous croiserez encore dans des exemples plus anciens.ONNX_NO_CONVERSIONdé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_FOLDERcharge le fichier depuis le dossier communCommon\Files(pourOnnxCreate).ONNX_USE_CPU_ONLYforce l’exécution sur le processeur ;ONNX_GPU_DEVICE_0àONNX_GPU_DEVICE_7choisissent un périphérique CUDA.ONNX_ENABLE_PROFILINGactive 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 :
- L’ordre des bougies : du plus ancien au plus récent, ou l’inverse ? Vérifiez l’ordre produit par
CopyRatescôté MQL5 et par votre script Python, et alignez-les. - L’ordre des colonnes : O, H, L, C dans le même ordre qu’à l’entraînement.
- 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). - Le type :
float32à l’entraînement impliquematrixfetvectorfcôté MQL5, surtout avecONNX_NO_CONVERSION. - 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 avecOnnxGetInputTypeInfoou dans un outil de visualisation avant de coder les formes. - Oubli de
OnnxRelease: libérez la session dansOnDeinit. - 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.
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.
- Programmation orientée objet : classes
- Héritage et polymorphisme
- La bibliothèque standard
- Matrices et vecteurs
- Le module Python MetaTrader5
- Lire et écrire des fichiers CSV
- Bases de données SQLite
- WebRequest et API externes
- Importer des DLL
- Le calendrier économique en MQL5
- Profiler et optimiser son code
- Versionner son code (MQL5 Algo Forge)
- Publier un produit sur le Market MQL5
