848 lines
32 KiB
MQL5
848 lines
32 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| Scikit.Regression.ONNX.mq5 |
| |||
//| Copyright 2023, MetaQuotes Ltd. |
| |||
//| https://www.mql5.com |
| |||
//+------------------------------------------------------------------+
| |||
#define TestFloatModel 1
| |||
#define TestDoubleModel 2
| |||
//---
| |||
#resource "models\\ard_regression_float.onnx" as const uchar ExtModelARDRegressionF[];
| |||
#resource "models\\ard_regression_double.onnx" as const uchar ExtModelARDRegressionD[];
| |||
#resource "models\\bayesian_ridge_float.onnx" as const uchar ExtModelBayesianRidgeF[];
| |||
#resource "models\\bayesian_ridge_double.onnx" as const uchar ExtModelBayesianRidgeD[];
| |||
#resource "models\\elastic_net_float.onnx" as const uchar ExtModelElasticNetF[];
| |||
#resource "models\\elastic_net_double.onnx" as const uchar ExtModelElasticNetD[];
| |||
#resource "models\\elastic_net_cv_float.onnx" as const uchar ExtModelElasticNetCVF[];
| |||
#resource "models\\elastic_net_cv_double.onnx" as const uchar ExtModelElasticNetCVD[];
| |||
#resource "models\\huber_regressor_float.onnx" as const uchar ExtModelHuberRegressorF[];
| |||
#resource "models\\huber_regressor_double.onnx" as const uchar ExtModelHuberRegressorD[];
| |||
#resource "models\\lars_float.onnx" as const uchar ExtModelLarsF[];
| |||
#resource "models\\lars_double.onnx" as const uchar ExtModelLarsD[];
| |||
#resource "models\\lars_cv_float.onnx" as const uchar ExtModelLarsCVF[];
| |||
#resource "models\\lars_cv_double.onnx" as const uchar ExtModelLarsCVD[];
| |||
#resource "models\\lasso_float.onnx" as const uchar ExtModelLassoF[];
| |||
#resource "models\\lasso_double.onnx" as const uchar ExtModelLassoD[];
| |||
#resource "models\\lasso_cv_float.onnx" as const uchar ExtModelLassoCVF[];
| |||
#resource "models\\lasso_cv_double.onnx" as const uchar ExtModelLassoCVD[];
| |||
#resource "models\\lasso_lars_float.onnx" as const uchar ExtModelLassoLarsF[];
| |||
#resource "models\\lasso_lars_double.onnx" as const uchar ExtModelLassoLarsD[];
| |||
#resource "models\\lasso_lars_cv_float.onnx" as const uchar ExtModelLassoLarsCVF[];
| |||
#resource "models\\lasso_lars_cv_double.onnx" as const uchar ExtModelLassoLarsCVD[];
| |||
#resource "models\\lasso_lars_ic_float.onnx" as const uchar ExtModelLassoLarsICF[];
| |||
#resource "models\\lasso_lars_ic_double.onnx" as const uchar ExtModelLassoLarsICD[];
| |||
#resource "models\\linear_regression_float.onnx" as const uchar ExtModelLinearRegressionF[];
| |||
#resource "models\\linear_regression_double.onnx" as const uchar ExtModelLinearRegressionD[];
| |||
#resource "models\\ridge_float.onnx" as const uchar ExtModelRidgeF[];
| |||
#resource "models\\ridge_double.onnx" as const uchar ExtModelRidgeD[];
| |||
#resource "models\\ridge_cv_float.onnx" as const uchar ExtModelRidgeCVF[];
| |||
#resource "models\\ridge_cv_double.onnx" as const uchar ExtModelRidgeCVD[];
| |||
#resource "models\\orthogonal_matching_pursuit_float.onnx" as const uchar ExtModelOMPF[];
| |||
#resource "models\\orthogonal_matching_pursuit_double.onnx" as const uchar ExtModelOMPD[];
| |||
#resource "models\\passive_aggressive_regressor_float.onnx" as const uchar ExtModelPAD[];
| |||
#resource "models\\passive_aggressive_regressor_double.onnx" as const uchar ExtModelPAF[];
| |||
#resource "models\\quantile_regressor_float.onnx" as const uchar ExtModelQuantileRegressorF[];
| |||
#resource "models\\quantile_regressor_double.onnx" as const uchar ExtModelQuantileRegressorD[];
| |||
#resource "models\\ransac_regressor_float.onnx" as const uchar ExtModelRANSACRegressorF[];
| |||
#resource "models\\ransac_regressor_double.onnx" as const uchar ExtModelRANSACRegressorD[];
| |||
#resource "models\\theil_sen_regressor_double.onnx" as const uchar ExtModelTheilSenRegressorD[];
| |||
#resource "models\\theil_sen_regressor_float.onnx" as const uchar ExtModelTheilSenRegressorF[];
| |||
#resource "models\\linear_svr_float.onnx" as const uchar ExtModelLinearSVRF[];
| |||
#resource "models\\linear_svr_double.onnx" as const uchar ExtModelLinearSVRD[];
| |||
#resource "models\\mlp_regressor_float.onnx" as const uchar ExtModelMLPRegressorF[];
| |||
#resource "models\\mlp_regressor_double.onnx" as const uchar ExtModelMLPRegressorD[];
| |||
#resource "models\\pls_regression_float.onnx" as const uchar ExtModelPLSRegressionF[];
| |||
#resource "models\\pls_regression_double.onnx" as const uchar ExtModelPLSRegressionD[];
| |||
#resource "models\\tweedie_regressor_float.onnx" as const uchar ExtModelTweedieRegressorF[];
| |||
#resource "models\\tweedie_regressor_double.onnx" as const uchar ExtModelTweedieRegressorD[];
| |||
#resource "models\\poisson_regressor_float.onnx" as const uchar ExtModelPoissonRegressorF[];
| |||
#resource "models\\poisson_regressor_double.onnx" as const uchar ExtModelPoissonRegressorD[];
| |||
#resource "models\\radius_neighbors_regressor_float.onnx" as const uchar ExtModelRadiusNeighborsRegressorF[];
| |||
#resource "models\\radius_neighbors_regressor_double.onnx" as const uchar ExtModelRadiusNeighborsRegressorD[];
| |||
#resource "models\\kneighbors_regressor_float.onnx" as const uchar ExtModelKNeighborsRegressorF[];
| |||
#resource "models\\kneighbors_regressor_double.onnx" as const uchar ExtModelKNeighborsRegressorD[];
| |||
#resource "models\\gaussian_process_regressor_float.onnx" as const uchar ExtModelGaussianProcessRegressorF[];
| |||
#resource "models\\gaussian_process_regressor_double.onnx" as const uchar ExtModelGaussianProcessRegressorD[];
| |||
#resource "models\\gamma_regressor_float.onnx" as const uchar ExtModelGammaRegressorF[];
| |||
#resource "models\\gamma_regressor_double.onnx" as const uchar ExtModelGammaRegressorD[];
| |||
#resource "models\\sgd_regressor_double.onnx" as const uchar ExtModelSGDRegressorD[];
| |||
#resource "models\\sgd_regressor_float.onnx" as const uchar ExtModelSGDRegressorF[];
| |||
#resource "models\\adaboost_regressor_float.onnx" as const uchar ExtModelAdaBoostRegressorF[];
| |||
#resource "models\\adaboost_regressor_double.onnx" as const uchar ExtModelAdaBoostRegressorD[];
| |||
#resource "models\\bagging_regressor_float.onnx" as const uchar ExtModelBaggingRegressorF[];
| |||
#resource "models\\bagging_regressor_double.onnx" as const uchar ExtModelBaggingRegressorD[];
| |||
#resource "models\\decision_tree_regressor_float.onnx" as const uchar ExtModelDecisionTreeRegressorF[];
| |||
#resource "models\\decision_tree_regressor_double.onnx" as const uchar ExtModelDecisionTreeRegressorD[];
| |||
#resource "models\\extra_tree_regressor_float.onnx" as const uchar ExtModelExtraTreeRegressorF[];
| |||
#resource "models\\extra_tree_regressor_double.onnx" as const uchar ExtModelExtraTreeRegressorD[];
| |||
#resource "models\\extra_trees_regressor_float.onnx" as const uchar ExtModelExtraTreesRegressorF[];
| |||
#resource "models\\extra_trees_regressor_double.onnx" as const uchar ExtModelExtraTreesRegressorD[];
| |||
#resource "models\\nu_svr_float.onnx" as const uchar ExtModelNuSVRF[];
| |||
#resource "models\\nu_svr_double.onnx" as const uchar ExtModelNuSVRD[];
| |||
#resource "models\\random_forest_regressor_float.onnx" as const uchar ExtModelRandomForestRegressorF[];
| |||
#resource "models\\random_forest_regressor_double.onnx" as const uchar ExtModelRandomForestRegressorD[];
| |||
#resource "models\\gradient_boosting_regressor_float.onnx" as const uchar ExtModelGradientBoostingRegressorF[];
| |||
#resource "models\\gradient_boosting_regressor_double.onnx" as const uchar ExtModelGradientBoostingRegressorD[];
| |||
#resource "models\\hist_gradient_boosting_regressor_float.onnx" as const uchar ExtModelHistGradientBoostingRegressorF[];
| |||
#resource "models\\hist_gradient_boosting_regressor_double.onnx" as const uchar ExtModelHistGradientBoostingRegressorD[];
| |||
#resource "models\\svr_float.onnx" as const uchar ExtModelSVRF[];
| |||
#resource "models\\svr_double.onnx" as const uchar ExtModelSVRD[];
| |||
| |||
//--- float and double ONNX
| |||
#define ModelARDRegression 1
| |||
#define ModelBayesianRidge 2
| |||
#define ModelElasticNet 3
| |||
#define ModelElasticNetCV 4
| |||
#define ModelHuberRegressor 5
| |||
#define ModelLars 6
| |||
#define ModelLarsCV 7
| |||
#define ModelLasso 8
| |||
#define ModelLassoCV 9
| |||
#define ModelLassoLars 10
| |||
#define ModelLassoLarsCV 11
| |||
#define ModelLassoLarsIC 12
| |||
#define ModelLinearRegression 13
| |||
#define ModelRidge 14
| |||
#define ModelRidgeCV 15
| |||
#define ModelOrthogonalMatchingPursuit 16
| |||
#define ModelPassiveAggressiveRegressor 17
| |||
#define ModelQuantileRegressor 18
| |||
#define ModelRANSACRegressor 19
| |||
#define ModelTheilSenRegressor 20
| |||
#define ModelLinearSVR 21
| |||
#define ModelMLPRegressor 22
| |||
#define ModelPLSRegression 23
| |||
#define ModelTweedieRegressor 24
| |||
#define ModelPoissonRegressor 25
| |||
#define ModelRadiusNeighborsRegressor 26
| |||
#define ModelKNeighborsRegressor 27
| |||
#define ModelGaussianProcessRegressor 28
| |||
#define ModelGammaRegressor 29
| |||
#define ModelSGDRegressor 30
| |||
| |||
//--- only float ONNX models
| |||
#define ModelAdaBoostRegressor 31
| |||
#define ModelBaggingRegressor 32
| |||
#define ModelDecisionTreeRegressor 33
| |||
#define ModelExtraTreeRegressor 34
| |||
#define ModelExtraTreesRegressor 35
| |||
#define ModelNuSVR 36
| |||
#define ModelRandomForestRegressor 37
| |||
#define ModelGradientBoostingRegressor 38
| |||
#define ModelHistGradientBoostingRegressor 39
| |||
#define ModelSVR 40
| |||
| |||
//---
| |||
#define StrModelDouble " (double)";
| |||
#define StrModelFloat " (float)";
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| CreateModel |
| |||
//+------------------------------------------------------------------+
| |||
long CreateModel(const int model_id,const int model_type,string &model_name)
| |||
{
| |||
long model_handle=INVALID_HANDLE;
| |||
ulong flags=ONNX_DEFAULT;
| |||
//ulong flags=ONNX_DEBUG_LOGS;
| |||
//---
| |||
switch(model_id)
| |||
{
| |||
//---
| |||
case ModelARDRegression:
| |||
{
| |||
model_name="ARDRegression";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelARDRegressionF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelARDRegressionD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelBayesianRidge:
| |||
{
| |||
model_name="BayesianRidge";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelBayesianRidgeF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelBayesianRidgeD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelElasticNet:
| |||
{
| |||
model_name="ElasticNet";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelElasticNetF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelElasticNetD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelElasticNetCV:
| |||
{
| |||
model_name="ElasticNetCV";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelElasticNetCVF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelElasticNetCVD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelHuberRegressor:
| |||
{
| |||
model_name="HuberRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelHuberRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelHuberRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLars:
| |||
{
| |||
model_name="Lars";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLarsF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLarsD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLarsCV:
| |||
{
| |||
model_name="LarsCV";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLarsCVF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLarsCVD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLasso:
| |||
{
| |||
model_name="Lasso";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLassoCV:
| |||
{
| |||
model_name="LassoCV";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoCVF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoCVD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLassoLars:
| |||
{
| |||
model_name="LassoLars";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoLarsF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoLarsD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLassoLarsCV:
| |||
{
| |||
model_name="LassoLarsCV";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoLarsCVF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoLarsCVD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLassoLarsIC:
| |||
{
| |||
model_name="LassoLarsIC";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoLarsICF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLassoLarsICD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLinearRegression:
| |||
{
| |||
model_name="LinearRegression";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLinearRegressionF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLinearRegressionD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelRidge:
| |||
{
| |||
model_name="Ridge";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRidgeF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRidgeD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelRidgeCV:
| |||
{
| |||
model_name="RidgeCV";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRidgeCVF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRidgeCVD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelOrthogonalMatchingPursuit:
| |||
{
| |||
model_name="OrthogonalMatchingPursuit";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelOMPF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelOMPD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelPassiveAggressiveRegressor:
| |||
{
| |||
model_name="PassiveAggressiveRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelPAF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelPAD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelQuantileRegressor:
| |||
{
| |||
model_name="QuantileRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelQuantileRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelQuantileRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelRANSACRegressor:
| |||
{
| |||
model_name="RANSACRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRANSACRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRANSACRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelTheilSenRegressor:
| |||
{
| |||
model_name="TheilSenRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelTheilSenRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelTheilSenRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelLinearSVR:
| |||
{
| |||
model_name="LinearSVR";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLinearSVRF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelLinearSVRD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelMLPRegressor:
| |||
{
| |||
model_name="MLPRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelMLPRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelMLPRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelPLSRegression:
| |||
{
| |||
model_name="PLSRegression";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelPLSRegressionF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelPLSRegressionD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelTweedieRegressor:
| |||
{
| |||
model_name="TweedieRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelTweedieRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelTweedieRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelPoissonRegressor:
| |||
{
| |||
model_name="PoissonRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelPoissonRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelPoissonRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelRadiusNeighborsRegressor:
| |||
{
| |||
model_name="RadiusNeighborsRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRadiusNeighborsRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRadiusNeighborsRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelKNeighborsRegressor:
| |||
{
| |||
model_name="KNeighborsRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelKNeighborsRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelKNeighborsRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelGaussianProcessRegressor:
| |||
{
| |||
model_name="GaussianProcessRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelGaussianProcessRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelGaussianProcessRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelGammaRegressor:
| |||
{
| |||
model_name="GammaRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelGammaRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelGammaRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelSGDRegressor:
| |||
{
| |||
model_name="SGDRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelSGDRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelSGDRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelAdaBoostRegressor:
| |||
{
| |||
model_name="AdaBoostRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelAdaBoostRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelAdaBoostRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelBaggingRegressor:
| |||
{
| |||
model_name="BaggingRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelBaggingRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelBaggingRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelDecisionTreeRegressor:
| |||
{
| |||
model_name="DecisionTreeRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelDecisionTreeRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelDecisionTreeRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelExtraTreeRegressor:
| |||
{
| |||
model_name="ExtraTreeRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelExtraTreeRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelExtraTreeRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelExtraTreesRegressor:
| |||
{
| |||
model_name="ExtraTreesRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelExtraTreesRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelExtraTreesRegressorD,flags);
| |||
break;
| |||
}
| |||
case ModelNuSVR:
| |||
{
| |||
model_name="NuSVR";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelNuSVRF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelNuSVRD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelRandomForestRegressor:
| |||
{
| |||
model_name="RandomForestRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRandomForestRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelRandomForestRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelGradientBoostingRegressor:
| |||
{
| |||
model_name="GradientBoostingRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelGradientBoostingRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelGradientBoostingRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelHistGradientBoostingRegressor:
| |||
{
| |||
model_name="HistGradientBoostingRegressor";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelHistGradientBoostingRegressorF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelHistGradientBoostingRegressorD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
case ModelSVR:
| |||
{
| |||
model_name="SVR";
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelSVRF,flags);
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
model_handle=OnnxCreateFromBuffer(ExtModelSVRD,flags);
| |||
break;
| |||
}
| |||
//---
| |||
default:
| |||
break;
| |||
}
| |||
//---
| |||
if(model_type==TestFloatModel)
| |||
model_name+=StrModelFloat;
| |||
//---
| |||
if(model_type==TestDoubleModel)
| |||
model_name+=StrModelDouble;
| |||
//---
| |||
return(model_handle);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Calculate regression using float values |
| |||
//+------------------------------------------------------------------+
| |||
bool RunModelFloat(long model,vector &input_vector, vector &output_vector)
| |||
{
| |||
//--- check number of input samples
| |||
ulong batch_size=input_vector.Size();
| |||
if(batch_size==0)
| |||
return(false);
| |||
//--- prepare output array
| |||
output_vector.Resize((int)batch_size);
| |||
//--- prepare input tensor
| |||
float input_data[];
| |||
ArrayResize(input_data,(int)batch_size);
| |||
//--- set input shape
| |||
ulong input_shape[]= {batch_size, 1};
| |||
OnnxSetInputShape(model,0,input_shape);
| |||
//--- copy data to the input tensor
| |||
for(int k=0; k<(int)batch_size; k++)
| |||
input_data[k]=(float)input_vector[k];
| |||
//--- prepare output tensor
| |||
float output_data[];
| |||
ArrayResize(output_data,(int)batch_size);
| |||
//--- set output shape
| |||
ulong output_shape[]= {batch_size,1};
| |||
OnnxSetOutputShape(model,0,output_shape);
| |||
//--- run the model
| |||
bool res=OnnxRun(model,ONNX_DEBUG_LOGS,input_data,output_data);
| |||
//--- copy output to vector
| |||
if(res)
| |||
{
| |||
for(int k=0; k<(int)batch_size; k++)
| |||
output_vector[k]=output_data[k];
| |||
}
| |||
//---
| |||
return(res);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Calculate regression using double values |
| |||
//+------------------------------------------------------------------+
| |||
bool RunModelDouble(long model,vector &input_vector, vector &output_vector)
| |||
{
| |||
//--- check number of input samples
| |||
ulong batch_size=input_vector.Size();
| |||
if(batch_size==0)
| |||
return(false);
| |||
//--- prepare output array
| |||
output_vector.Resize((int)batch_size);
| |||
//--- prepare input tensor
| |||
double input_data[];
| |||
ArrayResize(input_data,(int)batch_size);
| |||
//--- set input shape
| |||
ulong input_shape[]= {batch_size, 1};
| |||
OnnxSetInputShape(model,0,input_shape);
| |||
//--- copy data to the input tensor
| |||
for(int k=0; k<(int)batch_size; k++)
| |||
input_data[k]=input_vector[k];
| |||
//--- prepare output tensor
| |||
double output_data[];
| |||
ArrayResize(output_data,(int)batch_size);
| |||
//--- set output shape
| |||
ulong output_shape[]= {batch_size,1};
| |||
OnnxSetOutputShape(model,0,output_shape);
| |||
//--- run the model
| |||
bool res=OnnxRun(model,ONNX_DEBUG_LOGS,input_data,output_data);
| |||
//--- copy output to vector
| |||
if(res)
| |||
{
| |||
for(int k=0; k<(int)batch_size; k++)
| |||
output_vector[k]=output_data[k];
| |||
}
| |||
//---
| |||
return(res);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Generate synthetic data |
| |||
//+------------------------------------------------------------------+
| |||
bool GenerateData(const int n,vector &x,vector &y)
| |||
{
| |||
if(n<=0)
| |||
return(false);
| |||
//--- prepare arrays
| |||
x.Resize(n);
| |||
y.Resize(n);
| |||
//---
| |||
for(int i=0; i<n; i++)
| |||
{
| |||
x[i]=(double)1.0*i;
| |||
y[i]=(double)(4*x[i] + 10*sin(x[i]*0.5));
| |||
}
| |||
//---
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| TestRegressionModel |
| |||
//+------------------------------------------------------------------+
| |||
bool TestRegressionModel(const long model,const string model_name,const int model_type)
| |||
{
| |||
//---
| |||
ulong flags=ONNX_DEFAULT;
| |||
| |||
if(model_type==TestFloatModel)
| |||
{
| |||
PrintFormat("Testing ONNX float: %s ",model_name);
| |||
//model=OnnxCreateFromBuffer(ExtModelFloat,flags);
| |||
}
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
{
| |||
PrintFormat("Testing ONNX double: %s ",model_name);
| |||
//model=OnnxCreateFromBuffer(ExtModelDouble,flags);
| |||
}
| |||
else
| |||
{
| |||
PrintFormat("Model type is not incorrect.");
| |||
return(false);
| |||
}
| |||
//---
| |||
vector x_values= {};
| |||
vector y_true= {};
| |||
vector y_predicted= {};
| |||
//---
| |||
int n=100;
| |||
GenerateData(n,x_values,y_true);
| |||
//---
| |||
bool run_result=false;
| |||
if(model_type==TestFloatModel)
| |||
{
| |||
run_result=RunModelFloat(model,x_values,y_predicted);
| |||
}
| |||
else
| |||
if(model_type==TestDoubleModel)
| |||
{
| |||
run_result=RunModelDouble(model,x_values,y_predicted);
| |||
}
| |||
//---
| |||
if(run_result)
| |||
{
| |||
PrintFormat("MQL5: R-Squared (Coefficient of determination): %.16f",y_predicted.RegressionMetric(y_true,REGRESSION_R2));
| |||
PrintFormat("MQL5: Mean Absolute Error: %.16f",y_predicted.RegressionMetric(y_true,REGRESSION_MAE));
| |||
PrintFormat("MQL5: Mean Squared Error: %.16f",y_predicted.RegressionMetric(y_true,REGRESSION_MSE));
| |||
}
| |||
else
| |||
PrintFormat("Error %d",GetLastError());
| |||
//--- release model
| |||
OnnxRelease(model);
| |||
//---
| |||
return(true);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Script program start function |
| |||
//+------------------------------------------------------------------+
| |||
int OnStart(void)
| |||
{
| |||
//---
| |||
string model_name;
| |||
//--- test ONNX models (float)
| |||
int model_type=TestFloatModel;
| |||
Print("Testing ONNX float models...");
| |||
for(int model_id=1; model_id<=40; model_id++)
| |||
{
| |||
long model_handle=CreateModel(model_id,model_type,model_name);
| |||
if(model_handle!=INVALID_HANDLE)
| |||
{
| |||
PrintFormat("\nid=%d Name=%s",model_id, model_name);
| |||
//---
| |||
TestRegressionModel(model_handle,model_name,model_type);
| |||
}
| |||
else
| |||
PrintFormat("id=%d model_name=%s Error=%d\n",model_id,model_name,GetLastError());
| |||
}
| |||
//--- test ONNX models (double)
| |||
model_type=TestDoubleModel;
| |||
Print("\nTesting ONNX double models...");
| |||
for(int model_id=1; model_id<=30; model_id++)
| |||
{
| |||
long model_handle=CreateModel(model_id,model_type,model_name);
| |||
if(model_handle!=INVALID_HANDLE)
| |||
{
| |||
PrintFormat("\nid=%d Name=%s",model_id, model_name);
| |||
//---
| |||
TestRegressionModel(model_handle,model_name,model_type);
| |||
}
| |||
else
| |||
PrintFormat("id=%d model_name=%s Error=%d\n",model_id,model_name,GetLastError());
| |||
}
| |||
//--- test ONNX models (ONNX double execution errors)
| |||
/*model_type=TestDoubleModel;
| |||
Print("\nTesting ONNX double models with errors...");
| |||
for(int model_id=31; model_id<=40; model_id++)
| |||
{
| |||
long model_handle=CreateModel(model_id,model_type,model_name);
| |||
if(model_handle!=INVALID_HANDLE)
| |||
{
| |||
PrintFormat("\nid=%d Name=%s",model_id, model_name);
| |||
//---
| |||
TestRegressionModel(model_handle,model_name,model_type);
| |||
}
| |||
else
| |||
PrintFormat("id=%d model_name=%s Error=%d\n",model_id,model_name,GetLastError());
| |||
}*/
| |||
//---
| |||
return(0);
| |||
}
| |||
//+------------------------------------------------------------------+
|