Update ml_engine/hybrid_guardian.py

ml_engine/hybrid_guardian.py

@@ -1,6 +1,5 @@
 # ml_engine/hybrid_guardian.py
-# (V4.0 - The Dual Brain: Hybrid V2 + V3 Logic - FULL PRODUCTION CODE)
-# GEM-Architect Implementation
+# (V23.0 - GEM-Architect: Institutional Fuzzy Logic + Ultra-Confidence Override)
 
 import os
 import json
@@ -15,6 +14,7 @@ class HybridDeepSteward:
     def __init__(self, v2_model_path, v3_model_path, v3_features_map_path):
         """
         The Hybrid Guardian: Combines V2 (Regime Detection) and V3 (Precision Exit).
+        Uses "Fuzzy Logic" zones instead of hard cutoffs.
         """
         self.v2_path = v2_model_path
         self.v3_path = v3_model_path
@@ -25,16 +25,19 @@ class HybridDeepSteward:
         self.v3_feature_names = []
         self.initialized = False
         
-        # ⚙️ إعدادات الإستراتيجية الهجينة
-        # 1. V2 Gates (البوابات - رادار السياق)
-        self.V2_RISK_GATE = 0.60      # إذا كان V2 أقل من هذا، نتجاهل V3 (وضع آمن)
-        self.V2_PANIC_TRIGGER = 0.90  # إذا وصل V2 لهذا، نخرج فوراً (Black Swan)
+        # ⚙️ إعدادات المناطق المنطقية (Institutional Logic Zones)
         
-        # 2. V3 Thresholds (القناص - القرار اللحظي)
-        self.V3_HARD_EXIT = 0.90      # خروج كامل
-        self.V3_SOFT_EXIT = 0.75      # خروج جزئي أو شد الستوب (تحذير)
+        # 1. حدود V2 (الرادار - يحدد السياق)
+        self.V2_SAFE_LIMIT = 0.50     # تحت هذا الرقم: أمان قوي
+        self.V2_GREY_LIMIT = 0.60     # بين 0.50 و 0.60: منطقة رمادية (قلق بسيط)
+        self.V2_PANIC_TRIGGER = 0.90  # فوق هذا الرقم: انهيار مؤكد (Panic)
 
-        # ميزات V2 (ثابتة من التصميم القديم - تتطلب 64 شمعة)
+        # 2. حدود V3 (القناص - يحدد التنفيذ)
+        self.V3_SOFT_EXIT = 0.75      # خروج جزئي/تحذير
+        self.V3_HARD_EXIT = 0.90      # خروج كامل قياسي
+        self.V3_ULTRA_CONF = 0.97     # "كسر الفيتو": خروج حتى لو V2 آمن
+        
+        # ميزات V2 (ثابتة)
         self.V2_FEATURES = [
             'log_ret', 'rel_vol', 'rsi_norm', 'macd_hist', 'roc', 
             'bb_width', 'bb_pct', 'atr_pct', 'dist_ema50', 'dist_ema200',
@@ -42,134 +45,93 @@ class HybridDeepSteward:
         ]
 
     def initialize(self):
-        """تحميل كلا النموذجين"""
+        """تحميل النماذج"""
         try:
-            if not os.path.exists(self.v2_path):
-                print(f"❌ [HybridGuardian] V2 Model missing: {self.v2_path}")
-                return False
-            if not os.path.exists(self.v3_path):
-                print(f"❌ [HybridGuardian] V3 Model missing: {self.v3_path}")
-                return False
+            if not os.path.exists(self.v2_path): return False
+            if not os.path.exists(self.v3_path): return False
 
-            # Load V2
             self.model_v2 = xgb.Booster()
             self.model_v2.load_model(self.v2_path)
             
-            # Load V3
             self.model_v3 = xgb.Booster()
             self.model_v3.load_model(self.v3_path)
             
-            # Load V3 Features Map
             if os.path.exists(self.v3_features_path):
                 with open(self.v3_features_path, 'r') as f:
                     self.v3_feature_names = json.load(f)
             else:
-                print("❌ [HybridGuardian] V3 Feature map missing.")
                 return False
 
             self.initialized = True
-            print(f"✅ [HybridGuardian] Active. V2 Gate: {self.V2_RISK_GATE}, V3 Hard: {self.V3_HARD_EXIT}")
+            print(f"✅ [HybridGuardian V23] Logic: Safe<{self.V2_SAFE_LIMIT} | Grey<{self.V2_GREY_LIMIT} | Panic>{self.V2_PANIC_TRIGGER}")
             return True
 
         except Exception as e:
             print(f"❌ [HybridGuardian] Init Failed: {e}")
-            traceback.print_exc()
             return False
 
     # ==========================================================================
     # 🧠 V2 Feature Logic (Legacy 64-Candle Sequence)
     # ==========================================================================
     def _engineer_v2_features(self, df, current_price, entry_price):
-        """ 
-        تحضير ميزات النموذج القديم V2.
-        يتطلب هذا النموذج تسلسل زمني (Sequence) لآخر 64 شمعة، ثم تسطيحها.
-        """
         try:
             df = df.copy()
-            # نحتاج على الأقل 200 شمعة لحساب المؤشرات (مثل EMA200) بشكل صحيح قبل القص
             if len(df) < 200: return None
             
-            # 1. الحسابات الأساسية
             df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
-            
             vol_sma = df['volume'].rolling(window=50).mean()
             df['rel_vol'] = (df['volume'] - vol_sma) / (vol_sma + 1e-9)
-            
             df['rsi'] = ta.rsi(df['close'], length=14)
             df['rsi_norm'] = df['rsi'] / 100.0
-            
             macd = ta.macd(df['close'], fast=12, slow=26, signal=9)
-            # pandas_ta returns MACDh_12_26_9
             hist_col = [c for c in macd.columns if 'MACDh' in c][0]
             df['macd_hist'] = macd[hist_col]
-            
             df['roc'] = ta.roc(df['close'], length=9) / 100.0
-            
             bb = ta.bbands(df['close'], length=20, std=2)
             w_col = [c for c in bb.columns if 'BBB' in c][0]
             p_col = [c for c in bb.columns if 'BBP' in c][0]
             df['bb_width'] = bb[w_col] / 100.0
             df['bb_pct'] = bb[p_col]
-            
             df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
             df['atr_pct'] = df['atr'] / df['close']
-            
             df['ema50'] = ta.ema(df['close'], length=50)
             df['ema200'] = ta.ema(df['close'], length=200)
             df['dist_ema50'] = (df['close'] - df['ema50']) / (df['ema50'] + 1e-9)
             df['dist_ema200'] = (df['close'] - df['ema200']) / (df['ema200'] + 1e-9)
-            
-            # القناة السعرية للصفقة الحالية
             current_pnl = (current_price - entry_price) / entry_price
             df['pnl_channel'] = current_pnl
             
             df = df.fillna(0)
-            
-            # 2. استخراج آخر 64 شمعة (Sequence)
-            window = df.iloc[-64:][self.V2_FEATURES].values # Shape: (64, 11)
-            
-            if window.shape[0] < 64: 
-                return None
-                
-            # 3. التسطيح (Flattening) ليصبح (1, 704)
-            feature_vector = window.reshape(1, -1)
-            return feature_vector
-            
-        except Exception as e:
-            # print(f"V2 Feature Error: {e}")
+            window = df.iloc[-64:][self.V2_FEATURES].values
+            if window.shape[0] < 64: return None
+            return window.reshape(1, -1)
+        except:
             return None
 
     # ==========================================================================
-    # 🧬 V3 Feature Logic (Advanced Multi-Timeframe Single Row)
+    # 🧬 V3 Feature Logic (Advanced Multi-Timeframe)
     # ==========================================================================
     def _add_v3_indicators(self, df, window_mc):
-        """ دالة مساعدة لحساب مؤشرات V3 ومونت كارلو """
         try:
-            # 1. Technicals
             df['rsi'] = ta.rsi(df['close'], length=14)
             df['rsi_slope'] = ta.slope(df['rsi'], length=3)
-            
             macd = ta.macd(df['close'])
             if macd is not None and 'MACDh_12_26_9' in macd.columns:
                 df['macd_h'] = macd['MACDh_12_26_9']
                 df['macd_h_slope'] = ta.slope(df['macd_h'], length=3)
             else:
-                df['macd_h'] = 0
-                df['macd_h_slope'] = 0
+                df['macd_h'] = 0; df['macd_h_slope'] = 0
                 
             adx = ta.adx(df['high'], df['low'], df['close'], length=14)
             if adx is not None and 'ADX_14' in adx.columns:
                 df['adx'] = adx['ADX_14']
                 df['trend_net_force'] = adx['DMP_14'] - adx['DMN_14']
             else:
-                df['adx'] = 0
-                df['trend_net_force'] = 0
+                df['adx'] = 0; df['trend_net_force'] = 0
 
-            # EMAs
             df['ema_20'] = ta.ema(df['close'], length=20)
             df['ema_50'] = ta.ema(df['close'], length=50)
             df['ema_200'] = ta.ema(df['close'], length=200)
-            
             df['dist_ema20'] = (df['close'] - df['ema_20']) / df['close']
             df['dist_ema50'] = (df['close'] - df['ema_50']) / df['close']
             df['dist_ema200'] = (df['close'] - df['ema_200']) / df['close']
@@ -183,177 +145,157 @@ class HybridDeepSteward:
             df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
             df['atr_rel'] = df['atr'] / df['close']
 
-            # Volume
             df['obv'] = ta.obv(df['close'], df['volume'])
             df['obv_slope'] = ta.slope(df['obv'], length=5)
             df['cmf'] = ta.cmf(df['high'], df['low'], df['close'], df['volume'], length=20)
 
-            # 2. Monte Carlo (Vectorized)
             df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
-            
             roll_std = df['log_ret'].rolling(window=window_mc).std()
             roll_mean = df['log_ret'].rolling(window=window_mc).mean()
-            
             df['mc_skew'] = df['log_ret'].rolling(window=window_mc*2).skew()
             df['mc_kurt'] = df['log_ret'].rolling(window=window_mc*2).kurt()
-            
-            # Probability
             drift = roll_mean - (0.5 * roll_std**2)
             z_score = (0 - drift) / (roll_std + 1e-9)
             df['mc_prob_gain'] = 1 - norm.cdf(z_score)
-            
             var_95 = drift + (-1.645 * roll_std)
             df['mc_var_95'] = var_95
             df['mc_shock'] = (df['log_ret'] - roll_mean) / (roll_std + 1e-9)
             
             return df
-        except Exception as e:
-            # print(f"V3 Indicator Error: {e}")
+        except:
             return df
 
     def _engineer_v3_features(self, ohlcv_1m, ohlcv_5m, ohlcv_15m):
-        """ 
-        تحضير ميزات النموذج الجديد V3.
-        يعتمد على آخر صف فقط (Last Row) بعد دمج المؤشرات من الأطر الزمنية المختلفة.
-        """
         try:
-            # 1. Convert to DF
             df1 = pd.DataFrame(ohlcv_1m, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             df5 = pd.DataFrame(ohlcv_5m, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             df15 = pd.DataFrame(ohlcv_15m, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             
-            # التأكد من كفاية البيانات (للمتوسطات المتحركة الطويلة)
-            if len(df1) < 200 or len(df5) < 50 or len(df15) < 50:
-                return None
+            if len(df1) < 200 or len(df5) < 50 or len(df15) < 50: return None
 
-            # 2. Calculate Indicators (Full logic included locally)
             df1 = self._add_v3_indicators(df1, window_mc=30)
             df5 = self._add_v3_indicators(df5, window_mc=30)
             df15 = self._add_v3_indicators(df15, window_mc=20)
             
-            # 3. Merge Logic (Extracting Last Row Context)
-            # بما أننا نستخدم البيانات في اللحظة الحالية (Inference)، لا نحتاج لـ merge_asof المعقدة للماضي،
-            # بل نحتاج لآخر قيمة معروفة من كل إطار زمني.
-            
-            row1 = df1.iloc[-1]
-            row5 = df5.iloc[-1]
-            row15 = df15.iloc[-1]
+            row1 = df1.iloc[-1]; row5 = df5.iloc[-1]; row15 = df15.iloc[-1]
             
-            combined_features = {}
-            
-            # 1m Features (Primary)
-            for col in row1.index:
-                combined_features[col] = row1[col]
+            combined = {}
+            for col in row1.index: combined[col] = row1[col]
+            for col in ['rsi', 'rsi_slope', 'macd_h', 'bb_pct', 'mc_prob_gain', 'mc_shock']:
+                if col in row5: combined[f"{col}_5m"] = row5[col]
+            for col in ['rsi', 'macd_h', 'trend_net_force', 'mc_prob_gain', 'dist_ema200']:
+                if col in row15: combined[f"{col}_15m"] = row15[col]
                 
-            # 5m Features (Context - with suffix)
-            # القائمة يجب أن تطابق ما تم استخدامه في دالة process_symbol_data أثناء هندسة الميزات
-            cols_5m_target = ['rsi', 'rsi_slope', 'macd_h', 'bb_pct', 'mc_prob_gain', 'mc_shock']
-            for col in cols_5m_target:
-                if col in row5:
-                    combined_features[f"{col}_5m"] = row5[col]
-            
-            # 15m Features (Trend - with suffix)
-            cols_15m_target = ['rsi', 'macd_h', 'trend_net_force', 'mc_prob_gain', 'dist_ema200']
-            for col in cols_15m_target:
-                if col in row15:
-                    combined_features[f"{col}_15m"] = row15[col]
-            
-            # 4. Align with Feature Map (The crucial step)
-            # ترتيب الأعمدة يجب أن يكون مطابقاً تماماً لملف JSON
             vector = []
             for fname in self.v3_feature_names:
-                val = combined_features.get(fname, np.nan)
-                
-                # معالجة القيم المفقودة (نفس منطق XGBoost الافتراضي أو صفر)
-                if pd.isna(val) or np.isinf(val):
-                    val = 0.0
+                val = combined.get(fname, 0.0)
+                if pd.isna(val) or np.isinf(val): val = 0.0
                 vector.append(val)
             
-            # Reshape for prediction (1 sample, N features)
             return np.array(vector).reshape(1, -1)
-            
-        except Exception as e:
-            print(f"V3 Feature Prep Error: {e}")
-            traceback.print_exc()
+        except:
             return None
 
     # ==========================================================================
-    # 🛡️ The Grand Logic (التنفيذ الهجين)
+    # 🛡️ The Institutional Hybrid Logic (المنطق المؤسسي الجديد)
     # ==========================================================================
     def analyze_position(self, ohlcv_1m, ohlcv_5m, ohlcv_15m, entry_price):
-        """
-        يحلل الصفقة باستخدام النموذجين معاً.
-        """
         if not self.initialized:
             return {'action': 'HOLD', 'reason': 'Not Initialized'}
 
         try:
-            # 1. تحليل V2 (الرادار - يحتاج 64 شمعة دقيقة)
+            # 1. الحسابات (Inference)
             df_1m_raw = pd.DataFrame(ohlcv_1m, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             current_price = df_1m_raw['close'].iloc[-1]
             
+            # V2 Score
             feat_v2 = self._engineer_v2_features(df_1m_raw, current_price, entry_price)
-            
-            if feat_v2 is None:
-                score_v2 = 0.0 # بيانات غير كافية -> افترض الأمان
-            else:
-                # V2 يعطي احتمالية الخطر
-                score_v2 = float(self.model_v2.predict(xgb.DMatrix(feat_v2))[0])
+            score_v2 = float(self.model_v2.predict(xgb.DMatrix(feat_v2))[0]) if feat_v2 is not None else 0.0
 
-            # 2. تحليل V3 (القناص - يحتاج دمج الأطر)
+            # V3 Score
             feat_v3 = self._engineer_v3_features(ohlcv_1m, ohlcv_5m, ohlcv_15m)
-            
-            if feat_v3 is None:
-                score_v3 = 0.0
-            else:
-                # V3 يعطي احتمالية الخطر بدقة
-                score_v3 = float(self.model_v3.predict(xgb.DMatrix(feat_v3, feature_names=self.v3_feature_names))[0])
+            score_v3 = float(self.model_v3.predict(xgb.DMatrix(feat_v3, feature_names=self.v3_feature_names))[0]) if feat_v3 is not None else 0.0
 
-            # 3. منطق القرار (The Gating Logic)
-            
-            # السيناريو أ: انهيار كارثي يكتشفه V2 (Black Swan)
+            scores_dict = {'v2': score_v2, 'v3': score_v3}
+
+            # ---------------------------------------------------------
+            # 🧠 منطق اتخاذ القرار (Decision Logic Tree)
+            # ---------------------------------------------------------
+
+            # الحالة 1: V2 Panic (انهيار كارثي واضح)
             if score_v2 >= self.V2_PANIC_TRIGGER:
                 return {
                     'action': 'EXIT_HARD',
                     'confidence': score_v2,
-                    'reason': f'🚨 V2 PANIC (Score: {score_v2:.2f}) - Market Crash Detected',
-                    'scores': {'v2': score_v2, 'v3': score_v3}
+                    'reason': f'🚨 V2 PANIC (S:{score_v2:.2f}) - Market Crash Regime',
+                    'scores': scores_dict
                 }
 
-            # السيناريو ب: السوق آمن حسب V2 (تجاهل V3 لتقليل الضوضاء)
-            if score_v2 < self.V2_RISK_GATE:
-                return {
-                    'action': 'HOLD',
-                    'confidence': 1.0 - score_v2, # ثقة البقاء
-                    'reason': f'✅ V2 Safe Zone (Score: {score_v2:.2f})',
-                    'scores': {'v2': score_v2, 'v3': score_v3}
-                }
+            # الحالة 2: V2 Safe Zone (سوق آمن)
+            elif score_v2 < self.V2_SAFE_LIMIT:
+                # استثناء الثقة العمياء لـ V3
+                if score_v3 >= self.V3_ULTRA_CONF:
+                    return {
+                        'action': 'EXIT_HARD',
+                        'confidence': score_v3,
+                        'reason': f'⚡ V3 ULTRA OVERRIDE (S:{score_v3:.2f} > {self.V3_ULTRA_CONF}) - Sniper detects acute danger in Safe Zone',
+                        'scores': scores_dict
+                    }
+                else:
+                    return {
+                        'action': 'HOLD',
+                        'confidence': 1.0 - score_v2,
+                        'reason': f'✅ Safe Regime (V2:{score_v2:.2f} < {self.V2_SAFE_LIMIT}) - V3({score_v3:.2f}) Vetoed',
+                        'scores': scores_dict
+                    }
 
-            # السيناريو ج: منطقة القلق (V2 > 0.60) -> استشر القناص V3
-            if score_v3 >= self.V3_HARD_EXIT:
-                return {
-                    'action': 'EXIT_HARD',
-                    'confidence': score_v3,
-                    'reason': f'🎯 V3 Sniper Kill (Score: {score_v3:.2f}) [V2 Activated]',
-                    'scores': {'v2': score_v2, 'v3': score_v3}
-                }
-            
-            elif score_v3 >= self.V3_SOFT_EXIT:
-                return {
-                    'action': 'EXIT_SOFT', # أو Tighten SL
-                    'confidence': score_v3,
-                    'reason': f'⚠️ V3 Warning (Score: {score_v3:.2f}) [V2 Activated]',
-                    'scores': {'v2': score_v2, 'v3': score_v3}
-                }
+            # الحالة 3: V2 Grey Zone (منطقة رمادية) - نسمح لـ V3 بالتدخل بشروط
+            elif self.V2_SAFE_LIMIT <= score_v2 < self.V2_GREY_LIMIT:
+                if score_v3 >= self.V3_HARD_EXIT: # 0.90
+                    return {
+                        'action': 'EXIT_HARD',
+                        'confidence': score_v3,
+                        'reason': f'🎯 V3 Sniper (S:{score_v3:.2f}) inside Grey Zone',
+                        'scores': scores_dict
+                    }
+                elif score_v3 >= self.V3_SOFT_EXIT: # 0.75
+                    return {
+                        'action': 'EXIT_SOFT',
+                        'confidence': score_v3,
+                        'reason': f'⚠️ V3 Warning (S:{score_v3:.2f}) inside Grey Zone',
+                        'scores': scores_dict
+                    }
+                else:
+                    return {
+                        'action': 'HOLD',
+                        'confidence': 1.0 - score_v3,
+                        'reason': f'👀 Grey Zone (V2:{score_v2:.2f}) - V3({score_v3:.2f}) Waiting for signal',
+                        'scores': scores_dict
+                    }
 
-            else:
-                # V2 قلق، لكن V3 لم يجد سبباً تقنياً محدداً للخروج
-                return {
-                    'action': 'HOLD',
-                    'confidence': 1.0 - score_v3,
-                    'reason': f'👀 V2 Alert ({score_v2:.2f}) but V3 holds ({score_v3:.2f})',
-                    'scores': {'v2': score_v2, 'v3': score_v3}
-                }
+            # الحالة 4: V2 Risk Zone (بوابة الخطر مفتوحة) - V3 يعمل بحرية
+            else: # 0.60 <= score_v2 < 0.90
+                if score_v3 >= self.V3_HARD_EXIT:
+                    return {
+                        'action': 'EXIT_HARD',
+                        'confidence': score_v3,
+                        'reason': f'🔥 V3 Kill (S:{score_v3:.2f}) [Risk Gate Open V2:{score_v2:.2f}]',
+                        'scores': scores_dict
+                    }
+                elif score_v3 >= self.V3_SOFT_EXIT:
+                    return {
+                        'action': 'EXIT_SOFT',
+                        'confidence': score_v3,
+                        'reason': f'⚠️ V3 Soft (S:{score_v3:.2f}) [Risk Gate Open V2:{score_v2:.2f}]',
+                        'scores': scores_dict
+                    }
+                else:
+                    return {
+                        'action': 'HOLD',
+                        'confidence': 1.0 - score_v3,
+                        'reason': f'🛡️ High Alert (V2:{score_v2:.2f}) but V3({score_v3:.2f}) Holds',
+                        'scores': scores_dict
+                    }
 
         except Exception as e:
             print(f"❌ [HybridGuardian] Inference Error: {e}")