Update backtest_engine.py

backtest_engine.py

@@ -399,7 +399,9 @@ class HeavyDutyBacktester:
             for sym in self.TARGET_COINS:
                 c = await self._fetch_all_data_fast(sym, ms_s, ms_e)
                 if c: await self._process_data_in_memory(sym, c, ms_s, ms_e)
-
+# ============================================================
+    # 🔧 FIX: Updated Worker with Consensus Metrics
+    # ============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
         print(f"     ⏳ [System] Loading {len(scores_files)} datasets...", flush=True)
@@ -410,7 +412,7 @@ class HeavyDutyBacktester:
         if not data: return []
         df = pd.concat(data).sort_values('timestamp')
         
-        # Arrays
+        # Arrays extraction
         ts = df['timestamp'].values; close = df['close'].values.astype(float)
         sym = df['symbol'].values; sym_map = {s:i for i,s in enumerate(np.unique(sym))}
         sym_id = np.array([sym_map[s] for s in sym])
@@ -424,65 +426,113 @@ class HeavyDutyBacktester:
         
         res = []
         for cfg in combinations_batch:
-            pos = {}; log = []
+            pos = {}; log = [] # log stores: (pnl, was_consensus)
             bal = initial_capital; alloc = 0.0
             
+            # Entry Logic Mask
             mask = (l1 >= cfg['l1_thresh']) & (oracle >= cfg['oracle_thresh']) & (sniper >= cfg['sniper_thresh'])
             
             for i in range(N):
                 s = sym_id[i]; p = close[i]
                 
-                # Exit
+                # --- EXIT LOGIC ---
                 if s in pos:
-                    entry = pos[s][0]; h_r = pos[s][1]
+                    entry_price = pos[s][0]
+                    h_r = pos[s][1]
+                    entry_titan_score = pos[s][3] # Stored Titan Score
+                    
                     crash = (h_r > cfg['hydra_thresh']) 
-                    pnl = (p - entry)/entry
+                    pnl = (p - entry_price) / entry_price
                     
+                    # Simple SL/TP or Hydra Exit
                     if crash or pnl > 0.04 or pnl < -0.02:
-                        bal += pos[s][2] * (1 + pnl - fees_pct*2)
+                        # Fee impact (entry + exit)
+                        realized_pnl = pnl - (fees_pct * 2)
+                        
+                        bal += pos[s][2] * (1 + realized_pnl)
                         alloc -= pos[s][2]
-                        log.append(pnl)
+                        
+                        # Check consensus for this trade (Did Titan agree?)
+                        is_consensus = (entry_titan_score > 0.55) # Threshold for agreement
+                        log.append({'pnl': realized_pnl, 'consensus': is_consensus})
+                        
                         del pos[s]
                 
-                # Entry
+                # --- ENTRY LOGIC ---
                 if len(pos) < max_slots and mask[i]:
                     if s not in pos and bal >= 5.0:
-                        size = min(10.0, bal * 0.98)
-                        pos[s] = (p, hydra[i], size)
+                        size = min(10.0, bal * 0.98) # Fixed size per slot mostly
+                        # Store: (Price, HydraRisk, Size, TitanScore)
+                        pos[s] = (p, hydra[i], size, titan[i])
                         bal -= size; alloc += size
             
-            # Metrics
-            profit = (bal + alloc) - initial_capital
-            wins = sum(1 for x in log if x > 0)
-            tot = len(log)
+            # --- METRICS CALCULATION ---
+            final_bal = bal + alloc
+            net_profit = final_bal - initial_capital
+            total_trades = len(log)
+            wins = sum(1 for x in log if x['pnl'] > 0)
+            win_rate = (wins / total_trades * 100) if total_trades > 0 else 0.0
+            
+            # Consensus Metrics Calculation
+            consensus_trades = [x for x in log if x['consensus']]
+            num_con = len(consensus_trades)
+            
+            agreement_rate = (num_con / total_trades * 100) if total_trades > 0 else 0.0
+            con_wins = sum(1 for x in consensus_trades if x['pnl'] > 0)
+            con_win_rate = (con_wins / num_con * 100) if num_con > 0 else 0.0
+            con_avg_pnl = (sum(x['pnl'] for x in consensus_trades) / num_con * 100) if num_con > 0 else 0.0
+            
             res.append({
-                'config': cfg, 'net_profit': profit, 'total_trades': tot,
-                'win_rate': (wins/tot*100) if tot else 0, 'max_drawdown': 0
+                'config': cfg,
+                'final_balance': final_bal,   # ✅ Added
+                'net_profit': net_profit,
+                'total_trades': total_trades,
+                'win_rate': win_rate,
+                'max_drawdown': 0.0, # Simplified for speed
+                'consensus_agreement_rate': agreement_rate, # ✅ Added
+                'high_consensus_win_rate': con_win_rate,    # ✅ Added
+                'high_consensus_avg_pnl': con_avg_pnl       # ✅ Added
             })
+            
         return res
 
+    # ============================================================
+    # 🔧 FIX: Run Optimization with Safe Sorting
+    # ============================================================
     async def run_optimization(self, target_regime="RANGE"):
         await self.generate_truth_data()
         
-        # Grid
-        oracle_r = np.linspace(0.3, 0.7, 3); sniper_r = np.linspace(0.2, 0.6, 3)
-        hydra_r = [0.8, 0.9]; l1_r = [5.0, 10.0]
+        # Grid Setup
+        oracle_r = np.linspace(0.5, 0.8, 3) 
+        sniper_r = np.linspace(0.3, 0.6, 3)
+        hydra_r = [0.85, 0.95]
+        l1_r = [5.0]
         
         combos = []
         for o, s, h, l1 in itertools.product(oracle_r, sniper_r, hydra_r, l1_r):
             combos.append({
                 'w_titan': 0.4, 'w_struct': 0.3,
-                'l1_thresh': l1, 'oracle_thresh': o, 'sniper_thresh': s, 'hydra_thresh': h, 'legacy_thresh': 0.95
+                'l1_thresh': l1, 'oracle_thresh': o, 'sniper_thresh': s, 
+                'hydra_thresh': h, 'legacy_thresh': 0.95
             })
             
         files = glob.glob(os.path.join(CACHE_DIR, "*.pkl"))
-        best_res = self._worker_optimize(combos, files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
+        if not files:
+            print("⚠️ [Warning] No data files found for backtest.")
+            return None, {'net_profit': 0.0}
+
+        # Run Worker
+        results_list = self._worker_optimize(combos, files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
         
-        # ✅ FIX: Handle empty result
-        if not best_res:
+        if not results_list:
             print("⚠️ [Warning] No trades generated in any config.")
             return None, {'net_profit': 0.0, 'win_rate': 0.0}
 
+        # ✅ FIX: Sort and select 'best'
+        # Sort by Net Profit descending
+        results_list.sort(key=lambda x: x['net_profit'], reverse=True)
+        best = results_list[0] # The Champion
+
         print("\n" + "="*60)
         print(f"🏆 CHAMPION REPORT [{target_regime}]:")
         print(f"   💰 Final Balance:   ${best['final_balance']:,.2f}")
@@ -490,17 +540,18 @@ class HeavyDutyBacktester:
         print("-" * 60)
         print(f"   📊 Total Trades:    {best['total_trades']}")
         print(f"   📈 Win Rate:        {best['win_rate']:.1f}%")
-        print(f"   📉 Max Drawdown:    {best['max_drawdown']:.1f}%")
+        print(f"   📉 Max Drawdown:    {best['max_drawdown']:.1f}% (Approx)")
         print("-" * 60)
         print(f"   🧠 CONSENSUS ANALYTICS:")
-        print(f"   🤝 Model Agreement Rate:     {best['consensus_agreement_rate']:.1f}%")
+        print(f"   🤝 Model Agreement Rate:     {best['consensus_agreement_rate']:.1f}% (Titan Agreed)")
         print(f"   🌟 High-Consensus Win Rate:  {best['high_consensus_win_rate']:.1f}%")
         print(f"   💎 High-Consensus Avg PnL:   {best['high_consensus_avg_pnl']:.2f}%")
         print("-" * 60)
         print(f"   ⚙️ Oracle={best['config']['oracle_thresh']:.2f} | Sniper={best['config']['sniper_thresh']:.2f} | Hydra={best['config']['hydra_thresh']:.2f}")
-        print(f"   ⚖️ Weights: Titan={best['config']['w_titan']:.2f} | Patterns={best['config']['w_struct']:.2f} | L1={best['config']['l1_thresh']}")
         print("="*60)
+        
         return best['config'], best
+        
 async def run_strategic_optimization_task():
     print("\n🧪 [STRATEGIC BACKTEST] Full Spectrum Mode...")
     r2 = R2Service(); dm = DataManager(None, None, r2); proc = MLProcessor(dm)