| //+------------------------------------------------------------------+
|
| //| ONNX.Price.Prediction.Test.mq5 |
|
| //| Copyright 2023, MetaQuotes Ltd. |
|
| //| https://www.mql5.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2023, MetaQuotes Ltd."
|
| #property link "https://www.mql5.com"
|
| #property version "1.00"
|
| #property description "Evaluation of the quality of the next Close price prediction by Python\\model.onnx.\n"
|
| "Start in strategy tester on EURUSD,H1, open prices, from 2023.01.01 to 2023.02.01"
|
|
|
| #resource "Python/model.onnx" as uchar ExtModel[]
|
|
|
| #define SAMPLE_SIZE 10 // bars count in sample as defined in Python\PricePredictionTraining.py
|
| // X, y = collect_dataset(df, history_size=10)
|
|
|
| long ExtHandle=INVALID_HANDLE;
|
| double ExtPredicted=0;
|
| datetime ExtNextBar=0;
|
| long ExtTests=0;
|
| long ExtRightDirection=0;
|
| double ExtSumAbsoluteError=0.0;
|
| //+------------------------------------------------------------------+
|
| //| Expert initialization function |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| /*
|
| if(Symbol()!="EURUSD" || Period()!=PERIOD_H1)
|
| {
|
| Print("model must work with EURUSD,H1");
|
| return(INIT_FAILED);
|
| }
|
| */
|
| //--- create a model from static buffer
|
| ExtHandle=OnnxCreateFromBuffer(ExtModel,ONNX_DEFAULT);
|
| if(ExtHandle==INVALID_HANDLE)
|
| {
|
| Print("OnnxCreateFromBuffer error ",GetLastError());
|
| return(INIT_FAILED);
|
| }
|
| //--- since not all sizes defined in the input tensor we must set them explicitly
|
| //--- first index - batch size, second index - series size, third index - number of series (OHLC)
|
| const long input_shape[] = {1,SAMPLE_SIZE,4};
|
| if(!OnnxSetInputShape(ExtHandle,0,input_shape))
|
| {
|
| Print("OnnxSetInputShape error ",GetLastError());
|
| return(INIT_FAILED);
|
| }
|
| //--- since not all sizes defined in the output tensor we must set them explicitly
|
| //--- first index - batch size, must match the batch size of the input tensor
|
| //--- second index - number of predicted prices (we only predict Close)
|
| const long output_shape[] = {1,1};
|
| if(!OnnxSetOutputShape(ExtHandle,0,output_shape))
|
| {
|
| Print("OnnxSetOutputShape error ",GetLastError());
|
| return(INIT_FAILED);
|
| }
|
| //---
|
| return(INIT_SUCCEEDED);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Expert deinitialization function |
|
| //+------------------------------------------------------------------+
|
| void OnDeinit(const int reason)
|
| {
|
| if(ExtHandle!=INVALID_HANDLE)
|
| {
|
| OnnxRelease(ExtHandle);
|
| ExtHandle=INVALID_HANDLE;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Expert tick function |
|
| //+------------------------------------------------------------------+
|
| void OnTick()
|
| {
|
| //--- check new bar
|
| if(TimeCurrent()<ExtNextBar)
|
| return;
|
| ExtTests++;
|
| //--- set next bar time
|
| ExtNextBar=TimeCurrent();
|
| ExtNextBar-=ExtNextBar%PeriodSeconds();
|
| ExtNextBar+=PeriodSeconds();
|
| //--- check predicted price
|
| CheckPredicted();
|
| //--- predict next price
|
| PredictPrice();
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Check predicted price |
|
| //+------------------------------------------------------------------+
|
| void CheckPredicted(void)
|
| {
|
| if(ExtPredicted!=0.0)
|
| {
|
| static double closes[2];
|
| static datetime times[2];
|
| if(CopyClose(Symbol(),Period(),1,2,closes)==2 && CopyTime(Symbol(),Period(),1,2,times)==2)
|
| {
|
| ExtSumAbsoluteError+=MathAbs(ExtPredicted-closes[1]);
|
| double delta_predict=ExtPredicted-closes[0];
|
| double delta_actual=closes[1]-closes[0];
|
| if((delta_predict>0 && delta_actual>0) || (delta_predict<0 && delta_actual<0))
|
| ExtRightDirection++;
|
| Print("----------------------------------");
|
| Print("times[0]: ", times[0], "; closes[0]: ", closes[0], "; times[1]: ", times[1], "; closes[1]: ", closes[1]);
|
| Print("ExtPredicted: ", ExtPredicted, "; ExtSumAbsoluteError (ExtPredicted-closes[1]): ", ExtSumAbsoluteError, "; delta_predict (ExtPredicted-closes[0]): ", delta_predict, "; delta_actual (closes[1]-closes[0]): ", delta_actual, "; ExtRightDirection: ", ExtRightDirection, "; ExtTests: ", ExtTests);
|
| }
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Predict next price |
|
| //+------------------------------------------------------------------+
|
| void PredictPrice(void)
|
| {
|
| static matrixf input_data(SAMPLE_SIZE,4); // matrix for prepared input data
|
| static vectorf output_data(1); // vector to get result
|
| static matrix mm(SAMPLE_SIZE,4); // matrix of horizontal vectors Mean
|
| static matrix ms(SAMPLE_SIZE,4); // matrix of horizontal vectors Std
|
| static matrix x_norm(SAMPLE_SIZE,4); // matrix for prices normalize
|
| //--- prepare input data
|
| matrix rates;
|
| //--- request last bars
|
| if(!rates.CopyRates(Symbol(),PERIOD_D1,COPY_RATES_OHLC,1,SAMPLE_SIZE))
|
| {
|
| ExtPredicted=0.0;
|
| return;
|
| }
|
| //--- get series Mean
|
| vector m=rates.Mean(1);
|
| //--- get series Std
|
| vector s=rates.Std(1);
|
| //--- prepare matrices for prices normalization
|
| for(int i=0; i<SAMPLE_SIZE; i++)
|
| {
|
| mm.Row(m,i);
|
| ms.Row(s,i);
|
| }
|
| //--- the input of the model must be a set of vertical OHLC vectors
|
| x_norm=rates.Transpose();
|
| //--- normalize prices
|
| x_norm-=mm;
|
| x_norm/=ms;
|
| //--- run the inference
|
| input_data.Assign(x_norm);
|
| if(!OnnxRun(ExtHandle,ONNX_NO_CONVERSION,input_data,output_data))
|
| {
|
| ExtPredicted=0.0;
|
| return;
|
| }
|
| //--- denormalize the price from the output value
|
| ExtPredicted=output_data[0]*s[3]+m[3];
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Tester function |
|
| //+------------------------------------------------------------------+
|
| double OnTester()
|
| {
|
| double mae=ExtSumAbsoluteError/ExtTests;
|
| Print("mae = ",mae);
|
| double right_directions=(ExtRightDirection*100.0)/ExtTests;
|
| PrintFormat("right_directions = %.2f%%",right_directions);
|
| //---
|
| return(right_directions);
|
| }
|
| //+------------------------------------------------------------------+
|
