| #include "RuntimeStorage.mqh"
|
| #ifndef __MODEL_PREDICTOR_MQH__
|
| #define __MODEL_PREDICTOR_MQH__
|
|
|
| // Native MT5 ONNX works in the terminal and Strategy Tester without DLL imports.
|
| // Supported binary classifiers: one float probability tensor, or an int64 label
|
| // tensor followed by a float [1,2] probability tensor (snapshot XGBoost export).
|
| class CModelPredictor
|
| {
|
| private:
|
| struct SCategoricalMap
|
| {
|
| string field;
|
| string keys[];
|
| int values[];
|
| };
|
| long m_session;
|
| bool m_ready;
|
| int m_output_count;
|
| int m_probability_count;
|
| double m_last_probability;
|
| string m_last_error;
|
| string m_trained_symbol;
|
| string m_feature_contract;
|
| string m_supported_symbols[];
|
| int m_trained_timeframe;
|
| string m_feature_names[];
|
| double m_scaler_mean[];
|
| double m_scaler_scale[];
|
| SCategoricalMap m_cat_maps[];
|
|
|
| static string Trim(string value)
|
| {
|
| StringTrimLeft(value);
|
| StringTrimRight(value);
|
| return value;
|
| }
|
| static string NormalizeKey(string value)
|
| {
|
| value = Trim(value);
|
| if(StringLen(value)>0 && StringGetCharacter(value,0)==0xFEFF)
|
| value=StringSubstr(value,1);
|
| StringToLower(value);
|
| return value;
|
| }
|
| void Error(string message)
|
| {
|
| m_last_error=message;
|
| Print("[ModelPredictor] ERROR: ",message);
|
| }
|
| bool ReadBytes(string path, uchar &bytes[])
|
| {
|
| StringReplace(path,"/","\\");
|
| string prefix=TerminalInfoString(TERMINAL_COMMONDATA_PATH)+"\\Files\\";
|
| string local_prefix=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files\\";
|
| int flags=0;
|
| if(StringFind(path,prefix)==0)
|
| {
|
| path=StringSubstr(path,StringLen(prefix));
|
| flags=DUALEA_FILE_COMMON;
|
| }
|
| else if(StringFind(path,local_prefix)==0)
|
| path=StringSubstr(path,StringLen(local_prefix));
|
| ResetLastError();
|
| int file=FileOpen(path,FILE_READ|FILE_BIN|flags|FILE_SHARE_READ);
|
| if(file==INVALID_HANDLE)
|
| {
|
| Error(StringFormat("Cannot read %s (error=%d)",path,GetLastError()));
|
| return false;
|
| }
|
| ulong size=FileSize(file);
|
| if(size==0 || size>2147483647)
|
| {
|
| FileClose(file);
|
| Error("Empty or oversized model/config file: "+path);
|
| return false;
|
| }
|
| ArrayResize(bytes,(int)size);
|
| uint read=FileReadArray(file,bytes,0,(int)size);
|
| FileClose(file);
|
| if(read!=size)
|
| {
|
| Error("Incomplete model/config read: "+path);
|
| return false;
|
| }
|
| return true;
|
| }
|
| bool LoadConfig(string path)
|
| {
|
| uchar bytes[];
|
| if(!ReadBytes(path,bytes)) return false;
|
| string content;
|
| int size=ArraySize(bytes);
|
| if(size>=2 && ((bytes[0]==255 && bytes[1]==254) || (bytes[0]==254 && bytes[1]==255)))
|
| {
|
| bool little=(bytes[0]==255);
|
| ushort chars[];
|
| int count=(size-2)/2;
|
| ArrayResize(chars,count);
|
| for(int i=0;i<count;i++)
|
| chars[i]=(ushort)(little ? bytes[2+i*2]+256*bytes[3+i*2] : 256*bytes[2+i*2]+bytes[3+i*2]);
|
| content=ShortArrayToString(chars,0,count);
|
| }
|
| else
|
| content=CharArrayToString(bytes,0,size,CP_UTF8);
|
| string lines[];
|
| int count=StringSplit(content,'\n',lines);
|
| int declared_count=-1;
|
| m_trained_symbol="";
|
| m_feature_contract="";
|
| m_trained_timeframe=0;
|
| ArrayResize(m_supported_symbols,0);
|
| ArrayResize(m_feature_names,0);
|
| ArrayResize(m_scaler_mean,0);
|
| ArrayResize(m_scaler_scale,0);
|
| ArrayResize(m_cat_maps,0);
|
| for(int li=0;li<count;li++)
|
| {
|
| string line=Trim(lines[li]);
|
| int separator=StringFind(line,"=");
|
| if(separator<=0) continue;
|
| string key=NormalizeKey(StringSubstr(line,0,separator));
|
| string value=Trim(StringSubstr(line,separator+1));
|
| if(key=="trained_symbol") m_trained_symbol=value;
|
| else if(key=="trained_timeframe") m_trained_timeframe=(int)StringToInteger(value);
|
| else if(key=="feature_contract") m_feature_contract=value;
|
| else if(key=="supported_symbols") StringSplit(value,'|',m_supported_symbols);
|
| else if(key=="feature_count") declared_count=(int)StringToInteger(value);
|
| else if(key=="feature_names" || key=="scaler_mean" || key=="scaler_scale")
|
| {
|
| string tokens[];
|
| int n=StringSplit(value,'|',tokens);
|
| if(n<=1) n=StringSplit(value,',',tokens);
|
| if(key=="feature_names")
|
| {
|
| ArrayResize(m_feature_names,n);
|
| for(int i=0;i<n;i++) m_feature_names[i]=Trim(tokens[i]);
|
| }
|
| else if(key=="scaler_mean")
|
| {
|
| ArrayResize(m_scaler_mean,n);
|
| for(int i=0;i<n;i++) m_scaler_mean[i]=StringToDouble(Trim(tokens[i]));
|
| }
|
| else
|
| {
|
| ArrayResize(m_scaler_scale,n);
|
| for(int i=0;i<n;i++) m_scaler_scale[i]=StringToDouble(Trim(tokens[i]));
|
| }
|
| }
|
| else if(StringFind(key,"cat_")==0)
|
| {
|
| int map_index=ArraySize(m_cat_maps);
|
| ArrayResize(m_cat_maps,map_index+1);
|
| m_cat_maps[map_index].field=NormalizeKey(StringSubstr(key,4));
|
| string entries[];
|
| int n=StringSplit(value,'|',entries);
|
| for(int i=0;i<n;i++)
|
| {
|
| int colon=StringFind(entries[i],":");
|
| if(colon<=0) continue;
|
| int slot=ArraySize(m_cat_maps[map_index].keys);
|
| ArrayResize(m_cat_maps[map_index].keys,slot+1);
|
| ArrayResize(m_cat_maps[map_index].values,slot+1);
|
| m_cat_maps[map_index].keys[slot]=NormalizeKey(StringSubstr(entries[i],0,colon));
|
| m_cat_maps[map_index].values[slot]=(int)StringToInteger(StringSubstr(entries[i],colon+1));
|
| }
|
| }
|
| }
|
| int features=ArraySize(m_feature_names);
|
| if(features<=0 || (declared_count>0 && declared_count!=features) ||
|
| ArraySize(m_scaler_mean)!=features || ArraySize(m_scaler_scale)!=features)
|
| {
|
| Error("INI feature count/scaler metadata is missing or inconsistent");
|
| return false;
|
| }
|
| for(int i=0;i<features;i++)
|
| if(m_feature_names[i]=="" || !MathIsValidNumber(m_scaler_mean[i]) ||
|
| !MathIsValidNumber(m_scaler_scale[i]) || m_scaler_scale[i]<=0)
|
| {
|
| Error("Invalid feature name or scaler value at index "+IntegerToString(i));
|
| return false;
|
| }
|
| return true;
|
| }
|
| bool ConfigureModel()
|
| {
|
| if(OnnxGetInputCount(m_session)!=1)
|
| {
|
| Error("Only a single feature tensor model_input is supported");
|
| return false;
|
| }
|
| OnnxTypeInfo model_input;
|
| if(!OnnxGetInputTypeInfo(m_session,0,model_input) || model_input.type!=ONNX_TYPE_TENSOR ||
|
| model_input.tensor.data_type!=ONNX_DATA_TYPE_FLOAT || ArraySize(model_input.tensor.dimensions)!=2 ||
|
| (model_input.tensor.dimensions[0]>0 && model_input.tensor.dimensions[0]!=1) ||
|
| (model_input.tensor.dimensions[1]>0 && model_input.tensor.dimensions[1]!=FeatureCount()))
|
| {
|
| Error("Model must accept float [1,feature_count] model_input matching the INI");
|
| return false;
|
| }
|
| long input_shape[]={1,FeatureCount()};
|
| if(!OnnxSetInputShape(m_session,0,input_shape)) return false;
|
| m_output_count=(int)OnnxGetOutputCount(m_session);
|
| if(m_output_count!=1 && m_output_count!=2)
|
| {
|
| Error("Unsupported classifier output count");
|
| return false;
|
| }
|
| if(m_output_count==2)
|
| {
|
| OnnxTypeInfo label;
|
| if(!OnnxGetOutputTypeInfo(m_session,0,label) || label.type!=ONNX_TYPE_TENSOR ||
|
| label.tensor.data_type!=ONNX_DATA_TYPE_INT64 || ArraySize(label.tensor.dimensions)!=1 ||
|
| (label.tensor.dimensions[0]>0 && label.tensor.dimensions[0]!=1))
|
| {
|
| Error("First classifier output must be an int64 [1] label tensor");
|
| return false;
|
| }
|
| long label_shape[]={1};
|
| if(!OnnxSetOutputShape(m_session,0,label_shape)) return false;
|
| }
|
| OnnxTypeInfo probability;
|
| int output=m_output_count-1;
|
| if(!OnnxGetOutputTypeInfo(m_session,output,probability) || probability.type!=ONNX_TYPE_TENSOR ||
|
| probability.tensor.data_type!=ONNX_DATA_TYPE_FLOAT)
|
| {
|
| Error("Probability output must be a float tensor; ZipMap/sequence outputs require tensor export");
|
| return false;
|
| }
|
| int rank=ArraySize(probability.tensor.dimensions);
|
| if(rank<1 || rank>2 || (rank==2 && probability.tensor.dimensions[0]>0 && probability.tensor.dimensions[0]!=1))
|
| {
|
| Error("Probability output must have shape [1], [2], [1,1], or [1,2]");
|
| return false;
|
| }
|
| m_probability_count=(int)probability.tensor.dimensions[rank-1];
|
| if(m_probability_count!=1 && m_probability_count!=2)
|
| {
|
| Error("Probability output must have one sigmoid value or two binary class probabilities");
|
| return false;
|
| }
|
| if(m_output_count==2 && m_probability_count!=2)
|
| {
|
| Error("Label-plus-probability classifier must export two binary class probabilities");
|
| return false;
|
| }
|
| long shape[];
|
| ArrayResize(shape,rank);
|
| if(rank==2) shape[0]=1;
|
| shape[rank-1]=m_probability_count;
|
| return OnnxSetOutputShape(m_session,output,shape);
|
| }
|
| public:
|
| CModelPredictor() : m_session(INVALID_HANDLE),m_ready(false),m_output_count(0),m_probability_count(0),m_last_probability(-1.0),m_last_error("") {}
|
| ~CModelPredictor() { Shutdown(); }
|
| bool Init(const string model_path,const string config_json_path,const string config_ini_path)
|
| {
|
| Shutdown();
|
| m_last_error="";
|
| if(!LoadConfig(config_ini_path)) return false;
|
| uchar model[];
|
| if(!ReadBytes(model_path,model)) return false;
|
| ResetLastError();
|
| m_session=OnnxCreateFromBuffer(model,ONNX_USE_CPU_ONLY);
|
| if(m_session==INVALID_HANDLE)
|
| {
|
| Error(StringFormat("Native ONNX model creation failed (error=%d)",GetLastError()));
|
| return false;
|
| }
|
| if(!ConfigureModel())
|
| {
|
| if(m_last_error=="") Error(StringFormat("ONNX tensor configuration failed (error=%d)",GetLastError()));
|
| Shutdown();
|
| return false;
|
| }
|
| m_ready=true;
|
| PrintFormat("[ModelPredictor] Native ONNX initialized: features=%d, outputs=%d, probability tensor=%s",FeatureCount(),m_output_count,OnnxGetOutputName(m_session,m_output_count-1));
|
| return true;
|
| }
|
| void Shutdown()
|
| {
|
| if(m_session!=INVALID_HANDLE) OnnxRelease(m_session);
|
| m_session=INVALID_HANDLE;
|
| m_ready=false;
|
| m_last_probability=-1.0;
|
| }
|
| bool IsReady() const { return m_ready; }
|
| double LastProbability() const { return m_last_probability; }
|
| string LastError() const { return m_last_error; }
|
| int FeatureCount() const { return ArraySize(m_feature_names); }
|
| string TrainedSymbol() const { return m_trained_symbol; }
|
| int TrainedTimeframe() const { return m_trained_timeframe; }
|
| string FeatureContract() const { return m_feature_contract; }
|
| bool GetSupportedSymbols(string &symbols[]) const
|
| {
|
| ArrayCopy(symbols,m_supported_symbols);
|
| return ArraySize(symbols)>0;
|
| }
|
| bool SupportsSymbol(string symbol) const
|
| {
|
| for(int i=0;i<ArraySize(m_supported_symbols);i++)
|
| if(StringCompare(symbol,Trim(m_supported_symbols[i]),false)==0) return true;
|
| return m_trained_symbol!="*" && m_trained_symbol==symbol;
|
| }
|
| bool GetFeatureNames(string &dest[]) const
|
| {
|
| ArrayCopy(dest,m_feature_names);
|
| return ArraySize(m_feature_names)>0;
|
| }
|
| int EncodeCategorical(const string field,const string value) const
|
| {
|
| string key=NormalizeKey(field), label=NormalizeKey(value);
|
| for(int i=0;i<ArraySize(m_cat_maps);i++)
|
| if(m_cat_maps[i].field==key)
|
| for(int j=0;j<ArraySize(m_cat_maps[i].keys);j++)
|
| if(m_cat_maps[i].keys[j]==label) return m_cat_maps[i].values[j];
|
| return 0;
|
| }
|
| // A negative result is an inference failure, never a fabricated neutral probability.
|
| double Predict(double &features[],int feature_count)
|
| {
|
| m_last_probability=-1.0;
|
| if(!m_ready || feature_count!=FeatureCount() || ArraySize(features)<feature_count)
|
| {
|
| Error("Predict called without a ready model or with mismatched feature dimensions");
|
| return -1.0;
|
| }
|
| float model_input[], probabilities[];
|
| ArrayResize(model_input,feature_count);
|
| ArrayResize(probabilities,m_probability_count);
|
| for(int i=0;i<feature_count;i++)
|
| {
|
| double scaled=(features[i]-m_scaler_mean[i])/m_scaler_scale[i];
|
| if(!MathIsValidNumber(scaled) || MathAbs(scaled)>3.402823466e38)
|
| {
|
| Error("Nonfinite or overflowing model model_input at feature "+IntegerToString(i));
|
| return -1.0;
|
| }
|
| model_input[i]=(float)scaled;
|
| }
|
| long label[1];
|
| ResetLastError();
|
| bool ok;
|
| if(m_output_count==2) ok=OnnxRun(m_session,ONNX_NO_CONVERSION,model_input,label,probabilities);
|
| else ok=OnnxRun(m_session,ONNX_NO_CONVERSION,model_input,probabilities);
|
| if(!ok)
|
| {
|
| Error(StringFormat("Native ONNX inference failed (error=%d)",GetLastError()));
|
| return -1.0;
|
| }
|
| for(int i=0;i<m_probability_count;i++)
|
| if(!MathIsValidNumber(probabilities[i]) || probabilities[i]<0 || probabilities[i]>1)
|
| {
|
| Error("Model returned an invalid probability");
|
| return -1.0;
|
| }
|
| if(m_probability_count==2 && MathAbs((double)probabilities[0]+(double)probabilities[1]-1.0)>0.001)
|
| {
|
| Error("Binary class probabilities do not sum to one");
|
| return -1.0;
|
| }
|
| m_last_probability=probabilities[m_probability_count-1];
|
| m_last_error="";
|
| return m_last_probability;
|
| }
|
| };
|
| #endif
|
