forked from automated-trading/Scikit.Regression.ONNX
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);
| |
}
| |
//+------------------------------------------------------------------+
|