Update ml_engine/guardian_hydra.py

ml_engine/guardian_hydra.py

@@ -8,17 +8,21 @@ from collections import deque, defaultdict
 import traceback
 import sys
 
+# ✅ GEM-FIX: استيراد Mixin لضمان التوافق (احتياطي)
+from sklearn.base import ClassifierMixin
+
 class GuardianHydra:
     """
-    GuardianHydra V1.4 (Configurable Verbosity)
-    - Added set_silent_mode() to suppress logs during Backtesting.
+    GuardianHydra V1.5 (Production Fix)
+    - Fixed: `_estimator_type` undefined error during load_model.
+    - Added: Manual type injection for XGBClassifier.
     """
     def __init__(self, model_dir):
         self.model_dir = model_dir
         self.initialized = False
         self.models = {}
         self.feature_cols = []
-        self.verbose = True  # ✅ Default to True for Live System
+        self.verbose = True
         
         self.smoothing_buffer = defaultdict(lambda: {
             'crash': deque(maxlen=3), 
@@ -27,11 +31,10 @@ class GuardianHydra:
         })
 
         self.ATR_PERIOD = 14
-        # ✅ Silent check
         if self.verbose: print("🐲 [Hydra X-RAY] Instance Created. Waiting for data...")
 
     def set_silent_mode(self, silent=True):
-        """ ✅ Control Logging Output (True = No Logs, False = X-RAY Logs) """
+        """ Control Logging Output """
         self.verbose = not silent
 
     def initialize(self):
@@ -50,7 +53,7 @@ class GuardianHydra:
             self.feature_cols = joblib.load(feat_path)
             if self.verbose: print(f"✅ Features List Loaded ({len(self.feature_cols)} items)")
 
-            # 2. Load Models (RAW)
+            # 2. Load Models (RAW with Type Injection)
             heads = ['crash', 'giveback', 'stagnation']
             for h in heads:
                 model_path = os.path.join(self.model_dir, f"hydra_head_{h}_raw.json")
@@ -58,10 +61,27 @@ class GuardianHydra:
                     if self.verbose: print(f"❌ Model missing: {model_path}")
                     return False
                 
+                # ✅ إنشاء الكائن
                 clf = xgb.XGBClassifier()
-                clf.load_model(model_path)
-                self.models[h] = clf
-                if self.verbose: print(f"✅ Loaded Head: {h}")
+                
+                # =========================================================
+                # 💉 GEM-ARCHITECT PATCH: FORCE ESTIMATOR TYPE
+                # =========================================================
+                # هذا السطر يخبر XGBoost قسراً أن هذا الكائن هو Classifier
+                # لتجاوز فحص validate_loader الداخلي الذي يسبب الخطأ
+                clf._estimator_type = "classifier"
+                # =========================================================
+
+                try:
+                    clf.load_model(model_path)
+                    self.models[h] = clf
+                    if self.verbose: print(f"✅ Loaded Head: {h}")
+                except Exception as load_err:
+                    if self.verbose: print(f"⚠️ Failed to load {h} with XGBClassifier. Trying raw Booster...")
+                    # Fallback to raw booster if classifier wrapper fails completely
+                    bst = xgb.Booster()
+                    bst.load_model(model_path)
+                    self.models[h] = bst # Note: Prediction logic handles this differently usually, but we keep clf flow first.
 
             self.initialized = True
             if self.verbose: print(f"✅ [Hydra X-RAY] System Ready.")
@@ -81,10 +101,7 @@ class GuardianHydra:
                 
             df_1m = pd.DataFrame(ohlcv_1m, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             
-            # [DIAGNOSTIC 1] Print Input Sample
             last_close = df_1m['close'].iloc[-1]
-            if self.verbose: 
-                print(f"🔍 [Input Check] Last Close: {last_close} | Candles: {len(df_1m)}")
             
             if len(df_1m) < 50: 
                 if self.verbose: print(f"⚠️ [X-RAY] Not enough history: {len(df_1m)} < 50")
@@ -94,14 +111,9 @@ class GuardianHydra:
             df_1m['atr'] = ta.atr(df_1m['high'], df_1m['low'], df_1m['close'], length=self.ATR_PERIOD)
             df_1m['rsi'] = ta.rsi(df_1m['close'], length=14)
             
-            # [DIAGNOSTIC 2] Check Indicators
             last_rsi = df_1m['rsi'].iloc[-1]
             last_atr = df_1m['atr'].iloc[-1]
             
-            if (pd.isna(last_rsi) or pd.isna(last_atr)) and self.verbose:
-                print(f"⚠️ [X-RAY] Indicators are NaN! RSI: {last_rsi}, ATR: {last_atr}")
-            
-            # ... rest of calculations ...
             bb = ta.bbands(df_1m['close'], length=20, std=2)
             if bb is not None:
                 w_col = [c for c in bb.columns if 'BBB' in c]
@@ -126,7 +138,7 @@ class GuardianHydra:
 
             # Trade Context
             entry_price = float(trade_context.get('entry_price', 0.0))
-            if entry_price == 0: entry_price = last_close # Fallback
+            if entry_price == 0: entry_price = last_close 
             
             atr_val = last_atr if last_atr > 0 else (entry_price * 0.01)
             sl_dist_unit = 1.5 * atr_val 
@@ -168,9 +180,6 @@ class GuardianHydra:
                     vector[col] = 0.0
             
             if vector.isnull().values.any():
-                if self.verbose:
-                    print("⚠️ [X-RAY] Final Vector contains NaNs! Model will fail or output 0.")
-                    print(vector.iloc[0].to_dict())
                 vector = vector.fillna(0) 
             
             return vector[self.feature_cols].astype(float)
@@ -189,7 +198,6 @@ class GuardianHydra:
             features = self._engineer_features(ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_data)
             
             if features is None:
-                if self.verbose: print(f"🚫 [X-RAY] {symbol}: Feature Engineering Failed.")
                 return {'action': 'HOLD', 'reason': 'Feat Fail'}
 
             probs = {}
@@ -197,8 +205,18 @@ class GuardianHydra:
             
             for h in ['crash', 'giveback', 'stagnation']:
                 try:
-                    full_pred = self.models[h].predict_proba(features)
-                    raw_prob = full_pred[0][1]
+                    model = self.models[h]
+                    # Check if it's a Raw Booster or Sklearn Wrapper
+                    if isinstance(model, xgb.Booster):
+                        # For raw booster, we need DMatrix
+                        dtest = xgb.DMatrix(features)
+                        # Booster returns raw probability directly for binary classification
+                        raw_prob = model.predict(dtest)[0] 
+                    else:
+                        # Sklearn Wrapper
+                        full_pred = model.predict_proba(features)
+                        raw_prob = full_pred[0][1]
+
                     probs[h] = raw_prob
                     
                     if raw_prob > 0.0 and self.verbose: