Update learning_hub/adaptive_hub.py

learning_hub/adaptive_hub.py

@@ -1,6 +1,6 @@
 # ==============================================================================
 # 🧠 learning_hub/adaptive_hub.py 
-# (V60.1 - GEM-Architect: Full Sync [Base + Deltas + Fast])
+# (V60.1 - GEM-Architect: Golden Values + Full Sync)
 # ==============================================================================
 
 import json
@@ -10,7 +10,7 @@ import traceback
 from collections import deque
 from typing import Dict, Any, List
 
-# محاولة استيراد SystemLimits
+# محاولة استيراد SystemLimits لتحديث النظام الحي
 try:
     from ml_engine.processor import SystemLimits
 except ImportError:
@@ -52,19 +52,9 @@ class StrategyDNA:
     def get_final_guards(self):
         final = {}
         for k, v in self.base_guards.items():
+            # For guards, we rely on Base updates mostly, but structure supports delta
             d_fast = self.delta_guards_fast.get(k, 0.0)
-            # Periodic tuner updates base directly or needs delta logic?
-            # V3.3 tuner updates delta via update_periodic_delta, so we assume deltas exist for guards too?
-            # Note: For simplicity, Periodic Tuner currently updates 'Deltas' passed to hub.
-            # We need to support Weekly/Monthly deltas for guards too if Tuner sends them.
-            # Let's keep it simple: Base + Fast + (Weekly/Monthly if implemented in map)
-            # Since Tuner V3.3 passes new_deltas map, we handle it in update_periodic_delta
-            
             val = v + d_fast 
-            # Check if we stored weekly/monthly for guards in a generic way? 
-            # Currently structure is separate. To avoid complexity, we rely on Base updates from Tuner 
-            # OR we assume Tuner updates delta_weekly dict which contains ALL keys.
-            
             final[k] = max(0.1, min(0.99, val))
         return final
 
@@ -89,31 +79,75 @@ class AdaptiveHub:
         self.dna_file_key = "learning/strategic_dna_v60_layered.json" 
         self.current_market_regime = "RANGE"
         self.strategies: Dict[str, StrategyDNA] = {}
-        print("🧠 [AdaptiveHub V60.1] Full Sync Architecture Initialized.")
+        print("🧠 [AdaptiveHub V60.1] Golden DNA Injection Active.")
 
     async def initialize(self):
         try:
             if self.r2:
                 data_bytes = await self.r2.get_file_async(self.dna_file_key)
                 if data_bytes:
-                    self._load_from_dict(json.loads(data_bytes))
+                    saved_data = json.loads(data_bytes)
+                    self._load_from_dict(saved_data)
+                    print("   📂 Loaded DNA from R2.")
                 else:
                     self._create_default_dna()
+                    print("   ⚠️ No R2 file. Created Golden Defaults.")
             else:
                 self._create_default_dna()
             self._inject_current_parameters()
-        except Exception:
+        except Exception as e:
+            print(f"   ❌ Init Error: {e}")
             self._create_default_dna()
 
     def _create_default_dna(self):
-        # Golden Values (Base)
-        d_guards = {"hydra_crash": 0.60, "hydra_giveback": 0.60, "legacy_v2": 0.85}
+        """
+        💎 GEM-Architect: الحقن المباشر للقيم الذهبية (Golden Values)
+        """
+        
+        # 1. BULL MARKET (Golden Config)
+        d_guards_bull = {"hydra_crash": 0.60, "hydra_giveback": 0.60, "legacy_v2": 0.85}
         d_filters_bull = {"l1_min_score": 0.60, "l3_oracle_thresh": 0.75, "l4_sniper_thresh": 0.50}
         
-        self.strategies["BULL"] = StrategyDNA("BULL", {"titan": 0.5, "structure": 0.1}, {"wall_ratio_limit": 0.6}, d_filters_bull, d_guards)
-        self.strategies["BEAR"] = StrategyDNA("BEAR", {"titan": 0.1, "structure": 0.1}, {"wall_ratio_limit": 0.3}, d_filters_bull, d_guards)
-        self.strategies["RANGE"] = StrategyDNA("RANGE", {"titan": 0.3, "structure": 0.3}, {"wall_ratio_limit": 0.4}, d_filters_bull, d_guards)
-        self.strategies["DEAD"] = StrategyDNA("DEAD", {"titan": 0.1, "structure": 0.1}, {"wall_ratio_limit": 0.2}, d_filters_bull, d_guards)
+        self.strategies["BULL"] = StrategyDNA(
+            "BULL", 
+            {"titan": 0.50, "structure": 0.10}, 
+            {"wall_ratio_limit": 0.60}, 
+            d_filters_bull, 
+            d_guards_bull
+        )
+
+        # 2. BEAR MARKET (Golden Config)
+        d_guards_bear = {"hydra_crash": 0.60, "hydra_giveback": 0.60, "legacy_v2": 0.85}
+        d_filters_bear = {"l1_min_score": 0.60, "l3_oracle_thresh": 0.75, "l4_sniper_thresh": 0.30} # Sniper lower
+        
+        self.strategies["BEAR"] = StrategyDNA(
+            "BEAR", 
+            {"titan": 0.10, "structure": 0.10}, 
+            {"wall_ratio_limit": 0.30}, 
+            d_filters_bear, 
+            d_guards_bear
+        )
+
+        # 3. RANGE/DEAD (Conservative Defaults)
+        d_guards_def = {"hydra_crash": 0.70, "hydra_giveback": 0.70, "legacy_v2": 0.90}
+        d_filters_range = {"l1_min_score": 0.65, "l3_oracle_thresh": 0.70, "l4_sniper_thresh": 0.40}
+        
+        self.strategies["RANGE"] = StrategyDNA(
+            "RANGE", 
+            {"titan": 0.30, "structure": 0.30}, 
+            {"wall_ratio_limit": 0.40}, 
+            d_filters_range, 
+            d_guards_def
+        )
+        
+        d_filters_dead = {"l1_min_score": 0.80, "l3_oracle_thresh": 0.80, "l4_sniper_thresh": 0.50}
+        self.strategies["DEAD"] = StrategyDNA(
+            "DEAD", 
+            {"titan": 0.10, "structure": 0.10}, 
+            {"wall_ratio_limit": 0.20}, 
+            d_filters_dead, 
+            {"hydra_crash": 0.50, "hydra_giveback": 0.50, "legacy_v2": 0.80}
+        )
 
     def _load_from_dict(self, data):
         for key, val in data.get("strategies", {}).items():
@@ -132,41 +166,31 @@ class AdaptiveHub:
         self.current_market_regime = data.get("current_regime", "RANGE")
 
     # ============================================================
-    # 🧪 STRATEGIC BACKTEST LINK (Base Updater) - RESTORED!
+    # 🧪 STRATEGIC BACKTEST LINK (Base Updater)
     # ============================================================
     def submit_challenger(self, regime: str, new_config: dict, new_stats: dict) -> bool:
-        """
-        Called by HeavyDutyBacktester (Strategic Run).
-        Updates BASE values and resets Deltas (Clean Slate).
-        """
         if regime not in self.strategies: return False
         champion = self.strategies[regime]
         
-        # Logic to accept new config (Always accept if from manual Strategic run)
         print(f"   ⚖️ [Strategic Update] Updating BASE DNA for {regime}...")
         
-        # 1. Update Base Weights
+        # Update Base
         champion.model_weights['titan'] = new_config['w_titan']
         champion.model_weights['structure'] = new_config['w_struct']
-        
-        # 2. Update Base Filters
         champion.base_filters['l1_min_score'] = new_config['thresh']
         champion.base_filters['l3_oracle_thresh'] = new_config.get('oracle_thresh', 0.65)
         champion.base_filters['l4_sniper_thresh'] = new_config.get('sniper_thresh', 0.40)
-        
-        # 3. Update Base Guards
         champion.base_guards['hydra_crash'] = new_config['hydra_thresh']
-        champion.base_guards['hydra_giveback'] = new_config['hydra_thresh'] # Unified in backtest
+        champion.base_guards['hydra_giveback'] = new_config['hydra_thresh']
         champion.base_guards['legacy_v2'] = new_config['legacy_thresh']
-        
         champion.backtest_performance = new_stats
         
-        # 4. RESET DELTAS (New Base = New Start)
+        # Reset Deltas
         for k in champion.delta_weekly: champion.delta_weekly[k] = 0.0
         for k in champion.delta_monthly: champion.delta_monthly[k] = 0.0
         for k in champion.delta_fast: champion.delta_fast[k] = 0.0
         
-        # 5. Save & Inject Immediately
+        # Save & Inject
         asyncio.create_task(self._save_state_to_r2())
         self._inject_current_parameters()
         return True
@@ -180,14 +204,13 @@ class AdaptiveHub:
         dna.trade_buffer.append(trade_data)
         
         if len(dna.trade_buffer) >= 100:
-            print(f"🎓 [Fast Learner] Batch of 100 trades reached for {self.current_market_regime}. Analyzing...")
+            print(f"🎓 [Fast Learner] Batch of 100 trades reached. Analyzing...")
             self._process_fast_learning_batch(dna)
             dna.trade_buffer.clear()
             await self._save_state_to_r2()
             self._inject_current_parameters()
 
     def _process_fast_learning_batch(self, dna: StrategyDNA):
-        # Simple Logic: Check Oracle & Sniper
         models = ['l3_oracle_thresh', 'l4_sniper_thresh']
         performance = {m: {'wins': 0, 'total': 0, 'pnl_sum': 0.0} for m in models}
         
@@ -220,10 +243,8 @@ class AdaptiveHub:
             
             if win_rate < TARGET_HIT_LOW and avg_pnl < 0:
                 dna.delta_fast[model] = min(dna.delta_fast[model] + 0.01, 0.05)
-                print(f"   📉 {model} performing poorly (WR {win_rate:.2%}). Tightening +1%")
             elif win_rate > TARGET_HIT_HIGH and avg_pnl > 0.5:
                 dna.delta_fast[model] = max(dna.delta_fast[model] - 0.01, -0.05)
-                print(f"   📈 {model} performing great (WR {win_rate:.2%}). Loosening -1%")
 
     # ============================================================
     # 🗓️ PERIODIC UPDATES (Weekly/Monthly)
@@ -235,9 +256,7 @@ class AdaptiveHub:
         target_dict = dna.delta_weekly if update_type == 'weekly' else dna.delta_monthly
         limit = 0.03 if update_type == 'weekly' else 0.05
         
-        # Handles both Filters and Guards based on key names
         for k, v in new_deltas.items():
-            # If key exists in filters or guards, update it
             if k in dna.base_filters or k in dna.base_guards:
                 target_dict[k] = max(-limit, min(limit, v))
                 
@@ -257,6 +276,7 @@ class AdaptiveHub:
         
         mw = dna.model_weights
         total_w = sum(mw.values()) or 1.0
+        
         SystemLimits.L2_WEIGHT_TITAN = mw.get("titan", 0.4) / total_w
         SystemLimits.L2_WEIGHT_PATTERNS = mw.get("structure", 0.3) / total_w
         
@@ -268,6 +288,7 @@ class AdaptiveHub:
         SystemLimits.L4_OB_WALL_RATIO = dna.ob_settings.get("wall_ratio_limit", 0.4)
 
         SystemLimits.HYDRA_CRASH_THRESH = final_guards.get('hydra_crash', 0.85)
+        SystemLimits.HYDRA_GIVEBACK_THRESH = final_guards.get('hydra_giveback', 0.70)
         SystemLimits.LEGACY_V2_PANIC_THRESH = final_guards.get('legacy_v2', 0.95)
         
         print(f"   💉 [System Updated] {self.current_market_regime} | Oracle: {SystemLimits.L3_CONFIDENCE_THRESHOLD:.3f} | Sniper: {SystemLimits.L4_ENTRY_THRESHOLD:.3f}")