Update ml_engine/processor.py

ml_engine/processor.py

@@ -1,6 +1,6 @@
 # ============================================================
 # 🧠 ml_engine/processor.py 
-# (V66.0 - GEM-Architect: Direct Context Injection Fixed)
+# (V67.0 - GEM-Architect: Hybrid Gates & Conditional Hydra)
 # ============================================================
 
 import asyncio
@@ -41,48 +41,47 @@ MODEL_V3_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Production.j
 MODEL_V3_FEAT = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Features.json")
 
 # ============================================================
-# 🎛️ SYSTEM LIMITS (Fallback Only)
+# 🎛️ SYSTEM LIMITS (Baseline Defaults - Balanced Profile)
 # ============================================================
 class SystemLimits:
     """
-    GEM-Architect: Fallback Values.
-    The real values are now injected dynamically via 'dynamic_limits' per Coin Type.
+    GEM-Architect: Baseline Values (Balanced).
+    Real values are injected dynamically from AdaptiveHub.
     """
     
-    # --- Layer 1 ---
-    L1_MIN_AFFINITY_SCORE = 15.0  
+    # --- Layer 2 Hard Gates (Minimums to Qualify) ---
+    L2_GATE_TITAN    = 0.70
+    L2_GATE_PATTERN  = 0.60
+    L2_GATE_MC       = 0.55
     
+    # --- Layer 2 Weighted Score Threshold ---
+    L2_MIN_SCORE     = 0.75 
+
     # --- Layer 2 Weights ---
     L2_WEIGHT_TITAN    = 0.40
-    L2_WEIGHT_PATTERNS = 0.30
-    L2_WEIGHT_MC       = 0.10
+    L2_WEIGHT_PATTERNS = 0.40
+    L2_WEIGHT_MC       = 0.20
 
     # Pattern Config
-    PATTERN_TF_WEIGHTS = {'15m': 0.40, '1h': 0.30, '5m': 0.20, '4h': 0.10, '1d': 0.00}
+    PATTERN_TF_WEIGHTS = {'1h': 0.35, '15m': 0.25, '1d': 0.20, '5m': 0.10, '4h': 0.10}
     PATTERN_THRESH_BULLISH = 0.60
     PATTERN_THRESH_BEARISH = 0.40
 
-    # --- Layer 3 ---
-    L3_CONFIDENCE_THRESHOLD = 0.65
-    L3_WHALE_IMPACT_MAX = 0.10
-    L3_NEWS_IMPACT_MAX  = 0.05
-    L3_MC_ADVANCED_MAX  = 0.10
-
-    # --- Layer 4 ---
-    L4_ENTRY_THRESHOLD  = 0.40
-    L4_WEIGHT_ML        = 0.60
-    L4_WEIGHT_OB        = 0.40
+    # --- Layer 4 (Oracle) ---
+    L3_CONFIDENCE_THRESHOLD = 0.90 # High Precision
+    
+    # --- Layer 5 (Sniper) ---
+    L4_ENTRY_THRESHOLD  = 0.45 
     L4_OB_WALL_RATIO    = 0.40
 
     # --- Layer 0: Hydra & Guardian Defaults ---
-    HYDRA_CRASH_THRESH      = 0.85
-    HYDRA_GIVEBACK_THRESH   = 0.85
-    HYDRA_STAGNATION_THRESH = 0.80
+    HYDRA_CRASH_THRESH      = 0.60 # Increased Capture
+    HYDRA_GIVEBACK_THRESH   = 0.80 # Needs Activation Condition
+    HYDRA_STAGNATION_THRESH = 0.60 # Needs Time Condition
 
-    LEGACY_V2_PANIC_THRESH = 0.95
-    LEGACY_V3_HARD_THRESH  = 0.95
-    LEGACY_V3_SOFT_THRESH  = 0.88
-    LEGACY_V3_ULTRA_THRESH = 0.99
+    # Fixed Legacy Guards
+    LEGACY_V2_PANIC_THRESH = 0.98 # High Precision
+    LEGACY_V3_HARD_THRESH  = 0.95 # High Precision
 
     @classmethod
     def to_dict(cls) -> Dict[str, Any]:
@@ -114,7 +113,7 @@ class MLProcessor:
                 v3_features_map_path=MODEL_V3_FEAT
             )
 
-        print(f"🧠 [MLProcessor V66.0] Context-Aware Injection Active.")
+        print(f"🧠 [MLProcessor V67.0] Hybrid Scoring & Conditional Hydra Active.")
 
     async def initialize(self):
         if self.initialized: return
@@ -141,8 +140,7 @@ class MLProcessor:
                     self.sniper.configure_settings(
                         threshold=SystemLimits.L4_ENTRY_THRESHOLD, 
                         wall_ratio=SystemLimits.L4_OB_WALL_RATIO,
-                        w_ml=SystemLimits.L4_WEIGHT_ML,
-                        w_ob=SystemLimits.L4_WEIGHT_OB
+                        w_ml=0.60, w_ob=0.40
                     )
                 tasks.append(self.sniper.initialize())
             
@@ -158,12 +156,11 @@ class MLProcessor:
                 else:
                     self.guardian_legacy.initialize()
                 
-                # Default init
+                # Default init (Fixed values)
                 self.guardian_legacy.configure_thresholds(
                     v2_panic=SystemLimits.LEGACY_V2_PANIC_THRESH,
                     v3_hard=SystemLimits.LEGACY_V3_HARD_THRESH,
-                    v3_soft=SystemLimits.LEGACY_V3_SOFT_THRESH,
-                    v3_ultra=SystemLimits.LEGACY_V3_ULTRA_THRESH
+                    v3_soft=0.88, v3_ultra=0.99
                 )
                 print(f"   🛡️ [Guard 2] Legacy Steward: Active")
 
@@ -176,28 +173,27 @@ class MLProcessor:
 
     async def process_compound_signal(self, raw_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         """
-        L2 Processing with Dynamic Weight Injection
+        L2 Processing with Hybrid Gated Scoring (Gate -> Weight -> Final)
         """
         if not self.initialized: await self.initialize()
         
         symbol = raw_data.get('symbol')
         ohlcv_data = raw_data.get('ohlcv')
         current_price = raw_data.get('current_price', 0.0)
-        
-        # ✅ الحقن المباشر للقيم
         limits = raw_data.get('dynamic_limits', {})
         
         if not symbol or not ohlcv_data: return None
         
         try:
-            # 1. Titan
+            # --- 1. Raw Predictions ---
+            # Titan
             score_titan = 0.5
             titan_res = {}
             if self.titan:
                 titan_res = await asyncio.to_thread(self.titan.predict, ohlcv_data)
                 score_titan = titan_res.get('score', 0.5)
 
-            # 2. Pattern
+            # Patterns
             score_patterns = 0.5
             pattern_res = {}
             pattern_name = "Neutral"
@@ -206,7 +202,7 @@ class MLProcessor:
                 score_patterns = pattern_res.get('pattern_confidence', 0.5)
                 pattern_name = pattern_res.get('pattern_detected', 'Neutral')
 
-            # 3. MC
+            # Monte Carlo
             mc_score = 0.5
             if self.mc_analyzer and '1h' in ohlcv_data:
                 closes = [c[4] for c in ohlcv_data['1h']]
@@ -214,21 +210,36 @@ class MLProcessor:
                 mc_score = 0.5 + (raw_mc * 5.0)
                 mc_score = max(0.0, min(1.0, mc_score))
 
-            # 4. Hybrid Calc (Dynamic Injection)
+            # --- 2. Hybrid Gated Logic ---
+            # Extract Gates (Injectable, fallback to SystemLimits)
+            gate_titan = limits.get('l2_gate_titan', SystemLimits.L2_GATE_TITAN)
+            gate_patt  = limits.get('l2_gate_pattern', SystemLimits.L2_GATE_PATTERN)
+            gate_mc    = limits.get('l2_gate_mc', SystemLimits.L2_GATE_MC)
+            
+            # A) HARD GATES Check (Reject if component is too weak)
+            if score_titan < gate_titan: return None
+            if score_patterns < gate_patt: return None
+            if mc_score < gate_mc: return None
+
+            # B) Weighted Score Calculation
             w_titan = limits.get('w_titan', SystemLimits.L2_WEIGHT_TITAN)
             w_patt = limits.get('w_patt', SystemLimits.L2_WEIGHT_PATTERNS)
-            w_mc = SystemLimits.L2_WEIGHT_MC 
+            w_mc = limits.get('w_mc', SystemLimits.L2_WEIGHT_MC)
             
             total_w = w_titan + w_patt + w_mc
             if total_w <= 0: total_w = 1.0
             
             hybrid_score = ((score_titan * w_titan) + (score_patterns * w_patt) + (mc_score * w_mc)) / total_w
             
+            # C) Final Score Gate
+            min_l2_score = limits.get('l2_min_score', SystemLimits.L2_MIN_SCORE)
+            if hybrid_score < min_l2_score: return None
+
             return {
                 'symbol': symbol, 
                 'current_price': current_price, 
                 'enhanced_final_score': hybrid_score,
-                'dynamic_limits': limits, # تمرير الحدود للطبقات التالية
+                'dynamic_limits': limits, 
                 'asset_regime': raw_data.get('asset_regime', 'UNKNOWN'),
                 'strategy_type': raw_data.get('strategy_type', 'NORMAL'),
                 'titan_score': score_titan, 
@@ -251,7 +262,6 @@ class MLProcessor:
     async def consult_oracle(self, symbol_data: Dict[str, Any]) -> Dict[str, Any]:
         if not self.initialized: await self.initialize()
         
-        # ✅ الحقن المباشر للعتبة
         limits = symbol_data.get('dynamic_limits', {})
         threshold = limits.get('l3_oracle_thresh', SystemLimits.L3_CONFIDENCE_THRESHOLD)
         
@@ -272,9 +282,7 @@ class MLProcessor:
     async def check_sniper_entry(self, ohlcv_1m_data: List, order_book_data: Dict[str, Any], context_data: Dict = None) -> Dict[str, Any]:
         if not self.initialized: await self.initialize()
         
-        # ✅ الحقن المباشر
         limits = context_data.get('dynamic_limits', {}) if context_data else {}
-        
         thresh = limits.get('l4_sniper_thresh', SystemLimits.L4_ENTRY_THRESHOLD)
         wall_r = limits.get('l4_ob_wall_ratio', SystemLimits.L4_OB_WALL_RATIO)
 
@@ -283,8 +291,7 @@ class MLProcessor:
                 self.sniper.configure_settings(
                     threshold=thresh,
                     wall_ratio=wall_r,
-                    w_ml=SystemLimits.L4_WEIGHT_ML,
-                    w_ob=SystemLimits.L4_WEIGHT_OB
+                    w_ml=0.60, w_ob=0.40 # Fixed Weights per diagnosis
                 )
             return await self.sniper.check_entry_signal_async(ohlcv_1m_data, order_book_data)
             
@@ -292,27 +299,28 @@ class MLProcessor:
 
     def consult_dual_guardians(self, symbol, ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_context, order_book_snapshot=None):
         """
-        💎 GEM-Architect: الحقن المباشر لعتبات الحراس من سياق الصفقة
-        يضمن أن كل نوع عملة يتم حمايته بالعتبات الخاصة به (High Precision)
+        💎 GEM-Architect: Conditional Hydra Logic & Fixed Legacy
         """
         response = {'action': 'HOLD', 'detailed_log': '', 'probs': {}}
-        
-        # 1. استخراج الحدود الديناميكية من سياق الصفقة
-        # trade_context يمرر من TradeManager ويحتوي على dynamic_limits
         limits = trade_context.get('dynamic_limits', {})
         
-        # �� سحب القيم مع Fallback آمن
+        # --- Thresholds ---
         h_crash_thresh = limits.get('hydra_crash', SystemLimits.HYDRA_CRASH_THRESH)
         h_giveback_thresh = limits.get('hydra_giveback', SystemLimits.HYDRA_GIVEBACK_THRESH)
         h_stag_thresh = limits.get('hydra_stagnation', SystemLimits.HYDRA_STAGNATION_THRESH)
         
-        l_v2_thresh = limits.get('legacy_v2', SystemLimits.LEGACY_V2_PANIC_THRESH)
-        l_v3_hard = limits.get('legacy_v3_hard', SystemLimits.LEGACY_V3_HARD_THRESH)
-        l_v3_soft = limits.get('legacy_v3_soft', SystemLimits.LEGACY_V3_SOFT_THRESH)
-        l_v3_ultra = limits.get('legacy_v3_ultra', SystemLimits.LEGACY_V3_ULTRA_THRESH)
+        # --- Context Data for Conditions ---
+        entry_price = float(trade_context.get('entry_price', 0.0))
+        current_price = 0.0
+        if ohlcv_1m: current_price = float(ohlcv_1m[-1][4])
+        
+        highest_price = trade_context.get('highest_price', entry_price)
+        max_pnl_pct = ((highest_price - entry_price) / entry_price) * 100 if entry_price > 0 else 0.0
+        
+        time_in_trade_mins = trade_context.get('time_in_trade_mins', 0.0)
 
         # -----------------------------------------------
-        # 1. Hydra Execution
+        # 1. Hydra Execution (Conditional)
         # -----------------------------------------------
         hydra_result = {'action': 'HOLD', 'reason': 'Disabled', 'probs': {}}
         if self.guardian_hydra and self.guardian_hydra.initialized:
@@ -321,32 +329,45 @@ class MLProcessor:
             
             p_crash = h_probs.get('crash', 0.0)
             p_giveback = h_probs.get('giveback', 0.0)
+            p_stagnation = h_probs.get('stagnation', 0.0)
             
-            # 🔥 استخدام العتبات المحقونة
-            if hydra_result['action'] == 'HOLD':
-                if p_crash >= h_crash_thresh:
-                    hydra_result['action'] = 'EXIT_HARD'
-                    hydra_result['reason'] = f"Hydra Crash Risk {p_crash:.2f} >= {h_crash_thresh}"
-                elif p_giveback >= h_giveback_thresh:
+            # 🛑 CRASH: Always Active (Safety Net)
+            if p_crash >= h_crash_thresh:
+                hydra_result['action'] = 'EXIT_HARD'
+                hydra_result['reason'] = f"Hydra Crash Risk {p_crash:.2f} >= {h_crash_thresh}"
+                
+            # 🛑 GIVEBACK: Conditional Activation
+            # Trigger ONLY if we had decent profit (>0.6%)
+            elif p_giveback >= h_giveback_thresh:
+                if max_pnl_pct >= 0.6: 
                     hydra_result['action'] = 'EXIT_SOFT'
-                    hydra_result['reason'] = f"Hydra Giveback Risk {p_giveback:.2f} >= {h_giveback_thresh}"
-        
+                    hydra_result['reason'] = f"Hydra Giveback {p_giveback:.2f} (Max PnL {max_pnl_pct:.2f}%)"
+                else:
+                    hydra_result['action'] = 'HOLD' # Ignore noise if no profit to protect
+
+            # 🛑 STAGNATION: Conditional Activation (Time)
+            # Trigger ONLY if stuck for > 90 mins
+            elif p_stagnation >= h_stag_thresh:
+                if time_in_trade_mins > 90:
+                    hydra_result['action'] = 'EXIT_SOFT'
+                    hydra_result['reason'] = f"Hydra Stagnation {p_stagnation:.2f} (>90m)"
+                else:
+                    hydra_result['action'] = 'HOLD' # Too early to judge stagnation
+
         # -----------------------------------------------
-        # 2. Legacy Execution
+        # 2. Legacy Execution (Fixed Thresholds)
         # -----------------------------------------------
         legacy_result = {'action': 'HOLD', 'reason': 'Disabled', 'scores': {}}
         if self.guardian_legacy and self.guardian_legacy.initialized:
-            # 🔥 حقن الإعدادات ديناميكياً قبل التشغيل
+            # Fixed V2/V3 thresholds per diagnosis
             self.guardian_legacy.configure_thresholds(
-                v2_panic=l_v2_thresh,
-                v3_hard=l_v3_hard,
-                v3_soft=l_v3_soft,
-                v3_ultra=l_v3_ultra
+                v2_panic=0.98,
+                v3_hard=0.95,
+                v3_soft=0.88,
+                v3_ultra=0.99
             )
             
-            entry_price = float(trade_context.get('entry_price', 0.0))
             vol_30m = trade_context.get('volume_30m_usd', 0.0)
-            
             legacy_result = self.guardian_legacy.analyze_position(
                 ohlcv_1m, ohlcv_5m, ohlcv_15m, entry_price, 
                 order_book=order_book_snapshot,
@@ -361,19 +382,24 @@ class MLProcessor:
         
         h_c = h_probs.get('crash', 0.0)
         h_g = h_probs.get('giveback', 0.0)
-        h_s = h_probs.get('stagnation', 0.0) 
         l_v2 = l_scores.get('v2', 0.0)
-        l_v3 = l_scores.get('v3', 0.0)
         
-        stamp_str = f"🐲[C:{h_c:.0%}|G:{h_g:.0%}] 🕸️[V2:{l_v2:.0%}]"
+        stamp_str = f"🐲[C:{h_c:.2f}|G:{h_g:.2f}] 🕸️[V2:{l_v2:.2f}]"
 
         final_action = 'HOLD'
         final_reason = f"Safe. {stamp_str}"
         
-        if hydra_result['action'] in ['EXIT_HARD', 'EXIT_SOFT', 'TIGHTEN_SL', 'TRAIL_SL']:
+        # Priority: Hydra Crash > Legacy V2 > Hydra Giveback > Legacy V3
+        if hydra_result['action'] in ['EXIT_HARD']:
+             final_action = hydra_result['action']
+             final_reason = f"🐲 HYDRA: {hydra_result['reason']}"
+        elif legacy_result['action'] in ['EXIT_HARD']:
+             final_action = legacy_result['action']
+             final_reason = f"🕸️ LEGACY: {legacy_result['reason']}"
+        elif hydra_result['action'] in ['EXIT_SOFT']:
              final_action = hydra_result['action']
              final_reason = f"🐲 HYDRA: {hydra_result['reason']}"
-        elif legacy_result['action'] in ['EXIT_HARD', 'EXIT_SOFT']:
+        elif legacy_result['action'] in ['EXIT_SOFT']:
              final_action = legacy_result['action']
              final_reason = f"🕸️ LEGACY: {legacy_result['reason']}"