Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V67.0 - GEM-Architect: Portfolio Digital Twin)
+# 🧪 backtest_engine.py (V68.0 - GEM-Architect: Logic Tree Simulator)
 # ============================================================
 
 import asyncio
@@ -12,7 +12,6 @@ import os
 import concurrent.futures
 from typing import Dict, Any, List
 
-# استيراد الوحدات الأساسية
 try:
     from ml_engine.processor import MLProcessor, SystemLimits 
     from ml_engine.data_manager import DataManager
@@ -28,13 +27,13 @@ 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 = 5 
+        self.BACKTEST_DAYS = 14 
         
-        # 💰 إعدادات التوأم الرقمي (Portfolio Twin Settings)
+        # 💰 إعدادات التوأم الرقمي
         self.INITIAL_CAPITAL = 10.0
-        self.TRADING_FEES = 0.001  # 0.1% Maker/Taker
-        self.MAX_SLOTS = 4         # الحد الأقصى للصفقات المتزامنة (كما في النظام)
+        self.TRADING_FEES = 0.001 
+        self.MAX_SLOTS = 4         
         
         self.TARGET_COINS = [
             'BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT', 'XRP/USDT',
@@ -42,43 +41,46 @@ class HeavyDutyBacktester:
         ]
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V67.0] Portfolio Digital Twin Mode (Start: ${self.INITIAL_CAPITAL}).")
+        print(f"🧪 [Backtest V68.0] Logic Tree Simulator (Anti-FOMO).")
 
-    # ... (نفس دوال المساعدة resample_data و df_to_list) ...
+    # ==============================================================
+    # 🛠️ Helpers (Resampling Exact Match)
+    # ==============================================================
     def resample_data(self, df_1m, timeframe_str):
         if df_1m.empty: return pd.DataFrame()
         agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
         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 (Standard)
+    # PHASE 1: Generate Truth Data (Strict Logic Tree)
     # ==============================================================
     async def generate_truth_data(self):
-        # ... (نفس كود توليد البيانات السابق تماماً - لا تغيير هنا) ...
-        # اختصاراً للمساحة سأضع الكود الأساسي فقط
-        print(f"\n🚜 [Phase 1] Fetching & Structural Analysis ({self.BACKTEST_DAYS} Days)...")
+        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) 
-        test_regime = "RANGE" 
         
         for sym in self.TARGET_COINS:
             safe_sym = sym.replace('/', '_')
-            scores_file = f"{CACHE_DIR}/{safe_sym}_struct_scores_{self.BACKTEST_DAYS}d.pkl"
+            scores_file = f"{CACHE_DIR}/{safe_sym}_logictree_scores.pkl"
+            
             if os.path.exists(scores_file):
                 print(f"   📂 {sym} scores ready. Skipping.")
                 continue
+
+            print(f"   ⚙️ Simulating {sym}...", end="", flush=True)
             
-            print(f"   ⚙️ Processing {sym}...", end="", flush=True)
-            # ... (Fetching logic same as V66) ...
+            # 1. جلب بيانات الدقيقة (الخام)
             all_candles_1m = []
             current_since = start_time_ms
             while current_since < end_time_ms:
@@ -97,92 +99,110 @@ class HeavyDutyBacktester:
             if not all_candles_1m: 
                 print(" No Data.")
                 continue
-                
+
             df_1m = pd.DataFrame(all_candles_1m, 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)
             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[100:]:
+            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]
                 
-                df_struct = self.resample_data(current_slice_1m.tail(5000), '15m')
-                if len(df_struct) < 200: continue
-                
-                struct_score, _ = self.dm._calculate_structural_score(df_struct, sym, test_regime)
-                norm_struct_score = max(0.0, min(1.0, (struct_score + 20) / 100.0))
+                # 🔥 المحاكاة الدقيقة: بناء المدخلات كما يطلبها _apply_logic_tree
+                # نحتاج شموع 1 ساعة و 15 دقيقة
+                # نأخذ بيانات كافية (آخر 100 شمعة لكل إطار)
                 
-                # ... (Titan simulation) ...
-                titan_real = 0.5 
+                df_1h = self.resample_data(current_slice_1m.tail(6000), '1h')
+                df_15m = self.resample_data(current_slice_1m.tail(1500), '15m')
                 
-                ai_results.append({
-                    'timestamp': int(t_idx.timestamp() * 1000), # حفظ الوقت بدقة للترتيب الزمني
+                if len(df_1h) < 60 or len(df_15m) < 60: continue
+
+                # تحويل البيانات إلى القوائم التي يتوقعها DataManager V45
+                simulated_data_packet = {
                     'symbol': sym,
-                    'close': current_price,
-                    'real_titan': titan_real, 
-                    'real_struct_score': norm_struct_score
-                })
+                    '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 أكثر)
+                }
+                
+                # حساب نسبة التغير اليومي للمحاكاة (للصرامة)
+                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_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        # ✅ قوة الإشارة
+                    })
             
             if ai_results:
                 pd.DataFrame(ai_results).to_pickle(scores_file)
-                print(f" ✅ Saved.")
+                print(f" ✅ Saved ({len(ai_results)} signals).")
+            else:
+                print(" ⚠️ No strict signals found (Expected behavior for Anti-FOMO).")
 
     # ==============================================================
     # PHASE 2: Portfolio Digital Twin Engine
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
-        """
-        محاكاة دقيقة لإدارة المحفظة مع الزمن (Time-Series Portfolio Simulation).
-        """
         results = []
         
-        # 1. دمج جميع البيانات وترتيبها زمنياً (Time-Sorted Global Timeline)
-        # لضمان محاكاة السوق بشكل واقعي (لا يمكننا معالجة كل عملة وحدها)
         all_data = []
         for fp in scores_files:
             try: 
                 df = pd.read_pickle(fp)
-                all_data.append(df)
+                if not df.empty: all_data.append(df)
             except: pass
         
         if not all_data: return []
         
         global_df = pd.concat(all_data)
         global_df.sort_values('timestamp', inplace=True)
-        # تجميع البيانات حسب الطابع الزمني (للمعالجة لحظة بلحظة)
         grouped_by_time = global_df.groupby('timestamp')
         
-        # ----------------------------------------------------
-        
         for config in combinations_batch:
-            # 🏦 حالة المحفظة (Portfolio State)
             wallet = {
-                "balance": initial_capital, # الرصيد الكلي
-                "allocated": 0.0,           # المحجوز في صفقات
-                "positions": {},            # الصفقات المفتوحة: {symbol: {entry_p, size_usd}}
-                "equity_curve": [initial_capital],
+                "balance": initial_capital,
+                "allocated": 0.0,
+                "positions": {}, 
                 "trades_history": []
             }
             
             w_titan = config['w_titan']
-            w_struct = config['w_struct']
+            w_struct = config['w_struct'] # هذا سيكون وزناً لنوع الإشارة وقوتها
             entry_thresh = config['thresh']
             
-            # ⏳ المرور عبر الزمن (Time-Step Simulation)
             for ts, group in grouped_by_time:
-                # أ. إدارة الصفقات المفتوحة (Check Exits)
-                # يجب استخدام نسخة من المفاتيح للتعديل أثناء الدوران
+                # 1. Exit Logic
                 active_symbols = list(wallet["positions"].keys())
-                
-                # نحتاج معرفة الأسعار الحالية للعملات المفتوحة
-                # نستخرجها من المجموعة الحالية إذا توفرت
                 current_prices = {row['symbol']: row['close'] for _, row in group.iterrows()}
                 
                 for sym in active_symbols:
@@ -190,125 +210,83 @@ class HeavyDutyBacktester:
                         curr_p = current_prices[sym]
                         pos = wallet["positions"][sym]
                         entry_p = pos['entry_price']
-                        
                         pct_change = (curr_p - entry_p) / entry_p
                         
-                        # Exit Rules (TP 3% / SL 2%)
                         if pct_change >= 0.03 or pct_change <= -0.02:
-                            # تنفيذ الخروج
                             gross_pnl = pos['size_usd'] * pct_change
-                            fees = pos['size_usd'] * fees_pct * 2 # رسوم دخول وخروج تقريبية
+                            fees = pos['size_usd'] * fees_pct * 2
                             net_pnl = gross_pnl - fees
-                            
                             wallet["allocated"] -= pos['size_usd']
-                            wallet["balance"] += net_pnl # الرصيد يتحدث بالصافي
-                            
+                            wallet["balance"] += net_pnl
                             del wallet["positions"][sym]
-                            
-                            wallet["trades_history"].append({
-                                'pnl': net_pnl,
-                                'roi': (net_pnl / pos['size_usd']) * 100
-                            })
+                            wallet["trades_history"].append({'pnl': net_pnl})
 
-                # ب. البحث عن فرص جديدة (Check Entries)
-                # فقط إذا كان لدينا خانات فارغة ورصيد كافٍ
+                # 2. Entry Logic (Strict)
                 if len(wallet["positions"]) < max_slots:
                     free_capital = wallet["balance"] - wallet["allocated"]
-                    
-                    # محاكاة منطق تقسيم رأس المال (Smart Portfolio Logic)
-                    # الحجم = الرصيد الحر / الخانات المتبقية (تقريبي)
                     slots_left = max_slots - len(wallet["positions"])
-                    if slots_left > 0 and free_capital > 2.0: # الحد الأدنى للدخول
-                        # إذا كان الرصيد صغيراً جداً، ندخل بالكل المتاح (لأننا تحت 20$)
-                        if wallet["balance"] < 20.0:
-                             # إذا كان رصيد قليل، نأخذ ما يكفي لصفقة واحدة أو المتاح
-                             # لنقل نستخدم All-in للخانات المتبقية
-                             position_size = free_capital / slots_left
-                        else:
-                             # تقسيم متوازن
-                             position_size = wallet["balance"] / max_slots
-                             position_size = min(position_size, free_capital)
+                    
+                    if slots_left > 0 and free_capital > 2.0:
+                        position_size = wallet["balance"] / max_slots
+                        if wallet["balance"] < 20.0: position_size = free_capital / slots_left
+                        position_size = min(position_size, free_capital)
 
-                        # المرور على الفرص المتاحة في هذه اللحظة
                         for _, row in group.iterrows():
                             sym = row['symbol']
-                            if sym in wallet["positions"]: continue # لدينا صفقة بالفعل
+                            if sym in wallet["positions"]: continue
+                            
+                            # 🔥 استخدام البيانات الجديدة
+                            sig_type = row['signal_type'] # BREAKOUT or REVERSAL
+                            l1_raw_score = row['l1_score'] # Score from Logic Tree
+                            real_titan = row['real_titan']
                             
-                            # حساب السكور
-                            real_titan = row.get('real_titan', 0.5)
-                            real_struct = row.get('real_struct_score', 0.0)
+                            # تطبيع سكور الـ 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
                             
                             score = 0.0
                             if (w_titan + w_struct) > 0:
-                                score = ((real_titan * w_titan) + (real_struct * w_struct)) / (w_titan + w_struct)
+                                score = ((real_titan * w_titan) + (norm_struct * w_struct)) / (w_titan + w_struct)
                             
                             if score >= entry_thresh:
-                                # ✅ فتح صفقة جديدة (مع خصم رسوم الدخول من الحجم الفعلي)
-                                # نحجز المبلغ كاملاً، لكن الرسوم ستخصم عند الخروج لتبسيط المحاكاة
-                                wallet["positions"][sym] = {
-                                    'entry_price': row['close'],
-                                    'size_usd': position_size
-                                }
+                                wallet["positions"][sym] = {'entry_price': row['close'], 'size_usd': position_size}
                                 wallet["allocated"] += position_size
-                                
-                                # نتوقف عن البحث في هذه اللحظة إذا امتلأت الخانات
                                 if len(wallet["positions"]) >= max_slots: break
+                
+                if wallet["balance"] < 1.0 and len(wallet["positions"]) == 0: break
 
-                # تسجيل منحنى رأس المال (Equity Curve)
-                # Equity = Balance (Unrealized PnL is ignored for speed, only Realized)
-                # أو يمكن حساب Unrealized لدقة أكبر، لكن Realized يكفي للتحسين
-                wallet["equity_curve"].append(wallet["balance"])
-
-                # شرط الإفلاس
-                if wallet["balance"] < 1.0 and len(wallet["positions"]) == 0:
-                    break
-
-            # 3. تجميع النتائج
+            # Statistics
             trades = wallet["trades_history"]
             if trades:
                 net_profit = wallet["balance"] - initial_capital
-                wins = len([t for t in trades if t['pnl'] > 0])
-                total = len(trades)
-                
-                # Max Drawdown
-                peaks = pd.Series(wallet["equity_curve"]).cummax()
-                drawdown = (wallet["equity_curve"] - peaks) 
-                max_dd = drawdown.min() # قيمة سالبة
-
                 results.append({
                     'config': config,
-                    'net_profit': net_profit,
                     'final_balance': wallet["balance"],
-                    'total_trades': total,
-                    'win_rate': (wins/total)*100,
-                    'max_drawdown': max_dd,
-                    'roi_pct': (net_profit / initial_capital) * 100
+                    'net_profit': net_profit,
+                    'total_trades': len(trades)
                 })
             else:
-                 results.append({
-                    'config': config,
-                    'net_profit': 0.0,
-                    'final_balance': initial_capital,
-                    'total_trades': 0,
-                    'win_rate': 0.0,
-                    'max_drawdown': 0.0,
-                    'roi_pct': 0.0
-                })
+                 results.append({'config': config, 'final_balance': initial_capital, 'net_profit': 0.0, 'total_trades': 0})
 
         return results
 
     async def run_optimization(self):
         await self.generate_truth_data()
         
-        score_files = [os.path.join(CACHE_DIR, f) for f in os.listdir(CACHE_DIR) if f.endswith(f'_scores_{self.BACKTEST_DAYS}d.pkl')]
+        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 data found.")
+            print("❌ No Strict Logic signals found. Try changing coins or extending days.")
             return None
 
-        print(f"\n🧩 [Phase 2] Running Digital Twin Simulation...")
+        print(f"\n🧩 [Phase 2] Running Strict Logic Simulation...")
         print(f"   💰 Start Capital: ${self.INITIAL_CAPITAL}")
-        print(f"   🎰 Max Slots:     {self.MAX_SLOTS}")
-        print(f"   💸 Fees:          {self.TRADING_FEES*100}% per trade")
         
         w_titan_range = np.linspace(0.4, 0.9, num=self.GRID_DENSITY)
         w_struct_range = np.linspace(0.1, 0.6, num=self.GRID_DENSITY)
@@ -322,7 +300,7 @@ class HeavyDutyBacktester:
         print(f"   📊 Simulating {len(combinations):,} scenarios...")
         
         final_results = []
-        batch_size = max(20, len(combinations) // (os.cpu_count() * 2)) # تقليل الدفعة لأن المحاكاة ثقيلة
+        batch_size = max(20, len(combinations) // (os.cpu_count() * 2))
         batches = [combinations[i:i+batch_size] for i in range(0, len(combinations), batch_size)]
         
         with concurrent.futures.ProcessPoolExecutor() as executor:
@@ -340,13 +318,10 @@ class HeavyDutyBacktester:
         best = sorted(final_results, key=lambda x: x['final_balance'], reverse=True)[0]
         
         print("\n" + "="*60)
-        print(f"🏆 CHAMPION TWIN REPORT ({self.BACKTEST_DAYS} Days):")
-        print(f"   💵 Initial:   ${self.INITIAL_CAPITAL:,.2f}")
-        print(f"   💰 Final:     ${best['final_balance']:,.2f}")
-        print(f"   🚀 Net PnL:   ${best['net_profit']:,.2f} ({best['roi_pct']:,.2f}%)")
-        print("-" * 60)
-        print(f"   📊 Trades: {best['total_trades']} (WR: {best['win_rate']:.1f}%)")
-        print(f"   📉 Max DD: ${best['max_drawdown']:,.2f}")
+        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("-" * 60)
         print(f"   ⚙️ Config: Titan={best['config']['w_titan']} | Struct={best['config']['w_struct']} | Thresh={best['config']['thresh']}")
         print("="*60)
@@ -354,7 +329,7 @@ class HeavyDutyBacktester:
         return best['config']
 
 async def run_strategic_optimization_task():
-    print("\n🧪 [STRATEGIC BACKTEST] Starting Twin Optimization...")
+    print("\n🧪 [STRATEGIC BACKTEST] Starting Logic Tree Optimization...")
     r2 = R2Service()
     dm = DataManager(None, None, r2)
     proc = MLProcessor(dm)