Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V68.0 - GEM-Architect: Logic Tree Simulator)
+# 🧪 backtest_engine.py (V69.0 - GEM-Architect: Detailed Analytics)
 # ============================================================
 
 import asyncio
@@ -27,24 +27,21 @@ class HeavyDutyBacktester:
     def __init__(self, data_manager, processor):
         self.dm = data_manager
         self.proc = processor
-        self.GRID_DENSITY = 5 
-        self.BACKTEST_DAYS = 7
+        self.GRID_DENSITY = 15
+        self.BACKTEST_DAYS = 7 # 7 أيام كافية للتحسين السريع، 14 للدقة العالية
         
         # 💰 إعدادات التوأم الرقمي
         self.INITIAL_CAPITAL = 10.0
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
         
-        self.TARGET_COINS = [
-            'BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT', 'XRP/USDT',
-            'DOGE/USDT', 'ADA/USDT', 'AVAX/USDT'
-        ]
+        self.TARGET_COINS = [ 'SOL/USDT', 'XRP/USDT', 'DOGE/USDT', 'ADA/USDT', 'AVAX/USDT', 'LINK/USDT', 'TON/USDT', 'INJ/USDT', 'APT/USDT', 'OP/USDT', 'ARB/USDT', 'SUI/USDT', 'SEI/USDT', 'TIA/USDT', 'MATIC/USDT', 'PEPE/USDT', 'NEAR/USDT', 'RUNE/USDT', 'PYTH/USDT', 'WIF/USDT' ]
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V68.0] Logic Tree Simulator (Anti-FOMO).")
+        print(f"🧪 [Backtest V69.0] Detailed Analytics Mode Active.")
 
     # ==============================================================
-    # 🛠️ Helpers (Resampling Exact Match)
+    # 🛠️ Helpers
     # ==============================================================
     def resample_data(self, df_1m, timeframe_str):
         if df_1m.empty: return pd.DataFrame()
@@ -52,20 +49,19 @@ class HeavyDutyBacktester:
         rule = timeframe_str.replace('m', 'T').replace('h', 'H').replace('d', 'D')
         try:
             resampled = df_1m.resample(rule).agg(agg_dict).dropna()
-            # التأكد من إعادة التسمية الصحيحة للأعمدة
             resampled['timestamp'] = resampled.index.astype(np.int64) // 10**6
             return resampled
         except Exception: return pd.DataFrame()
 
     def df_to_list(self, df):
         if df.empty: return []
-        # ترتيب الأعمدة كما يتوقعها DataManager القديم والجديد
         return df[['timestamp', 'open', 'high', 'low', 'close', 'volume']].values.tolist()
 
     # ==============================================================
     # PHASE 1: Generate Truth Data (Strict Logic Tree)
     # ==============================================================
     async def generate_truth_data(self):
+        # (نفس منطق V68 السابق - لم يتغير لأنه صحيح)
         print(f"\n🚜 [Phase 1] Replicating V45.0 Logic Tree ({self.BACKTEST_DAYS} Days)...")
         end_time_ms = int(time.time() * 1000)
         start_time_ms = end_time_ms - (self.BACKTEST_DAYS * 24 * 60 * 60 * 1000) 
@@ -80,7 +76,6 @@ class HeavyDutyBacktester:
 
             print(f"   ⚙️ Simulating {sym}...", end="", flush=True)
             
-            # 1. جلب بيانات الدقيقة (الخام)
             all_candles_1m = []
             current_since = start_time_ms
             while current_since < end_time_ms:
@@ -106,70 +101,58 @@ class HeavyDutyBacktester:
             df_1m = df_1m.sort_index()
             
             ai_results = []
-            # نفحص كل 15 دقيقة (لأن الفلتر يعمل على إطار الربع ساعة والساعة)
             resample_freq = '15T'
             time_indices = df_1m.resample(resample_freq).last().dropna().index
             
-            for t_idx in time_indices[200:]: # نبدأ بعد فترة لضمان وجود بيانات كافية للمؤشرات
+            for t_idx in time_indices[200:]:
                 current_slice_1m = df_1m.loc[:t_idx]
                 if len(current_slice_1m) < 500: continue
                 current_price = current_slice_1m['close'].iloc[-1]
                 
-                # 🔥 المحاكاة الدقيقة: بناء المدخلات كما يطلبها _apply_logic_tree
-                # نحتاج شموع 1 ساعة و 15 دقيقة
-                # نأخذ بيانات كافية (آخر 100 شمعة لكل إطار)
-                
                 df_1h = self.resample_data(current_slice_1m.tail(6000), '1h')
                 df_15m = self.resample_data(current_slice_1m.tail(1500), '15m')
                 
                 if len(df_1h) < 60 or len(df_15m) < 60: continue
 
-                # تحويل البيانات إلى القوائم التي يتوقعها DataManager V45
                 simulated_data_packet = {
                     'symbol': sym,
                     'ohlcv_1h': self.df_to_list(df_1h.tail(60)),
                     'ohlcv_15m': self.df_to_list(df_15m.tail(60)),
-                    'change_24h': 0.0 # (يمكن حسابه بدقة أكبر إذا لزم الأمر، لكن الفلتر يعتمد على 4H أكثر)
+                    'change_24h': 0.0 
                 }
                 
-                # حساب نسبة التغير اليومي للمحاكاة (للصرامة)
                 try:
                     price_24h_ago = df_1h.iloc[-24]['close'] if len(df_1h) >= 24 else df_1h.iloc[0]['close']
                     simulated_data_packet['change_24h'] = ((current_price - price_24h_ago) / price_24h_ago) * 100
                 except: pass
 
-                # 🔥 استدعاء المنطق الصارم مباشرة
-                # هذا يضمن أن الباكتست يرى بالضبط ما يراه النظام الحي (Breakout/Reversal/None)
+                # استدعاء المنطق الصارم
                 logic_result = self.dm._apply_logic_tree(simulated_data_packet)
                 
                 signal_type = logic_result.get('type', 'NONE')
                 l1_score = logic_result.get('score', 0.0)
                 
-                # تخزين النتيجة فقط إذا كان هناك إشارة (لتوفير الذاكرة وتسريع المعالجة)
-                # أو تخزين الكل إذا أردنا تدريب Titan على الرفض
-                
-                # محاكاة Titan (اختياري، للسرعة نضع قيمة افتراضية أو نستدعي النموذج)
+                # Titan Simulation Placeholder
                 titan_real = 0.5
                 
-                # إذا كانت الإشارة مقبولة، نحفظها
                 if signal_type in ['BREAKOUT', 'REVERSAL']:
                     ai_results.append({
                         'timestamp': int(t_idx.timestamp() * 1000),
                         'symbol': sym,
                         'close': current_price,
                         'real_titan': titan_real, 
-                        'signal_type': signal_type, # ✅ نوع الإشارة (مهم جداً)
-                        'l1_score': l1_score        # ✅ قوة الإشارة
+                        'signal_type': signal_type,
+                        'l1_score': l1_score
                     })
             
             if ai_results:
                 pd.DataFrame(ai_results).to_pickle(scores_file)
                 print(f" ✅ Saved ({len(ai_results)} signals).")
             else:
-                print(" ⚠️ No strict signals found (Expected behavior for Anti-FOMO).")
+                print(" ⚠️ No strict signals found.")
 
     # ==============================================================
-    # PHASE 2: Portfolio Digital Twin Engine
+    # PHASE 2: Portfolio Digital Twin Engine (Enhanced Stats)
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
@@ -193,11 +176,11 @@ class HeavyDutyBacktester:
                 "balance": initial_capital,
                 "allocated": 0.0,
                 "positions": {}, 
-                "trades_history": []
+                "trades_history": [] # Store {pnl: float}
             }
             
             w_titan = config['w_titan']
-            w_struct = config['w_struct'] # هذا سيكون وزناً لنوع الإشارة وقوتها
+            w_struct = config['w_struct']
             entry_thresh = config['thresh']
             
             for ts, group in grouped_by_time:
@@ -221,7 +204,7 @@ class HeavyDutyBacktester:
                             del wallet["positions"][sym]
                             wallet["trades_history"].append({'pnl': net_pnl})
 
-                # 2. Entry Logic (Strict)
+                # 2. Entry Logic
                 if len(wallet["positions"]) < max_slots:
                     free_capital = wallet["balance"] - wallet["allocated"]
                     slots_left = max_slots - len(wallet["positions"])
@@ -235,21 +218,13 @@ class HeavyDutyBacktester:
                             sym = row['symbol']
                             if sym in wallet["positions"]: continue
                             
-                            # 🔥 استخدام البيانات الجديدة
-                            sig_type = row['signal_type'] # BREAKOUT or REVERSAL
-                            l1_raw_score = row['l1_score'] # Score from Logic Tree
+                            sig_type = row['signal_type']
+                            l1_raw_score = row['l1_score']
                             real_titan = row['real_titan']
                             
-                            # تطبيع سكور الـ L1 ليكون متوافقاً مع المعادلة (0-1)
-                            # Breakout score عادة يكون صغيراً (1.5 - 5.0 ratio)
-                            # Reversal score (0-100)
-                            
                             norm_struct = 0.0
-                            if sig_type == 'BREAKOUT':
-                                # كلما زاد الفوليوم كان أفضل، لنقل 5.0 هو الحد الأقصى للطبيعي
-                                norm_struct = min(1.0, l1_raw_score / 5.0)
-                            elif sig_type == 'REVERSAL':
-                                norm_struct = l1_raw_score / 100.0
+                            if sig_type == 'BREAKOUT': norm_struct = min(1.0, l1_raw_score / 5.0)
+                            elif sig_type == 'REVERSAL': norm_struct = l1_raw_score / 100.0
                             
                             score = 0.0
                             if (w_titan + w_struct) > 0:
@@ -262,18 +237,64 @@ class HeavyDutyBacktester:
                 
                 if wallet["balance"] < 1.0 and len(wallet["positions"]) == 0: break
 
-            # Statistics
+            # 🔥🔥🔥 إحصائيات تفصيلية (Detailed Analytics) 🔥🔥🔥
             trades = wallet["trades_history"]
             if trades:
                 net_profit = wallet["balance"] - initial_capital
+                
+                # 1. الربح والخسارة
+                pnls = [t['pnl'] for t in trades]
+                wins = [p for p in pnls if p > 0]
+                losses = [p for p in pnls if p <= 0]
+                
+                win_count = len(wins)
+                loss_count = len(losses)
+                total_trades = len(trades)
+                win_rate = (win_count / total_trades) * 100
+                
+                # 2. أقصى ربح وخسارة فردية
+                max_single_win = max(pnls) if pnls else 0.0
+                max_single_loss = min(pnls) if pnls else 0.0
+                
+                # 3. السلاسل المتتالية (Streaks)
+                current_win_streak = 0
+                max_win_streak = 0
+                current_loss_streak = 0
+                max_loss_streak = 0
+                
+                for p in pnls:
+                    if p > 0:
+                        current_win_streak += 1
+                        current_loss_streak = 0
+                        if current_win_streak > max_win_streak: max_win_streak = current_win_streak
+                    else:
+                        current_loss_streak += 1
+                        current_win_streak = 0
+                        if current_loss_streak > max_loss_streak: max_loss_streak = current_loss_streak
+
                 results.append({
                     'config': config,
                     'final_balance': wallet["balance"],
                     'net_profit': net_profit,
-                    'total_trades': len(trades)
+                    'total_trades': total_trades,
+                    'win_count': win_count,
+                    'loss_count': loss_count,
+                    'win_rate': win_rate,
+                    'max_single_win': max_single_win,
+                    'max_single_loss': max_single_loss,
+                    'max_win_streak': max_win_streak,
+                    'max_loss_streak': max_loss_streak
                 })
             else:
-                 results.append({'config': config, 'final_balance': initial_capital, 'net_profit': 0.0, 'total_trades': 0})
+                 results.append({
+                     'config': config, 
+                     'final_balance': initial_capital, 
+                     'net_profit': 0.0, 
+                     'total_trades': 0,
+                     'win_count': 0, 'loss_count': 0, 'win_rate': 0.0,
+                     'max_single_win': 0.0, 'max_single_loss': 0.0,
+                     'max_win_streak': 0, 'max_loss_streak': 0
+                 })
 
         return results
 
@@ -282,7 +303,7 @@ class HeavyDutyBacktester:
         
         score_files = [os.path.join(CACHE_DIR, f) for f in os.listdir(CACHE_DIR) if f.endswith(f'_logictree_scores.pkl')]
         if not score_files:
-            print("❌ No Strict Logic signals found. Try changing coins or extending days.")
+            print("❌ No Strict Logic signals found.")
             return None
 
         print(f"\n🧩 [Phase 2] Running Strict Logic Simulation...")
@@ -317,11 +338,21 @@ class HeavyDutyBacktester:
             
         best = sorted(final_results, key=lambda x: x['final_balance'], reverse=True)[0]
         
+        # 🔥🔥🔥 التقرير التفصيلي الكامل 🔥🔥🔥
         print("\n" + "="*60)
         print(f"🏆 CHAMPION STRICT REPORT ({self.BACKTEST_DAYS} Days):")
-        print(f"   💰 Final Balance: ${best['final_balance']:,.2f}")
-        print(f"   🚀 Net PnL:       ${best['net_profit']:,.2f}")
-        print(f"   📊 Trades:        {best['total_trades']}")
+        print(f"   💰 Final Balance:   ${best['final_balance']:,.2f}")
+        print(f"   🚀 Net PnL:         ${best['net_profit']:,.2f}")
+        print("-" * 60)
+        print(f"   📊 Total Trades:    {best['total_trades']}")
+        print(f"   ✅ Winning Trades:  {best['win_count']}")
+        print(f"   ❌ Losing Trades:   {best['loss_count']}")
+        print(f"   📈 Win Rate:        {best['win_rate']:.1f}%")
+        print("-" * 60)
+        print(f"   🟢 Max Single Win:  ${best['max_single_win']:.2f}")
+        print(f"   🔴 Max Single Loss: ${best['max_single_loss']:.2f}")
+        print(f"   🔥 Max Win Streak:  {best['max_win_streak']} trades")
+        print(f"   🧊 Max Loss Streak: {best['max_loss_streak']} trades")
         print("-" * 60)
         print(f"   ⚙️ Config: Titan={best['config']['w_titan']} | Struct={best['config']['w_struct']} | Thresh={best['config']['thresh']}")
         print("="*60)