Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V118.9 - GEM-Architect: Dimension Safe)
+# 🧪 backtest_engine.py (V118.10 - GEM-Architect: Multi-Class Fix)
 # ============================================================
 
 import asyncio
@@ -54,7 +54,7 @@ class HeavyDutyBacktester:
         else:
             os.makedirs(CACHE_DIR)
             
-        print(f"🧪 [Backtest V118.9] Dimension Safe Mode. Models: {self._check_models_status()}")
+        print(f"🧪 [Backtest V118.10] Multi-Class Fix Mode. Models: {self._check_models_status()}")
 
     def _check_models_status(self):
         status = []
@@ -188,13 +188,15 @@ class HeavyDutyBacktester:
         df_1m = df_1m.sort_index()
 
         frames = {}
+        agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
+        
         frames['1m'] = self._calculate_indicators_vectorized(df_1m.copy(), timeframe='1m')
         frames['1m']['timestamp'] = frames['1m'].index.floor('1min').astype(np.int64) // 10**6
         fast_1m = {col: frames['1m'][col].values for col in frames['1m'].columns}
         
         numpy_htf = {} 
         for tf_str, tf_code in [('5m', '5T'), ('15m', '15T'), ('1h', '1h'), ('4h', '4h'), ('1d', '1D')]:
-            resampled = df_1m.resample(tf_code).agg({'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}).dropna()
+            resampled = df_1m.resample(tf_code).agg(agg_dict).dropna()
             resampled = self._calculate_indicators_vectorized(resampled, timeframe=tf_str)
             resampled['timestamp'] = resampled.index.astype(np.int64) // 10**6
             frames[tf_str] = resampled
@@ -233,7 +235,11 @@ class HeavyDutyBacktester:
                 
                 X_GLOBAL_V2 = np.column_stack([l_log, l_rsi, l_fib, l_vol, l5_log, l5_rsi, l5_fib, l5_trd, l15_log, l15_rsi, l15_fib618, l15_trd, *lag_cols])
                 global_v2_probs = legacy_v2.predict(xgb.DMatrix(X_GLOBAL_V2))
-                if len(global_v2_probs.shape) > 1: global_v2_probs = global_v2_probs[:, 2] 
+                
+                # ✅ FIX: Handle Multi-Class output if exists
+                if len(global_v2_probs.shape) > 1: 
+                    # Assuming last column is Panic/Crash prob (or index 2)
+                    global_v2_probs = global_v2_probs[:, -1] 
             except: pass
 
         # 5. 🔥 Pre-Assemble Hydra Static 🔥
@@ -267,6 +273,7 @@ class HeavyDutyBacktester:
                 idx_1h = map_1m_to_1h[final_valid_indices]
                 idx_15m = map_1m_to_15m[final_valid_indices]
                 idx_4h = map_1m_to_4h[final_valid_indices]
+                
                 titan_scores = np.clip(fast_1m['l1_score'][final_valid_indices] / 40.0, 0.1, 0.95)
                 
                 oracle_features = []
@@ -284,11 +291,13 @@ class HeavyDutyBacktester:
                 
                 X_oracle_big = np.column_stack(oracle_features)
                 preds = oracle_dir_model.predict(X_oracle_big)
-                if len(preds.shape) > 1 and preds.shape[1] > 1: oracle_preds = preds[:, 1]
+                
+                # ✅ FIX: Handle Multi-Class (take last column usually)
+                if len(preds.shape) > 1 and preds.shape[1] > 1: oracle_preds = preds[:, -1]
                 else: oracle_preds = preds.flatten()
             except Exception as e: print(f"Oracle Error: {e}")
 
-        # --- B. SNIPER MATRIX CONSTRUCTION ---
+        # --- B. SNIPER MATRIX CONSTRUCTION (FIXED) ---
         sniper_preds = np.full(num_candidates, 0.5)
         if sniper_models:
             try:
@@ -299,9 +308,19 @@ class HeavyDutyBacktester:
                     else: sniper_features.append(np.zeros(num_candidates))
                 
                 X_sniper_big = np.column_stack(sniper_features)
-                # ✅ FIX: SQUEEZE PREDICTIONS
-                preds_list = [np.squeeze(m.predict(X_sniper_big)) for m in sniper_models]
-                sniper_preds = np.mean(preds_list, axis=0)
+                
+                # ✅ FIX: Extract Positive Class Prob if Multi-Class
+                batch_preds = []
+                for m in sniper_models:
+                    raw_p = m.predict(X_sniper_big)
+                    if len(raw_p.shape) > 1 and raw_p.shape[1] > 1:
+                        # Assuming index 2 is Buy (0=Sell, 1=Hold, 2=Buy) or index 1 if binary
+                        # Safest: Take last column
+                        batch_preds.append(raw_p[:, -1])
+                    else:
+                        batch_preds.append(raw_p)
+                
+                sniper_preds = np.mean(batch_preds, axis=0)
             except Exception as e: print(f"Sniper Error: {e}")
 
         # --- C. HYDRA MATRIX CONSTRUCTION ---
@@ -325,7 +344,6 @@ class HeavyDutyBacktester:
                     sl_max_pnl_r = (sl_cum_max - entry_p) / sl_dist
                     sl_atr_pct = sl_atr / sl_close
                     zeros = np.zeros(240); ones = np.ones(240)
-                    
                     row = np.column_stack([
                         sl_static[:, 0], sl_static[:, 1], sl_static[:, 2],
                         sl_static[:, 3], sl_static[:, 4],
@@ -372,7 +390,7 @@ class HeavyDutyBacktester:
             arr_l1 = fast_1m['l1_score'][final_valid_indices]
             arr_titan = np.clip(arr_l1 / 40.0, 0.1, 0.95)
             
-            # 2. Check Lengths
+            # 2. Check Lengths & Flatten
             arrays = {
                 'timestamp': arr_ts,
                 'close': arr_close,
@@ -386,18 +404,16 @@ class HeavyDutyBacktester:
                 'time_legacy_panic': legacy_time_preds
             }
             
-            # 3. Explicitly Flatten & Verify
             clean_arrays = {}
             for k, v in arrays.items():
                 flat_v = np.array(v).flatten()
-                if len(flat_v) != num_candidates:
-                    print(f"❌ SIZE MISMATCH in {k}: Expected {num_candidates}, got {len(flat_v)}")
-                    # Fix by truncating or padding (Emergency Fix)
-                    if len(flat_v) > num_candidates: flat_v = flat_v[:num_candidates]
-                    else: flat_v = np.pad(flat_v, (0, num_candidates - len(flat_v)))
+                # Safety Truncate
+                if len(flat_v) > num_candidates: flat_v = flat_v[:num_candidates]
+                elif len(flat_v) < num_candidates: 
+                    print(f"⚠️ PADDING {k}: {len(flat_v)} -> {num_candidates}")
+                    flat_v = np.pad(flat_v, (0, num_candidates - len(flat_v)))
                 clean_arrays[k] = flat_v
             
-            # 4. Create DF
             clean_arrays['symbol'] = sym 
             ai_df = pd.DataFrame(clean_arrays)
 
@@ -484,6 +500,7 @@ class HeavyDutyBacktester:
                 sym_id = arr_sym_int[i]
                 price = arr_close[i]
                 
+                # Exits
                 if sym_id in positions:
                     pos = positions[sym_id] 
                     entry = pos[0]; h_risk = pos[2]; h_time = pos[3]
@@ -501,6 +518,7 @@ class HeavyDutyBacktester:
                             dd = (peak_bal - tot) / peak_bal
                             if dd > max_dd: max_dd = dd
 
+                # Entries
                 if len(positions) < max_slots:
                     if mask_buy[i]:
                          if sym_id not in positions: