Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V117.1 - GEM-Architect: Speed Demon)
+# 🧪 backtest_engine.py (V117.2 - GEM-Architect: Speed + Accuracy)
 # ============================================================
 
 import asyncio
@@ -60,7 +60,7 @@ class HeavyDutyBacktester:
         else:
             os.makedirs(CACHE_DIR)
             
-        print(f"🧪 [Backtest V117.1] Speed Demon Loaded. Cache Flushed. Targets: {len(self.TARGET_COINS)}")
+        print(f"🧪 [Backtest V117.2] High-Fidelity Speed Mode. Targets: {len(self.TARGET_COINS)}")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -197,7 +197,7 @@ class HeavyDutyBacktester:
         return df
 
     # ==============================================================
-    # 🧠 CPU PROCESSING (OPTIMIZED BATCH INFERENCE)
+    # 🧠 CPU PROCESSING (OPTIMIZED BATCH INFERENCE V2)
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
@@ -248,8 +248,12 @@ class HeavyDutyBacktester:
         # 3. Load Models
         hydra_models = getattr(self.proc.guardian_hydra, 'models', {}) if self.proc.guardian_hydra else {}
         legacy_v2 = getattr(self.proc.guardian_legacy, 'model_v2', None)
+        
         oracle_dir_model = getattr(self.proc.oracle, 'model_direction', None)
+        oracle_cols = getattr(self.proc.oracle, 'feature_cols', [])
+        
         sniper_models = getattr(self.proc.sniper, 'models', [])
+        sniper_cols = getattr(self.proc.sniper, 'feature_names', [])
 
         # 4. 🔥 PRE-CALC LEGACY V2 🔥
         global_v2_probs = np.zeros(len(fast_1m['close']))
@@ -313,42 +317,62 @@ class HeavyDutyBacktester:
         ai_results = []
         time_vec = np.arange(1, 241)
 
-        # 🔥 BATCH BUFFERS FOR HYDRA 🔥
+        # 🔥 BATCH BUFFERS 🔥
         hydra_batch_X = []
         hydra_batch_indices = []
-        BATCH_SIZE = 2000 
         
-        # Temp results to be filled by batch processing
-        temp_hydra_results = {} # {idx: (risk, time)}
+        oracle_batch_X = []
+        sniper_batch_X = []
+        
+        BATCH_SIZE = 5000 # Increased batch size for efficiency
+        
+        # Temp results stores
+        temp_hydra_results = {} 
+        temp_oracle_results = {}
+        temp_sniper_results = {}
 
-        # Main Loop: Collect Data & Run Simple Models
+        # Main Loop: Collect Data
         for i, current_time in enumerate(final_valid_indices):
             ts_val = int(current_time.timestamp() * 1000)
             idx_1m = np.searchsorted(fast_1m['timestamp'], ts_val)
             
             if idx_1m < 500 or idx_1m >= len(fast_1m['close']) - 245: continue
             
-            # --- Oracle & Sniper (Keep Per-Instance or could be batched, but they are fast enough usually) ---
-            # To speed up, we just use defaults if models are missing
-            oracle_conf = 0.5
-            sniper_score = 0.5
-            
-            # (Simplification: If models exist, run inference. If bottleneck, move to Batch like Hydra)
-            # For now, leaving Oracle/Sniper as is (they are lighter than Hydra loops)
-            # ... [Oracle/Sniper code omitted for brevity, assuming minimal impact or similar batching can be applied]
-            # Re-inserting simple placeholders for speed in this demo if needed, 
-            # BUT let's keep the logic:
-            
             idx_1h = map_1m_to_1h[idx_1m]
             idx_15m = map_1m_to_15m[idx_1m]
             idx_4h = np.searchsorted(numpy_htf['4h']['timestamp'], ts_val)
             if idx_4h >= len(numpy_htf['4h']['close']): idx_4h = len(numpy_htf['4h']['close']) - 1
 
-            if oracle_dir_model:
-                # Construct vector... (Fast enough for single row usually)
-                pass # (Assume code from previous block executes here)
+            current_res_idx = len(ai_results) # Index in result list
 
-            # --- HYDRA PREP (THE BOTTLENECK FIX) ---
+            # --- 🔮 BATCH ORACLE ---
+            if oracle_dir_model:
+                o_vec = []
+                for col in oracle_cols:
+                    val = 0.0
+                    if col.startswith('1h_'): val = numpy_htf['1h'].get(col[3:], [0])[idx_1h]
+                    elif col.startswith('15m_'): val = numpy_htf['15m'].get(col[4:], [0])[idx_15m]
+                    elif col.startswith('4h_'): val = numpy_htf['4h'].get(col[3:], [0])[idx_4h]
+                    elif col == 'sim_titan_score': val = 0.6
+                    elif col == 'sim_mc_score': val = 0.5
+                    elif col == 'sim_pattern_score': val = 0.5
+                    o_vec.append(val)
+                oracle_batch_X.append(o_vec)
+            else:
+                temp_oracle_results[current_res_idx] = 0.5
+
+            # --- 🔫 BATCH SNIPER ---
+            if sniper_models:
+                s_vec = []
+                for col in sniper_cols:
+                    if col in fast_1m: s_vec.append(fast_1m[col][idx_1m])
+                    elif col == 'L_score': s_vec.append(fast_1m.get('vol_zscore_50', [0])[idx_1m])
+                    else: s_vec.append(0.0)
+                sniper_batch_X.append(s_vec)
+            else:
+                temp_sniper_results[current_res_idx] = 0.5
+
+            # --- 🐲 BATCH HYDRA ---
             if hydra_models and global_hydra_static is not None:
                 start_idx = idx_1m + 1
                 end_idx = start_idx + 240
@@ -356,7 +380,6 @@ class HeavyDutyBacktester:
                 sl_static = global_hydra_static[start_idx:end_idx]
                 entry_price = fast_1m['close'][idx_1m]
                 
-                # Vectorized Matrix Construction for the 240 window
                 sl_close = sl_static[:, 6]
                 sl_atr = sl_static[:, 5]
                 sl_dist = np.maximum(1.5 * sl_atr, entry_price * 0.015)
@@ -368,11 +391,12 @@ class HeavyDutyBacktester:
                 sl_atr_pct = sl_atr / sl_close
                 
                 zeros = np.zeros(240)
-                ones_oracle = np.full(240, oracle_conf)
+                # Note: We use 0.5 as placeholder for Oracle in Hydra until we run Oracle, 
+                # but for speed we assume average conf for risk check
+                ones_oracle = np.full(240, 0.6) 
                 ones_l2 = np.full(240, 0.7)
                 ones_target = np.full(240, 3.0)
                 
-                # Construct the matrix for this candidate
                 X_cand = np.column_stack([
                     sl_static[:, 0], sl_static[:, 1], sl_static[:, 2],
                     sl_static[:, 3], sl_static[:, 4],
@@ -384,44 +408,84 @@ class HeavyDutyBacktester:
                 ])
                 
                 hydra_batch_X.append(X_cand)
-                hydra_batch_indices.append(len(ai_results)) # Track which result this belongs to
-                
-                # Trigger Batch Prediction if full
-                if len(hydra_batch_X) >= BATCH_SIZE:
+                hydra_batch_indices.append(current_res_idx)
+
+            # Placeholder Result
+            ai_results.append({
+                'timestamp': ts_val, 'symbol': sym, 'close': fast_1m['close'][idx_1m],
+                'real_titan': 0.6, 'oracle_conf': 0.5, 'sniper_score': 0.5,
+                'risk_hydra_crash': 0.0, 'time_hydra_crash': 0,
+                'risk_legacy_v2': 0.0, 'time_legacy_panic': 0,
+                'signal_type': 'BREAKOUT', 'l1_score': 50.0
+            })
+
+            # --- EXECUTE BATCHES IF FULL ---
+            if len(hydra_batch_X) >= BATCH_SIZE:
+                # 1. Oracle
+                if oracle_batch_X:
+                    try:
+                        o_preds = oracle_dir_model.predict(np.array(oracle_batch_X))
+                        start_i = current_res_idx - len(oracle_batch_X) + 1
+                        for i, p in enumerate(o_preds):
+                            val = float(p[0]) if isinstance(p, (list, np.ndarray)) else float(p)
+                            if val < 0.5: val = 1 - val
+                            temp_oracle_results[start_i + i] = val
+                    except: pass
+                    oracle_batch_X = []
+
+                # 2. Sniper
+                if sniper_batch_X:
+                    try:
+                        s_X = np.array(sniper_batch_X)
+                        # Average of models
+                        avg_preds = np.zeros(len(s_X))
+                        for m in sniper_models:
+                            avg_preds += m.predict(s_X)
+                        avg_preds /= len(sniper_models)
+                        
+                        start_i = current_res_idx - len(sniper_batch_X) + 1
+                        for i, p in enumerate(avg_preds):
+                            temp_sniper_results[start_i + i] = float(p)
+                    except: pass
+                    sniper_batch_X = []
+
+                # 3. Hydra
+                if hydra_batch_X:
                     big_X = np.vstack(hydra_batch_X)
                     try:
-                        # 🔥 SINGLE CALL FOR 2000 CANDIDATES 🔥
                         preds = hydra_models['crash'].predict_proba(big_X)[:, 1]
-                        # Split results back
                         for b_i, res_idx in enumerate(hydra_batch_indices):
                             p_slice = preds[b_i*240 : (b_i+1)*240]
                             max_p = np.max(p_slice)
                             c_idx = np.where(p_slice > 0.6)[0]
-                            c_time = int(fast_1m['timestamp'][fast_1m['timestamp'].searchsorted(ts_val) + 1 + c_idx[0]]) if len(c_idx) > 0 else 0
+                            c_time = int(fast_1m['timestamp'][fast_1m['timestamp'].searchsorted(ai_results[res_idx]['timestamp']) + 1 + c_idx[0]]) if len(c_idx) > 0 else 0
                             temp_hydra_results[res_idx] = (max_p, c_time)
                     except: pass
                     hydra_batch_X = []
                     hydra_batch_indices = []
 
-            # Legacy V2 (Fast Lookup)
-            max_legacy_v2 = 0.0; legacy_panic_time = 0
-            if legacy_v2:
-                start_idx = idx_1m + 1
-                probs_slice = global_v2_probs[start_idx:start_idx+240]
-                max_legacy_v2 = np.max(probs_slice)
-                panic_indices = np.where(probs_slice > 0.8)[0]
-                if len(panic_indices) > 0:
-                    legacy_panic_time = int(fast_1m['timestamp'][start_idx + panic_indices[0]])
+        # --- PROCESS LEFTOVERS ---
+        if oracle_batch_X:
+            try:
+                o_preds = oracle_dir_model.predict(np.array(oracle_batch_X))
+                start_i = len(ai_results) - len(oracle_batch_X)
+                for i, p in enumerate(o_preds):
+                    val = float(p[0]) if isinstance(p, (list, np.ndarray)) else float(p)
+                    if val < 0.5: val = 1 - val
+                    temp_oracle_results[start_i + i] = val
+            except: pass
 
-            ai_results.append({
-                'timestamp': ts_val, 'symbol': sym, 'close': entry_price,
-                'real_titan': 0.6, 'oracle_conf': oracle_conf, 'sniper_score': sniper_score,
-                'risk_hydra_crash': 0.0, 'time_hydra_crash': 0, # To be filled
-                'risk_legacy_v2': max_legacy_v2, 'time_legacy_panic': legacy_panic_time,
-                'signal_type': 'BREAKOUT', 'l1_score': 50.0
-            })
+        if sniper_batch_X:
+            try:
+                s_X = np.array(sniper_batch_X)
+                avg_preds = np.zeros(len(s_X))
+                for m in sniper_models: avg_preds += m.predict(s_X)
+                avg_preds /= len(sniper_models)
+                start_i = len(ai_results) - len(sniper_batch_X)
+                for i, p in enumerate(avg_preds):
+                    temp_sniper_results[start_i + i] = float(p)
+            except: pass
 
-        # Process remaining Hydra batch
         if hydra_batch_X:
             big_X = np.vstack(hydra_batch_X)
             try:
@@ -434,10 +498,29 @@ class HeavyDutyBacktester:
                     temp_hydra_results[res_idx] = (max_p, c_time)
             except: pass
 
-        # Fill Hydra Results
-        for idx, (risk, t_crash) in temp_hydra_results.items():
-            ai_results[idx]['risk_hydra_crash'] = risk
-            ai_results[idx]['time_hydra_crash'] = t_crash
+        # --- Legacy V2 Vectorized Fill ---
+        if legacy_v2:
+             # Just map pre-calculated global values
+             for idx, res in enumerate(ai_results):
+                 ts = res['timestamp']
+                 idx_1m = np.searchsorted(fast_1m['timestamp'], ts)
+                 start = idx_1m + 1
+                 # Safety check
+                 if start < len(global_v2_probs) - 240:
+                     probs_slice = global_v2_probs[start:start+240]
+                     max_p = np.max(probs_slice)
+                     p_idx = np.where(probs_slice > 0.8)[0]
+                     p_time = int(fast_1m['timestamp'][start + p_idx[0]]) if len(p_idx) > 0 else 0
+                     ai_results[idx]['risk_legacy_v2'] = max_p
+                     ai_results[idx]['time_legacy_panic'] = p_time
+
+        # --- FILL ALL RESULTS ---
+        for i in range(len(ai_results)):
+            if i in temp_oracle_results: ai_results[i]['oracle_conf'] = temp_oracle_results[i]
+            if i in temp_sniper_results: ai_results[i]['sniper_score'] = temp_sniper_results[i]
+            if i in temp_hydra_results:
+                ai_results[i]['risk_hydra_crash'] = temp_hydra_results[i][0]
+                ai_results[i]['time_hydra_crash'] = temp_hydra_results[i][1]
 
         dt = time.time() - t0
         if ai_results:
@@ -483,7 +566,6 @@ class HeavyDutyBacktester:
         global_df.sort_values('timestamp', inplace=True)
         
         # 🚀 CONVERT TO NUMPY ARRAYS FOR BLAZING SPEED 🚀
-        # This removes pandas overhead from the inner loop
         arr_ts = global_df['timestamp'].values
         arr_close = global_df['close'].values.astype(np.float64)
         arr_symbol = global_df['symbol'].values
@@ -493,7 +575,6 @@ class HeavyDutyBacktester:
         arr_hydra_time = global_df['time_hydra_crash'].values.astype(np.int64)
         arr_titan = global_df['real_titan'].values.astype(np.float64)
         
-        # Pre-map symbols to integers for faster dictionary lookups
         unique_syms = np.unique(arr_symbol)
         sym_map = {s: i for i, s in enumerate(unique_syms)}
         arr_sym_int = np.array([sym_map[s] for s in arr_symbol], dtype=np.int32)
@@ -506,7 +587,6 @@ class HeavyDutyBacktester:
         start_time = time.time()
         
         for idx, config in enumerate(combinations_batch):
-            # Progress Logging (Every 10 combos)
             if idx > 0 and idx % 10 == 0:
                 elapsed = time.time() - start_time
                 avg_time = elapsed / idx
@@ -514,45 +594,32 @@ class HeavyDutyBacktester:
                 sys.stdout.write(f"\r        ⚙️ Progress: {idx}/{total_combos} ({idx/total_combos:.1%}) | ETA: {rem_time:.0f}s")
                 sys.stdout.flush()
 
-            # --- Logic Core ---
             wallet_bal = initial_capital
             wallet_alloc = 0.0
-            # positions: key=sym_int, val=[entry, size, risk_h, time_h, score]
             positions = {} 
-            trades_log = [] # [pnl, score]
+            trades_log = [] 
             
             oracle_thresh = config.get('oracle_thresh', 0.6)
             sniper_thresh = config.get('sniper_thresh', 0.4)
             hydra_thresh = config['hydra_thresh']
 
-            # Pre-calculate entry candidates mask for this config
-            # (Vectorized check is 100x faster than checking inside loop)
+            # Vectorized Mask
             mask_buy = (arr_oracle >= oracle_thresh) & (arr_sniper >= sniper_thresh)
             
             peak_bal = initial_capital
             max_dd = 0.0
-
-            # 🚀 OPTIMIZED TIME LOOP 🚀
-            # We iterate through indices. Since data is sorted by time, 
-            # we can process linearly.
-            # Warning: Multiple symbols share same timestamp.
-            # Group logic simulated by linear scan.
-            
-            current_ts = arr_ts[0]
             
-            # Simple linear iteration is safest to preserve logic without complex groupby
-            # Speedup comes from numpy access vs dataframe access
+            # Optimized Loop
             for i in range(total_len):
                 ts = arr_ts[i]
                 sym_id = arr_sym_int[i]
                 price = arr_close[i]
                 
-                # Check Exits first (for open positions)
+                # Check Exits
                 if sym_id in positions:
-                    pos = positions[sym_id] # [entry, size, risk, time, score]
+                    pos = positions[sym_id] 
                     entry = pos[0]
                     
-                    # Hydra Check
                     h_risk = pos[2]
                     h_time = pos[3]
                     is_crash = (h_risk > hydra_thresh) and (h_time > 0) and (ts >= h_time)
@@ -565,7 +632,6 @@ class HeavyDutyBacktester:
                         trades_log.append((pnl, pos[4]))
                         del positions[sym_id]
                         
-                        # Update DD
                         tot = wallet_bal + wallet_alloc
                         if tot > peak_bal: peak_bal = tot
                         else:
@@ -573,19 +639,17 @@ class HeavyDutyBacktester:
                             if dd > max_dd: max_dd = dd
 
                 # Check Entries
-                # Only if we have space AND signal matches
                 if len(positions) < max_slots:
                     if mask_buy[i]:
                          if sym_id not in positions:
                              if wallet_bal >= 10.0:
                                  cons_score = (arr_titan[i] + arr_oracle[i] + arr_sniper[i]) / 3.0
-                                 # Enter
                                  size = 10.0
                                  positions[sym_id] = [price, size, arr_hydra_risk[i], arr_hydra_time[i], cons_score]
                                  wallet_bal -= size
                                  wallet_alloc += size
 
-            # Final Stats Calc
+            # Stats
             final_bal = wallet_bal + wallet_alloc
             net_profit = final_bal - initial_capital
             total_t = len(trades_log)
@@ -638,7 +702,7 @@ class HeavyDutyBacktester:
                 'high_consensus_avg_pnl': hc_avg_pnl
             })
             
-        print("") # New line after progress bar
+        print("") 
         return results
 
     async def run_optimization(self, target_regime="RANGE"):
@@ -701,8 +765,12 @@ async def run_strategic_optimization_task():
         hub = AdaptiveHub(r2); await hub.initialize()
         optimizer = HeavyDutyBacktester(dm, proc)
         
+        # ✅ Updated Scenarios List
         scenarios = [
             {"regime": "BULL", "start": "2024-01-01", "end": "2024-03-30"},
+            {"regime": "BEAR", "start": "2023-08-01", "end": "2023-09-15"},
+            {"regime": "DEAD", "start": "2023-06-01", "end": "2023-08-01"},
+            {"regime": "RANGE", "start": "2024-07-01", "end": "2024-09-30"}
         ]
         
         for scen in scenarios: