Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V118.4 - GEM-Architect: Bulletproof)
+# 🧪 backtest_engine.py (V118.5 - GEM-Architect: Hyper-Vectorized)
 # ============================================================
 
 import asyncio
@@ -17,7 +17,7 @@ import traceback
 from datetime import datetime, timezone
 from typing import Dict, Any, List
 
-# ✅ استيراد المحركات
+# ✅ استيراد المحركات الأساسية
 try:
     from ml_engine.processor import MLProcessor, SystemLimits 
     from ml_engine.data_manager import DataManager
@@ -36,11 +36,19 @@ class HeavyDutyBacktester:
     def __init__(self, data_manager, processor):
         self.dm = data_manager
         self.proc = processor
+        
+        # 🎛️ كثافة شبكة البحث
         self.GRID_DENSITY = 3  
+        
+        # إعدادات المحفظة
         self.INITIAL_CAPITAL = 10.0
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
-        self.TARGET_COINS = ['SOL/USDT', 'XRP/USDT', 'DOGE/USDT']
+        
+        self.TARGET_COINS = [
+            'SOL/USDT', 'XRP/USDT', 'DOGE/USDT'
+        ]
+        
         self.force_start_date = None 
         self.force_end_date = None   
         
@@ -54,7 +62,7 @@ class HeavyDutyBacktester:
         else:
             os.makedirs(CACHE_DIR)
             
-        print(f"🧪 [Backtest V118.4] Bulletproof Mode. Models: {self._check_models_status()}")
+        print(f"🧪 [Backtest V118.5] Hyper-Vectorized Mode. Models: {self._check_models_status()}")
 
     def _check_models_status(self):
         status = []
@@ -124,7 +132,7 @@ class HeavyDutyBacktester:
         df['ema50'] = ta.ema(df['close'], length=50)
         df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
         
-        # ✅ FIX: rel_vol calculated globally to avoid KeyError
+        # Global calc
         df['vol_ma50'] = df['volume'].rolling(50).mean()
         df['rel_vol'] = df['volume'] / (df['vol_ma50'] + 1e-9)
 
@@ -138,7 +146,7 @@ class HeavyDutyBacktester:
         df['vol_z'] = (df['volume'] - vol_mean) / (vol_std + 1e-9)
         df['atr_pct'] = df['atr'] / df['close']
 
-        # 🔥 L1 Score 🔥
+        # L1 Score
         rsi_penalty = np.where(df['rsi'] > 70, (df['rsi'] - 70) * 2, 0)
         l1_score_raw = (df['rel_vol'] * 10) + (df['atr_pct'] * 1000) - rsi_penalty
         df['l1_score'] = l1_score_raw.fillna(0)
@@ -168,7 +176,7 @@ class HeavyDutyBacktester:
         return df
 
     # ==============================================================
-    # 🧠 CPU PROCESSING (FIXED SAFE LOOKUP)
+    # 🧠 CPU PROCESSING (HYPER-VECTORIZED)
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
@@ -179,9 +187,10 @@ class HeavyDutyBacktester:
              print(f"   📂 [{sym}] Data Exists -> Skipping.")
              return
 
-        print(f"   ⚙️ [CPU] Analyzing {sym} (Real Models Active)...", flush=True)
+        print(f"   ⚙️ [CPU] Analyzing {sym} (Hyper-Vectorized Mode)...", flush=True)
         t0 = time.time()
 
+        # 1. Data Prep
         df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
         df_1m['datetime'] = pd.to_datetime(df_1m['timestamp'], unit='ms')
         df_1m.set_index('datetime', inplace=True)
@@ -202,40 +211,51 @@ class HeavyDutyBacktester:
             frames[tf_str] = resampled
             numpy_htf[tf_str] = {col: resampled[col].values for col in resampled.columns}
 
+        # 2. Time Alignment (Vectorized)
         map_1m_to_1h = np.clip(np.searchsorted(numpy_htf['1h']['timestamp'], fast_1m['timestamp']), 0, len(numpy_htf['1h']['timestamp'])-1)
         map_1m_to_5m = np.clip(np.searchsorted(numpy_htf['5m']['timestamp'], fast_1m['timestamp']), 0, len(numpy_htf['5m']['timestamp'])-1)
         map_1m_to_15m = np.clip(np.searchsorted(numpy_htf['15m']['timestamp'], fast_1m['timestamp']), 0, len(numpy_htf['15m']['timestamp'])-1)
+        map_1m_to_4h = np.clip(np.searchsorted(numpy_htf['4h']['timestamp'], fast_1m['timestamp']), 0, len(numpy_htf['4h']['timestamp'])-1)
 
-        # Load Models
-        titan_engine = self.proc.titan
+        # 3. Model Access
         oracle_dir_model = getattr(self.proc.oracle, 'model_direction', None)
         sniper_models = getattr(self.proc.sniper, '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)
 
-        # Pre-Calc Legacy V2
+        # 4. 🔥 Pre-Calc Legacy V2 (Vectorized) 🔥
         global_v2_probs = np.zeros(len(fast_1m['close']))
         if legacy_v2:
             try:
-                l_log = fast_1m['log_ret']; l_rsi = fast_1m['rsi'] / 100.0
-                l_fib = fast_1m['fib_pos']; l_vol = fast_1m['volatility']
+                # Direct array construction
+                l_log = fast_1m['log_ret']
+                l_rsi = fast_1m['rsi'] / 100.0
+                l_fib = fast_1m['fib_pos']
+                l_vol = fast_1m['volatility']
+                
                 l5_log = numpy_htf['5m']['log_ret'][map_1m_to_5m]
                 l5_rsi = numpy_htf['5m']['rsi'][map_1m_to_5m] / 100.0
                 l5_fib = numpy_htf['5m']['fib_pos'][map_1m_to_5m]
                 l5_trd = numpy_htf['5m']['trend_slope'][map_1m_to_5m]
+                
                 l15_log = numpy_htf['15m']['log_ret'][map_1m_to_15m]
                 l15_rsi = numpy_htf['15m']['rsi'][map_1m_to_15m] / 100.0
                 l15_fib618 = numpy_htf['15m']['dist_fib618'][map_1m_to_15m]
                 l15_trd = numpy_htf['15m']['trend_slope'][map_1m_to_15m]
+                
                 lag_cols = []
                 for lag in [1, 2, 3, 5, 10, 20]:
-                    lag_cols.extend([fast_1m[f'log_ret_lag_{lag}'], fast_1m[f'rsi_lag_{lag}'], fast_1m[f'fib_pos_lag_{lag}'], fast_1m[f'volatility_lag_{lag}']])
+                    lag_cols.extend([
+                        fast_1m[f'log_ret_lag_{lag}'], fast_1m[f'rsi_lag_{lag}'],
+                        fast_1m[f'fib_pos_lag_{lag}'], fast_1m[f'volatility_lag_{lag}']
+                    ])
+                
                 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])
-                gp = legacy_v2.predict(xgb.DMatrix(X_GLOBAL_V2))
-                if len(gp.shape) > 1: global_v2_probs = gp[:, 2] 
+                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] 
             except: pass
 
-        # Pre-Assemble Hydra Static
+        # 5. 🔥 Pre-Assemble Hydra Static 🔥
         global_hydra_static = None
         if hydra_models:
             try:
@@ -249,187 +269,203 @@ class HeavyDutyBacktester:
                 global_hydra_static = np.column_stack([h_rsi_1m, h_rsi_5m, h_rsi_15m, h_bb, h_vol, h_atr, h_close])
             except: pass
 
+        # 6. Candidate Filtering
         valid_indices_mask = fast_1m['l1_score'] >= 5.0 
         valid_indices = np.where(valid_indices_mask)[0]
-        final_valid_indices = [idx for idx in valid_indices if idx > 500 and idx < len(fast_1m['close']) - 245]
+        # Skip warmup and tail
+        mask_bounds = (valid_indices > 500) & (valid_indices < len(fast_1m['close']) - 245)
+        final_valid_indices = valid_indices[mask_bounds]
         
-        print(f"     🎯 Raw Candidates (Score > 5): {len(final_valid_indices)}. Calculating Model Scores...", flush=True)
+        print(f"     🎯 Raw Candidates (Score > 5): {len(final_valid_indices)}. Vectorized Scoring...", flush=True)
 
-        ai_results = []
-        time_vec = np.arange(1, 241)
+        # 🚀 HYPER-VECTORIZATION START 🚀
+        # Instead of looping, we construct the BIG matrices for all candidates at once.
+        # This brings speed back to ~60s
         
-        oracle_batch_X, sniper_batch_X, hydra_batch_X, hydra_batch_indices = [], [], [], []
-        temp_oracle_results, temp_sniper_results, temp_hydra_results, temp_titan_results = {}, {}, {}, {}
-        BATCH_SIZE = 5000
-        current_batch_count = 0 # ✅ Independent Batch Counter
-
-        for i_idx in final_valid_indices:
-            ts_val = fast_1m['timestamp'][i_idx]
-            current_res_idx = len(ai_results)
-            
-            idx_1h = map_1m_to_1h[i_idx]
-            idx_15m = map_1m_to_15m[i_idx]
-            idx_4h = np.clip(np.searchsorted(numpy_htf['4h']['timestamp'], ts_val), 0, len(numpy_htf['4h']['timestamp'])-1)
-
-            # 1. Titan
-            titan_score_est = min(0.95, max(0.1, fast_1m['l1_score'][i_idx] / 40.0))
-            temp_titan_results[current_res_idx] = titan_score_est
+        num_candidates = len(final_valid_indices)
+        if num_candidates == 0: return
 
-            # 2. Oracle (SAFE LOOKUP FIX)
-            if oracle_dir_model:
-                o_vec = []
+        # --- A. ORACLE MATRIX CONSTRUCTION ---
+        oracle_preds = np.full(num_candidates, 0.5)
+        if oracle_dir_model:
+            try:
+                # Mapped Indices for all candidates
+                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 = []
                 for col in getattr(self.proc.oracle, 'feature_cols', []):
-                    val = 0.0
-                    if col.startswith('1h_'): 
-                        c_name = col[3:]
-                        if c_name in numpy_htf['1h']: val = numpy_htf['1h'][c_name][idx_1h]
-                    elif col.startswith('15m_'): 
-                        c_name = col[4:]
-                        if c_name in numpy_htf['15m']: val = numpy_htf['15m'][c_name][idx_15m]
-                    elif col.startswith('4h_'): 
-                        c_name = col[3:]
-                        if c_name in numpy_htf['4h']: val = numpy_htf['4h'][c_name][idx_4h]
-                    elif col == 'sim_titan_score': val = titan_score_est
-                    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
-
-            # 3. Sniper
-            if sniper_models:
-                s_vec = []
+                    if col.startswith('1h_'):
+                        c = col[3:]
+                        oracle_features.append(numpy_htf['1h'][c][idx_1h] if c in numpy_htf['1h'] else np.zeros(num_candidates))
+                    elif col.startswith('15m_'):
+                        c = col[4:]
+                        oracle_features.append(numpy_htf['15m'][c][idx_15m] if c in numpy_htf['15m'] else np.zeros(num_candidates))
+                    elif col.startswith('4h_'):
+                        c = col[3:]
+                        oracle_features.append(numpy_htf['4h'][c][idx_4h] if c in numpy_htf['4h'] else np.zeros(num_candidates))
+                    elif col == 'sim_titan_score': oracle_features.append(titan_scores)
+                    elif col == 'sim_mc_score': oracle_features.append(np.full(num_candidates, 0.5))
+                    elif col == 'sim_pattern_score': oracle_features.append(np.full(num_candidates, 0.5))
+                    else: oracle_features.append(np.zeros(num_candidates))
+                
+                X_oracle_big = np.column_stack(oracle_features)
+                preds = oracle_dir_model.predict(X_oracle_big)
+                # Handle output shape
+                if len(preds.shape) > 1 and preds.shape[1] > 1:
+                    oracle_preds = preds[:, 1] # Prob of Class 1
+                else:
+                    oracle_preds = preds.flatten()
+                    # If model outputs 0/1 class, we might need proba. Assuming predict gives prob or class.
+                    # Adjust if simple XGB classifier gives 0/1. For backtest, assume regression or proba.
+            except Exception as e: print(f"Oracle Error: {e}")
+
+        # --- B. SNIPER MATRIX CONSTRUCTION ---
+        sniper_preds = np.full(num_candidates, 0.5)
+        if sniper_models:
+            try:
+                sniper_features = []
                 for col in getattr(self.proc.sniper, 'feature_names', []):
-                    if col in fast_1m: s_vec.append(fast_1m[col][i_idx])
-                    elif col == 'L_score': s_vec.append(fast_1m.get('vol_zscore_50', [0])[i_idx])
-                    else: s_vec.append(0.0)
-                sniper_batch_X.append(s_vec)
-            else:
-                temp_sniper_results[current_res_idx] = 0.5
-
-            # 4. Hydra
-            if hydra_models and global_hydra_static is not None:
-                start_idx = i_idx + 1; end_idx = start_idx + 240
-                sl_static = global_hydra_static[start_idx:end_idx]
-                entry_price = fast_1m['close'][i_idx]
-                sl_close = sl_static[:, 6]; sl_atr = sl_static[:, 5]
-                sl_dist = np.maximum(1.5 * sl_atr, entry_price * 0.015)
-                sl_pnl = sl_close - entry_price; sl_norm_pnl = sl_pnl / sl_dist
-                sl_cum_max = np.maximum.accumulate(sl_close); sl_cum_max = np.maximum(sl_cum_max, entry_price)
-                sl_max_pnl_r = (sl_cum_max - entry_price) / sl_dist
-                sl_atr_pct = sl_atr / sl_close
-                zeros = np.zeros(240); ones = np.full(240, 1.0)
-                X_cand = np.column_stack([
-                    sl_static[:, 0], sl_static[:, 1], sl_static[:, 2],
-                    sl_static[:, 3], sl_static[:, 4],
-                    zeros, sl_atr_pct, sl_norm_pnl, sl_max_pnl_r,
-                    zeros, zeros, time_vec,
-                    zeros, ones * 0.6, ones * 0.7, ones * 3.0
-                ])
-                hydra_batch_X.append(X_cand)
-                hydra_batch_indices.append(current_res_idx)
-
-            ai_results.append({
-                'timestamp': ts_val, 'symbol': sym, 'close': fast_1m['close'][i_idx],
-                'real_titan': titan_score_est, 'oracle_conf': 0.5, 'sniper_score': 0.5,
-                'l1_score': fast_1m['l1_score'][i_idx], 
-                'risk_hydra_crash': 0.0, 'time_hydra_crash': 0, 'risk_legacy_v2': 0.0
-            })
-            
-            current_batch_count += 1
-
-            # ✅ FIX: Trigger based on count, not just Hydra list size
-            if current_batch_count >= BATCH_SIZE:
-                if oracle_batch_X:
-                    try:
-                        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(preds):
-                            val = float(p[0]) if hasattr(p, '__iter__') else float(p)
-                            if val < 0.5: val = 1 - val 
-                            temp_oracle_results[start_i + i] = val
-                    except: pass
-                    oracle_batch_X = []
+                    if col in fast_1m: sniper_features.append(fast_1m[col][final_valid_indices])
+                    elif col == 'L_score': sniper_features.append(fast_1m.get('vol_zscore_50', np.zeros(len(fast_1m['close'])))[final_valid_indices])
+                    else: sniper_features.append(np.zeros(num_candidates))
                 
-                if sniper_batch_X:
-                    try:
-                        s_X = np.array(sniper_batch_X)
-                        preds = np.mean([m.predict(s_X) for m in sniper_models], axis=0)
-                        start_i = current_res_idx - len(sniper_batch_X) + 1
-                        for i, p in enumerate(preds): temp_sniper_results[start_i + i] = float(p)
-                    except: pass
-                    sniper_batch_X = []
-
-                if hydra_batch_X:
-                    try:
-                        big_X = np.vstack(hydra_batch_X)
-                        preds = hydra_models['crash'].predict_proba(big_X)[:, 1]
-                        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(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 = []
+                X_sniper_big = np.column_stack(sniper_features)
+                # Ensemble Average
+                preds_list = [m.predict(X_sniper_big) for m in sniper_models]
+                sniper_preds = np.mean(preds_list, axis=0)
+            except Exception as e: print(f"Sniper Error: {e}")
+
+        # --- C. HYDRA MATRIX CONSTRUCTION (The Heavy One) ---
+        hydra_risk_preds = np.zeros(num_candidates)
+        hydra_time_preds = np.zeros(num_candidates, dtype=int)
+        
+        # Hydra is sequence-based (window of 240). Vectorizing this is tricky without exploding memory.
+        # We will iterate but ONLY for prediction input construction, which is lighter than full logic.
+        # Actually, for 95k candidates, a (95000, 240, features) array is huge.
+        # We MUST batch Hydra. But efficiently.
+        
+        if hydra_models and global_hydra_static is not None:
+            # We process in chunks of 5000 to keep memory sane
+            chunk_size = 5000
+            for i in range(0, num_candidates, chunk_size):
+                chunk_indices = final_valid_indices[i : i + chunk_size]
                 
-                current_batch_count = 0
-
-        # Process Leftovers (Same logic)
-        if oracle_batch_X:
-            try:
-                preds = oracle_dir_model.predict(np.array(oracle_batch_X))
-                start_i = len(ai_results) - len(oracle_batch_X)
-                for i, p in enumerate(preds):
-                    val = float(p[0]) if hasattr(p, '__iter__') else float(p)
-                    if val < 0.5: val = 1 - val
-                    temp_oracle_results[start_i + i] = val
-            except: pass
-        if sniper_batch_X:
-            try:
-                s_X = np.array(sniper_batch_X)
-                preds = np.mean([m.predict(s_X) for m in sniper_models], axis=0)
-                start_i = len(ai_results) - len(sniper_batch_X)
-                for i, p in enumerate(preds): temp_sniper_results[start_i + i] = float(p)
-            except: pass
-        if hydra_batch_X:
-            try:
-                big_X = np.vstack(hydra_batch_X)
-                preds = hydra_models['crash'].predict_proba(big_X)[:, 1]
-                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(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
-
+                # Build batch X
+                batch_X = []
+                valid_batch_indices = [] # Map back to chunk index
+                
+                for k, idx in enumerate(chunk_indices):
+                    start = idx + 1
+                    end = start + 240
+                    # Quick slice
+                    sl_static = global_hydra_static[start:end]
+                    
+                    entry_p = fast_1m['close'][idx]
+                    sl_close = sl_static[:, 6]
+                    sl_atr = sl_static[:, 5]
+                    
+                    sl_dist = np.maximum(1.5 * sl_atr, entry_p * 0.015)
+                    sl_pnl = sl_close - entry_p
+                    sl_norm_pnl = sl_pnl / sl_dist
+                    
+                    # Accumulate max - vectorized for the window
+                    sl_cum_max = np.maximum.accumulate(sl_close)
+                    sl_cum_max = np.maximum(sl_cum_max, entry_p)
+                    sl_max_pnl_r = (sl_cum_max - entry_p) / sl_dist
+                    
+                    sl_atr_pct = sl_atr / sl_close
+                    
+                    # Static cols
+                    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],
+                        zeros, sl_atr_pct, sl_norm_pnl, sl_max_pnl_r,
+                        zeros, zeros, time_vec,
+                        zeros, ones*0.6, ones*0.7, ones*3.0
+                    ])
+                    batch_X.append(row)
+                    valid_batch_indices.append(i + k) # Global index in final_valid_indices
+
+                if batch_X:
+                    try:
+                        big_X = np.array(batch_X) # Shape: (Batch, 240, Feats)
+                        # Flatten for 2D model if needed, or keeping 3D depending on Hydra.
+                        # Assuming Hydra uses 2D input (stacking windows):
+                        big_X_flat = big_X.reshape(-1, big_X.shape[-1])
+                        
+                        preds_flat = hydra_models['crash'].predict_proba(big_X_flat)[:, 1]
+                        
+                        # Reshape back to (Batch, 240)
+                        preds_batch = preds_flat.reshape(len(batch_X), 240)
+                        
+                        # Extract Max Risk & Time
+                        batch_max_risk = np.max(preds_batch, axis=1)
+                        
+                        # Find first index > thresh (0.6) for time
+                        over_thresh = preds_batch > 0.6
+                        # argmax gives first True index
+                        has_crash = over_thresh.any(axis=1)
+                        crash_times_rel = np.argmax(over_thresh, axis=1)
+                        
+                        # Map back to global results
+                        for j, glob_idx in enumerate(valid_batch_indices):
+                            hydra_risk_preds[glob_idx] = batch_max_risk[j]
+                            if has_crash[j]:
+                                # Calc absolute timestamp
+                                start_t_idx = final_valid_indices[glob_idx] + 1
+                                abs_time = fast_1m['timestamp'][start_t_idx + crash_times_rel[j]]
+                                hydra_time_preds[glob_idx] = abs_time
+                                
+                    except Exception: pass
+
+        # --- D. LEGACY V2 MAPPING ---
+        legacy_risk_preds = np.zeros(num_candidates)
+        legacy_time_preds = np.zeros(num_candidates, dtype=int)
+        
         if legacy_v2:
-             for idx, res in enumerate(ai_results):
-                 ts = res['timestamp']
-                 idx_1m = np.searchsorted(fast_1m['timestamp'], ts)
-                 start = idx_1m + 1
-                 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
-
-        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]
+            # Vectorized mapping logic
+            # For each candidate at idx, scan global_v2_probs[idx+1 : idx+241]
+            # This is a sliding window max. Can be slow if looped.
+            # Fast approx: Check max just for the entry? No, need lookahead.
+            # We loop simply because it's fast scalar lookups.
+            for k, idx in enumerate(final_valid_indices):
+                start = idx + 1
+                if start + 240 < len(global_v2_probs):
+                    window = global_v2_probs[start : start + 240]
+                    legacy_risk_preds[k] = np.max(window)
+                    # Time logic can be added if needed, sticking to max risk for now
+
+        # --- E. CONSTRUCT FINAL DATAFRAME ---
+        # Titan Proxy
+        titan_scores_final = np.clip(fast_1m['l1_score'][final_valid_indices] / 40.0, 0.1, 0.95)
+        l1_scores_final = fast_1m['l1_score'][final_valid_indices]
+        timestamps_final = fast_1m['timestamp'][final_valid_indices]
+        closes_final = fast_1m['close'][final_valid_indices]
+        
+        ai_df = pd.DataFrame({
+            'timestamp': timestamps_final,
+            'symbol': sym,
+            'close': closes_final,
+            'real_titan': titan_scores_final,
+            'oracle_conf': oracle_preds,
+            'sniper_score': sniper_preds,
+            'l1_score': l1_scores_final,
+            'risk_hydra_crash': hydra_risk_preds,
+            'time_hydra_crash': hydra_time_preds,
+            'risk_legacy_v2': legacy_risk_preds,
+            'time_legacy_panic': legacy_time_preds
+        })
 
         dt = time.time() - t0
-        if ai_results:
-            pd.DataFrame(ai_results).to_pickle(scores_file)
-            print(f"   ✅ [{sym}] Completed {len(ai_results)} signals in {dt:.2f} seconds.", flush=True)
+        if not ai_df.empty:
+            ai_df.to_pickle(scores_file)
+            print(f"   ✅ [{sym}] Completed {len(ai_df)} signals in {dt:.2f} seconds.", flush=True)
             
         del frames, fast_1m, numpy_htf, global_v2_probs, global_hydra_static
         gc.collect()
@@ -464,6 +500,7 @@ class HeavyDutyBacktester:
         global_df = pd.concat(all_data)
         global_df.sort_values('timestamp', inplace=True)
         
+        # 🚀 Numpy Conversion 🚀
         arr_ts = global_df['timestamp'].values
         arr_close = global_df['close'].values.astype(np.float64)
         arr_symbol = global_df['symbol'].values
@@ -479,19 +516,12 @@ class HeavyDutyBacktester:
         arr_sym_int = np.array([sym_map[s] for s in arr_symbol], dtype=np.int32)
         
         total_len = len(arr_ts)
-        total_combos = len(combinations_batch)
-        print(f"     🚀 [System] Starting Optimized Grid Search on {total_combos} combos...", flush=True)
+        print(f"     🚀 [System] Starting Optimized Grid Search on {len(combinations_batch)} combos...", flush=True)
 
         results = []
-        start_time = time.time()
         
         for idx, config in enumerate(combinations_batch):
-            if idx > 0 and idx % 10 == 0:
-                elapsed = time.time() - start_time
-                avg_time = elapsed / idx
-                rem_time = avg_time * (total_combos - idx)
-                sys.stdout.write(f"\r        ⚙️ Progress: {idx}/{total_combos} ({idx/total_combos:.1%}) | ETA: {rem_time:.0f}s")
-                sys.stdout.flush()
+            # No Annoying Progress Logs
 
             wallet_bal = initial_capital
             wallet_alloc = 0.0
@@ -513,6 +543,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]
@@ -530,6 +561,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:
@@ -540,6 +572,7 @@ class HeavyDutyBacktester:
                                  wallet_bal -= size
                                  wallet_alloc += size
 
+            # Stats
             final_bal = wallet_bal + wallet_alloc
             net_profit = final_bal - initial_capital
             total_t = len(trades_log)
@@ -553,6 +586,9 @@ class HeavyDutyBacktester:
             hc_avg_pnl = (sum(p for p, s in trades_log if s > 0.65)/hc_count*100) if hc_count > 0 else 0.0
             agree_rate = (hc_count / total_t * 100) if total_t > 0 else 0.0
 
+            # ✅ FIX: Ensure 'thresh' key exists for AdaptiveHub compatibility
+            config['thresh'] = l1_thresh 
+
             results.append({
                 'config': config, 'final_balance': final_bal, 'net_profit': net_profit,
                 'total_trades': total_t, 'win_count': win_count, 'loss_count': loss_count,
@@ -609,9 +645,9 @@ class HeavyDutyBacktester:
         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 System Mirror Mode...")
+    print("\n🧪 [STRATEGIC BACKTEST] Hyper-Vectorized Mode...")
     r2 = R2Service()
     dm = DataManager(None, None, r2)
     proc = MLProcessor(dm)