| #ifndef __MODEL_PREDICTOR_MQH__
|
| #define __MODEL_PREDICTOR_MQH__
|
|
|
| // CRITICAL: DLL imports crash Strategy Tester but are needed for live trading
|
| // Use conditional compilation - only import DLL when NOT in tester
|
| #ifndef MQL_TESTER
|
|
|
| #ifdef USE_MOCK_ORT
|
| #import "PaperEA_OnnxBridge_mock.dll"
|
| int InitializeModel(string modelPath, string configPath);
|
| int PredictSignal(const double &features[], int featureCount, double &probability);
|
| void Cleanup();
|
| string GetLastModelError();
|
| #import
|
| #else
|
| #import "PaperEA_OnnxBridge_u2.dll"
|
| int InitializeModel(string modelPath, string configPath);
|
| int PredictSignal(const double &features[], int featureCount, double &probability);
|
| void Cleanup();
|
| string GetLastModelError();
|
| #import
|
| #endif
|
|
|
| #else
|
| // Strategy Tester: Use stub implementations
|
| int InitializeModel(string modelPath, string configPath) { return 0; }
|
| int PredictSignal(const double &features[], int featureCount, double &probability) { probability = 0.5; return 0; }
|
| void Cleanup() { }
|
| string GetLastModelError() { return "ONNX DLL not available in Strategy Tester"; }
|
| #endif
|
|
|
| class CModelPredictor
|
| {
|
| private:
|
| struct SCategoricalMap
|
| {
|
| string field;
|
| string keys[];
|
| int values[];
|
| };
|
|
|
| bool m_ready;
|
| string m_model_path;
|
| string m_json_path;
|
| string m_ini_path;
|
| string m_input_name;
|
| string m_output_name;
|
| string m_last_error;
|
| double m_scaler_mean[];
|
| double m_scaler_scale[];
|
| string m_feature_names[];
|
| double m_work_buffer[];
|
| double m_last_probability;
|
| SCategoricalMap m_cat_maps[];
|
| bool m_debug_logged;
|
| bool m_debug_probs_logged;
|
|
|
| bool LoadIniConfig(const string path);
|
| bool ParseKeyValue(const string line, string &key, string &value) const;
|
| static string Trim(string value);
|
| static string NormalizeKey(string value);
|
| void EnsureBuffer(const int count);
|
| void Log(const string msg) const { Print("[ModelPredictor] " + msg); }
|
| void LogError(const string msg);
|
| void CaptureDllError(const string context);
|
|
|
| public:
|
| CModelPredictor();
|
| bool Init(const string model_path, const string config_json_path, const string config_ini_path);
|
| double Predict(double &features[], int feature_count);
|
| void Shutdown();
|
| 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); }
|
| bool GetFeatureNames(string &dest[]) const;
|
| int EncodeCategorical(const string field, const string value) const;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Implementation |
|
| //+------------------------------------------------------------------+
|
|
|
| CModelPredictor::CModelPredictor()
|
| {
|
| m_ready = false;
|
| m_model_path = "";
|
| m_json_path = "";
|
| m_ini_path = "";
|
| m_input_name = "";
|
| m_output_name = "";
|
| m_last_error = "";
|
| m_last_probability = 0.5;
|
| m_debug_logged = false;
|
| m_debug_probs_logged = false;
|
| ArrayResize(m_scaler_mean, 0);
|
| ArrayResize(m_scaler_scale, 0);
|
| ArrayResize(m_feature_names, 0);
|
| ArrayResize(m_work_buffer, 0);
|
| ArrayResize(m_cat_maps, 0);
|
| }
|
|
|
| string CModelPredictor::Trim(string value)
|
| {
|
| StringTrimLeft(value);
|
| StringTrimRight(value);
|
| return value;
|
| }
|
|
|
| string CModelPredictor::NormalizeKey(string value)
|
| {
|
| string tmp = Trim(value);
|
| while(StringLen(tmp) > 0)
|
| {
|
| int ch = StringGetCharacter(tmp, 0);
|
| if(ch == 0xFEFF || ch == 65279 || ch == 0)
|
| tmp = StringSubstr(tmp, 1);
|
| else
|
| break;
|
| }
|
| StringToLower(tmp);
|
| return tmp;
|
| }
|
|
|
| bool CModelPredictor::ParseKeyValue(const string line, string &key, string &value) const
|
| {
|
| int pos = StringFind(line, "=");
|
| if(pos <= 0)
|
| return false;
|
| key = Trim(StringSubstr(line, 0, pos));
|
| value = Trim(StringSubstr(line, pos + 1));
|
| key = NormalizeKey(key);
|
| return (StringLen(key) > 0);
|
| }
|
|
|
| void CModelPredictor::EnsureBuffer(const int count)
|
| {
|
| if(ArraySize(m_work_buffer) != count)
|
| ArrayResize(m_work_buffer, count);
|
| }
|
|
|
| void CModelPredictor::LogError(const string msg)
|
| {
|
| m_last_error = msg;
|
| Log("ERROR: " + msg);
|
| }
|
|
|
| void CModelPredictor::CaptureDllError(const string context)
|
| {
|
| string dll_err = GetLastModelError();
|
| if(StringLen(Trim(dll_err)) == 0)
|
| dll_err = StringFormat("%s failed (GetLastError=%d)", context, GetLastError());
|
| LogError(dll_err);
|
| }
|
|
|
| bool CModelPredictor::LoadIniConfig(const string path)
|
| {
|
| string open_name = path;
|
| int extra_flags = 0;
|
| string common_prefix = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\Files\\";
|
| if(StringFind(path, common_prefix) == 0)
|
| {
|
| open_name = StringSubstr(path, StringLen(common_prefix));
|
| extra_flags = FILE_COMMON;
|
| }
|
|
|
| // Try different file opening modes
|
| int handle = FileOpen(open_name, FILE_READ|FILE_TXT|extra_flags);
|
| if(handle == INVALID_HANDLE)
|
| {
|
| handle = FileOpen(open_name, FILE_READ|FILE_TXT|FILE_ANSI|extra_flags);
|
| }
|
| if(handle == INVALID_HANDLE)
|
| {
|
| handle = FileOpen(open_name, FILE_READ|FILE_TXT|FILE_UNICODE|extra_flags);
|
| }
|
| if(handle == INVALID_HANDLE)
|
| {
|
| handle = FileOpen(open_name, FILE_READ|FILE_TXT|FILE_COMMON);
|
| }
|
| if(handle == INVALID_HANDLE)
|
| {
|
| LogError(StringFormat("Unable to open ONNX config INI: %s (error=%d)", path, GetLastError()));
|
| return false;
|
| }
|
|
|
| int parsed_pairs = 0;
|
| bool saw_feature_names = false;
|
|
|
| ArrayResize(m_feature_names, 0);
|
| ArrayResize(m_scaler_mean, 0);
|
| ArrayResize(m_scaler_scale, 0);
|
| ArrayResize(m_cat_maps, 0);
|
|
|
| int declared_count = -1;
|
| while(!FileIsEnding(handle))
|
| {
|
| string raw = Trim(FileReadString(handle));
|
| if(StringLen(raw) == 0 || StringGetCharacter(raw, 0) == '#')
|
| continue;
|
|
|
| string key, value;
|
| if(!ParseKeyValue(raw, key, value))
|
| continue;
|
|
|
| parsed_pairs++;
|
| if(parsed_pairs <= 3)
|
| Log(StringFormat("INI key[%d]=%s", parsed_pairs, key));
|
|
|
| if(key == "feature_count")
|
| {
|
| declared_count = (int)StringToInteger(value);
|
| continue;
|
| }
|
|
|
| if(key == "feature_names")
|
| {
|
| string tokens[];
|
| int parts = StringSplit(value, '|', tokens);
|
| if(parts <= 1)
|
| parts = StringSplit(value, ',', tokens);
|
| ArrayResize(m_feature_names, parts);
|
| for(int i = 0; i < parts; i++)
|
| m_feature_names[i] = Trim(tokens[i]);
|
| saw_feature_names = (parts > 0);
|
| Log(StringFormat("INI loaded feature_names=%d", parts));
|
| continue;
|
| }
|
|
|
| if(key == "scaler_mean")
|
| {
|
| string tokens[];
|
| int parts = StringSplit(value, '|', tokens);
|
| if(parts <= 1)
|
| parts = StringSplit(value, ',', tokens);
|
| ArrayResize(m_scaler_mean, parts);
|
| for(int i = 0; i < parts; i++)
|
| m_scaler_mean[i] = StringToDouble(Trim(tokens[i]));
|
| Log(StringFormat("INI loaded scaler_mean=%d", parts));
|
| continue;
|
| }
|
|
|
| if(key == "scaler_scale")
|
| {
|
| string tokens[];
|
| int parts = StringSplit(value, '|', tokens);
|
| if(parts <= 1)
|
| parts = StringSplit(value, ',', tokens);
|
| ArrayResize(m_scaler_scale, parts);
|
| for(int i = 0; i < parts; i++)
|
| m_scaler_scale[i] = StringToDouble(Trim(tokens[i]));
|
| Log(StringFormat("INI loaded scaler_scale=%d", parts));
|
| continue;
|
| }
|
|
|
| if(StringSubstr(key, 0, 4) == "cat_")
|
| {
|
| string field = NormalizeKey(StringSubstr(key, 4));
|
| string entries[];
|
| int entry_count = StringSplit(value, '|', entries);
|
| if(entry_count <= 0)
|
| continue;
|
|
|
| SCategoricalMap map;
|
| map.field = field;
|
| ArrayResize(map.keys, 0);
|
| ArrayResize(map.values, 0);
|
|
|
| for(int e = 0; e < entry_count; e++)
|
| {
|
| string kv = Trim(entries[e]);
|
| int colon = StringFind(kv, ":");
|
| if(colon <= 0)
|
| continue;
|
| string label = NormalizeKey(StringSubstr(kv, 0, colon));
|
| int code = (int)StringToInteger(StringSubstr(kv, colon + 1));
|
| int idx = ArraySize(map.keys);
|
| ArrayResize(map.keys, idx + 1);
|
| ArrayResize(map.values, idx + 1);
|
| map.keys[idx] = label;
|
| map.values[idx] = code;
|
| }
|
|
|
| int mcount = ArraySize(map.keys);
|
| if(mcount > 0)
|
| {
|
| int slot = ArraySize(m_cat_maps);
|
| ArrayResize(m_cat_maps, slot + 1);
|
| m_cat_maps[slot] = map;
|
| }
|
| continue;
|
| }
|
|
|
| if(key == "input_name")
|
| {
|
| m_input_name = Trim(value);
|
| continue;
|
| }
|
|
|
| if(key == "output_name")
|
| {
|
| m_output_name = Trim(value);
|
| continue;
|
| }
|
| }
|
|
|
| if(parsed_pairs == 0)
|
| {
|
| FileClose(handle);
|
| int hbin = FileOpen(open_name, FILE_READ|FILE_BIN|extra_flags);
|
| if(hbin == INVALID_HANDLE)
|
| hbin = FileOpen(open_name, FILE_READ|FILE_BIN|FILE_COMMON);
|
| if(hbin != INVALID_HANDLE)
|
| {
|
| int sz = (int)FileSize(hbin);
|
| if(sz > 0)
|
| {
|
| uchar bytes[];
|
| ArrayResize(bytes, sz);
|
| FileReadArray(hbin, bytes, 0, sz);
|
| string content = CharArrayToString(bytes, 0, sz, 65001);
|
| if(StringLen(content) == 0)
|
| content = CharArrayToString(bytes, 0, sz, 0);
|
|
|
| string lines[];
|
| int lcount = StringSplit(content, '\n', lines);
|
| for(int li = 0; li < lcount; li++)
|
| {
|
| string line = Trim(lines[li]);
|
| if(StringLen(line) == 0)
|
| continue;
|
| if(StringGetCharacter(line, StringLen(line) - 1) == '\r')
|
| line = StringSubstr(line, 0, StringLen(line) - 1);
|
| if(StringLen(line) == 0 || StringGetCharacter(line, 0) == '#')
|
| continue;
|
|
|
| string k2, v2;
|
| if(!ParseKeyValue(line, k2, v2))
|
| continue;
|
|
|
| parsed_pairs++;
|
|
|
| if(k2 == "feature_count")
|
| {
|
| declared_count = (int)StringToInteger(v2);
|
| continue;
|
| }
|
|
|
| if(k2 == "feature_names")
|
| {
|
| string tokens[];
|
| int parts = StringSplit(v2, '|', tokens);
|
| if(parts <= 1)
|
| parts = StringSplit(v2, ',', tokens);
|
| ArrayResize(m_feature_names, parts);
|
| for(int i = 0; i < parts; i++)
|
| m_feature_names[i] = Trim(tokens[i]);
|
| saw_feature_names = (parts > 0);
|
| continue;
|
| }
|
|
|
| if(k2 == "scaler_mean")
|
| {
|
| string tokens[];
|
| int parts = StringSplit(v2, '|', tokens);
|
| if(parts <= 1)
|
| parts = StringSplit(v2, ',', tokens);
|
| ArrayResize(m_scaler_mean, parts);
|
| for(int i = 0; i < parts; i++)
|
| m_scaler_mean[i] = StringToDouble(Trim(tokens[i]));
|
| continue;
|
| }
|
|
|
| if(k2 == "scaler_scale")
|
| {
|
| string tokens[];
|
| int parts = StringSplit(v2, '|', tokens);
|
| if(parts <= 1)
|
| parts = StringSplit(v2, ',', tokens);
|
| ArrayResize(m_scaler_scale, parts);
|
| for(int i = 0; i < parts; i++)
|
| m_scaler_scale[i] = StringToDouble(Trim(tokens[i]));
|
| continue;
|
| }
|
|
|
| if(StringSubstr(k2, 0, 4) == "cat_")
|
| {
|
| string field = NormalizeKey(StringSubstr(k2, 4));
|
| string entries[];
|
| int entry_count = StringSplit(v2, '|', entries);
|
| if(entry_count <= 0)
|
| continue;
|
|
|
| SCategoricalMap map;
|
| map.field = field;
|
| ArrayResize(map.keys, 0);
|
| ArrayResize(map.values, 0);
|
|
|
| for(int e = 0; e < entry_count; e++)
|
| {
|
| string kv = Trim(entries[e]);
|
| int colon = StringFind(kv, ":");
|
| if(colon <= 0)
|
| continue;
|
| string label = NormalizeKey(StringSubstr(kv, 0, colon));
|
| int code = (int)StringToInteger(StringSubstr(kv, colon + 1));
|
| int idx = ArraySize(map.keys);
|
| ArrayResize(map.keys, idx + 1);
|
| ArrayResize(map.values, idx + 1);
|
| map.keys[idx] = label;
|
| map.values[idx] = code;
|
| }
|
|
|
| int mcount = ArraySize(map.keys);
|
| if(mcount > 0)
|
| {
|
| int slot = ArraySize(m_cat_maps);
|
| ArrayResize(m_cat_maps, slot + 1);
|
| m_cat_maps[slot] = map;
|
| }
|
| continue;
|
| }
|
|
|
| if(k2 == "input_name")
|
| {
|
| m_input_name = Trim(v2);
|
| continue;
|
| }
|
|
|
| if(k2 == "output_name")
|
| {
|
| m_output_name = Trim(v2);
|
| continue;
|
| }
|
| }
|
| }
|
| FileClose(hbin);
|
| }
|
| }
|
| else
|
| {
|
| FileClose(handle);
|
| }
|
|
|
| if(ArraySize(m_feature_names) == 0)
|
| {
|
| if(parsed_pairs == 0)
|
| LogError("ONNX config INI parsed 0 key/value pairs");
|
| else if(!saw_feature_names)
|
| LogError(StringFormat("ONNX config parsed %d keys but did not detect feature_names", parsed_pairs));
|
| LogError("ONNX config missing feature_names entry");
|
| return false;
|
| }
|
|
|
| if(declared_count > 0 && declared_count != ArraySize(m_feature_names))
|
| {
|
| Log(StringFormat("feature_count (%d) differs from actual list (%d) - continuing", declared_count, ArraySize(m_feature_names)));
|
| }
|
|
|
| if(ArraySize(m_scaler_mean) != ArraySize(m_feature_names))
|
| {
|
| Log("Scaler mean length mismatch - padding");
|
| ArrayResize(m_scaler_mean, ArraySize(m_feature_names));
|
| }
|
|
|
| if(ArraySize(m_scaler_scale) != ArraySize(m_feature_names))
|
| {
|
| Log("Scaler scale length mismatch - padding");
|
| ArrayResize(m_scaler_scale, ArraySize(m_feature_names));
|
| }
|
|
|
| return true;
|
| }
|
|
|
| bool CModelPredictor::Init(const string model_path, const string config_json_path, const string config_ini_path)
|
| {
|
| Shutdown();
|
|
|
| if(StringLen(Trim(model_path)) == 0 || StringLen(Trim(config_json_path)) == 0 || StringLen(Trim(config_ini_path)) == 0)
|
| {
|
| LogError("Init parameters missing model/config paths");
|
| return false;
|
| }
|
|
|
| if(!LoadIniConfig(config_ini_path))
|
| return false;
|
|
|
| // The DLL expects the INI config path (scaler + feature info), not the JSON.
|
| if(InitializeModel(model_path, config_ini_path) != 1)
|
| {
|
| CaptureDllError("InitializeModel");
|
| return false;
|
| }
|
|
|
| m_model_path = model_path;
|
| m_json_path = config_json_path;
|
| m_ini_path = config_ini_path;
|
| m_last_probability = 0.5;
|
| m_last_error = "";
|
| m_ready = true;
|
| Log(StringFormat("ONNX predictor initialized (%d features)", ArraySize(m_feature_names)));
|
| return true;
|
| }
|
|
|
| void CModelPredictor::Shutdown()
|
| {
|
| if(m_ready)
|
| {
|
| Cleanup();
|
| m_ready = false;
|
| Log("ONNX predictor shutdown");
|
| }
|
| }
|
|
|
| bool CModelPredictor::GetFeatureNames(string &dest[]) const
|
| {
|
| int count = ArraySize(m_feature_names);
|
| ArrayResize(dest, count);
|
| for(int i = 0; i < count; i++)
|
| dest[i] = m_feature_names[i];
|
| return (count > 0);
|
| }
|
|
|
| int CModelPredictor::EncodeCategorical(const string field, const string value) const
|
| {
|
| string needle = NormalizeKey(field);
|
| string normalized_value = NormalizeKey(value);
|
| for(int i = 0; i < ArraySize(m_cat_maps); i++)
|
| {
|
| if(m_cat_maps[i].field != needle)
|
| continue;
|
| for(int j = 0; j < ArraySize(m_cat_maps[i].keys); j++)
|
| {
|
| if(m_cat_maps[i].keys[j] == normalized_value)
|
| return m_cat_maps[i].values[j];
|
| }
|
| break;
|
| }
|
| return 0;
|
| }
|
|
|
| double CModelPredictor::Predict(double &features[], int feature_count)
|
| {
|
| if(!m_ready)
|
| {
|
| Log("ERROR: Predict() called but model not ready (m_ready=false)");
|
| return 0.5;
|
| }
|
|
|
| int expected = ArraySize(m_feature_names);
|
| if(feature_count != expected)
|
| {
|
| LogError(StringFormat("Feature mismatch: got %d expected %d", feature_count, expected));
|
| return 0.5;
|
| }
|
|
|
| // DEBUG: Always log first 8 features to diagnose zero-input issue
|
| string feat_str = "ONNX Input features: ";
|
| bool has_nonzero = false;
|
| for(int i = 0; i < MathMin(8, expected); i++)
|
| {
|
| feat_str += StringFormat("[%d]=%.6f ", i, features[i]);
|
| if(MathAbs(features[i]) > 0.0001) has_nonzero = true;
|
| }
|
| Log(feat_str);
|
|
|
| if(!has_nonzero)
|
| {
|
| Log("WARNING: All features are zero or near-zero - model will return neutral");
|
| }
|
|
|
| double output_value = 0.5;
|
|
|
| // Call DLL prediction
|
| int result = PredictSignal(features, expected, output_value);
|
|
|
| if(result != 1)
|
| {
|
| CaptureDllError("PredictSignal");
|
| LogError(StringFormat("PredictSignal FAILED with code %d, output=%.6f", result, output_value));
|
| return 0.5;
|
| }
|
|
|
| // Check for neutral output
|
| if(MathAbs(output_value - 0.5) < 0.001)
|
| {
|
| Log(StringFormat("WARNING: Model returned neutral (%.6f) - possible model file corruption or zero input", output_value));
|
| }
|
| else
|
| {
|
| Log(StringFormat("PredictSignal SUCCESS: output=%.6f", output_value));
|
| }
|
|
|
| // Check GetLastModelError for any debug info from DLL
|
| string dbg = GetLastModelError();
|
| if(StringLen(dbg) > 0 && dbg != "ONNX DLL not available in Strategy Tester")
|
| {
|
| Log(StringFormat("DLL status: %s", dbg));
|
| }
|
|
|
| output_value = MathMax(0.0, MathMin(1.0, output_value));
|
| m_last_probability = output_value;
|
| return output_value;
|
| }
|
|
|
| #endif
|
