Update backtest_engine.py

backtest_engine.py

@@ -1,10 +1,9 @@
 # ============================================================
-# 🧪 backtest_engine.py (V51.0 - GEM-Architect: The Grid Master)
+# 🧪 backtest_engine.py (V51.1 - GEM-Architect: Bug Fix)
 # ============================================================
 # التحديثات:
-# 1. إضافة متغير GRID_DENSITY للتحكم بعدد التوليفات بسهولة.
-# 2. استخدام التوازي الكامل (Multiprocessing) بدون خسارة الدقة.
-# 3. دمج الفلتر الأولي (Scanner) كجزء من المعادلة.
+# 1. إصلاح خطأ 'numpy.ndarray object has no attribute values'.
+# 2. تحسين التعامل مع المصفوفات لضمان استقرار الباكتست.
 # ============================================================
 
 import asyncio
@@ -29,9 +28,8 @@ CACHE_DIR = "backtest_cache_grid"
 class MassiveOptimizer:
     def __init__(self, data_manager):
         self.dm = data_manager
-        # 🎛️ هذا هو "الزر" الذي طلبته
-        # 3 = سريع (تجربة) | 5 = متوسط (~3000) | 10 = دقيق (~100k) | 15 = جنوني
-        self.GRID_DENSITY = 10
+        # 3 = سريع (تجربة) | 5 = متوسط (~3000) | 10 = دقيق (~1000)
+        self.GRID_DENSITY = 10 
         
         self.TARGET_COINS = [
             'BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT', 'XRP/USDT',
@@ -40,36 +38,38 @@ class MassiveOptimizer:
         ]
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest Engine V51.0] Grid Density set to: {self.GRID_DENSITY}")
+        print(f"🧪 [Backtest Engine V51.1] Grid Density set to: {self.GRID_DENSITY}")
 
     async def fetch_deep_history(self):
         """تحميل البيانات وتجهيزها للمعالجة السريعة"""
         print(f"\n⏳ [Data] Pre-fetching history for Grid Search...")
         end_time_ms = int(time.time() * 1000)
-        start_time_ms = end_time_ms - (14 * 24 * 60 * 60 * 1000) # 14 يوم كافية للتحسين التكتيكي
+        start_time_ms = end_time_ms - (14 * 24 * 60 * 60 * 1000) 
         
         for sym in self.TARGET_COINS:
             safe_sym = sym.replace('/', '_')
             file_path = f"{CACHE_DIR}/{safe_sym}.pkl"
             
-            # إذا الملف موجود وحديث، لا نحمله مرة أخرى
             if os.path.exists(file_path): continue
 
             print(f"   ⬇️  Downloading {sym}...", end="", flush=True) 
             try:
-                # سحب شمعات 15 دقيقة (أسرع وأدق للفلتر الجديد)
                 candles = await self.dm.exchange.fetch_ohlcv(sym, '15m', since=start_time_ms, limit=1000)
                 if candles:
                     df = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
                     df = df.drop_duplicates(subset=['timestamp']).sort_values('timestamp')
                     for col in ['open', 'high', 'low', 'close', 'volume']: df[col] = df[col].astype(float)
                     
-                    # حساب المؤشرات مسبقاً (Vectorized Pre-calculation) لتسريع الباكتست مليون مرة
-                    # 1. Titan Proxy (Trend)
+                    # حساب المؤشرات مسبقاً (Vectorized)
                     df['ema50'] = df['close'].ewm(span=50).mean()
                     
-                    # 2. Scanner Proxies (Indicators)
-                    df['rsi'] = 100 - (100 / (1 + df['close'].diff().clip(lower=0).rolling(14).mean() / df['close'].diff().clip(upper=0).abs().rolling(14).mean()))
+                    # Scanner Proxies
+                    # RSI Manual Calculation for speed
+                    delta = df['close'].diff()
+                    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+                    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+                    rs = gain / loss
+                    df['rsi'] = 100 - (100 / (1 + rs))
                     
                     # BB
                     df['ma20'] = df['close'].rolling(20).mean()
@@ -90,7 +90,6 @@ class MassiveOptimizer:
     def _worker_evaluate_batch(combinations_batch, market_data_files):
         """
         يقوم هذا العامل بتقييم مجموعة من التوليفات (Batch) دفعة واحدة.
-        يعمل في Process منفصل تماماً = سرعة قصوى.
         """
         results = []
         
@@ -110,37 +109,33 @@ class MassiveOptimizer:
             
             for df in dfs:
                 # ---------------------------------------------------
-                # ⚡ Vectorized Signal Logic (The Core Strategy)
+                # ⚡ Vectorized Signal Logic
                 # ---------------------------------------------------
-                # 1. Titan Score (Simulated): Trend Alignment
-                # إذا السعر فوق المتوسط = 1.0، وإلا 0.2
+                # 1. Titan Score (Simulated)
                 titan_score = np.where(df['close'] > df['ema50'], 0.9, 0.3)
                 
-                # 2. Scanner Score (Simulated): RSI & BB
-                # RSI منخفض (فرصة) + اختراق BB
-                rsi_cond = np.where(df['rsi'] < 60, 1.0, 0.4) # نحب الـ RSI المنخفض للشراء
-                bb_cond = np.where(df['close'] > df['bb_upper'], 1.0, 0.0) # اختراق
+                # 2. Scanner Score (Simulated)
+                rsi_cond = np.where(df['rsi'] < 60, 1.0, 0.4) 
+                bb_cond = np.where(df['close'] > df['bb_upper'], 1.0, 0.0) 
                 
-                # دمج المؤشرات للكاشف
                 scanner_score = (rsi_cond * 0.7) + (bb_cond * 0.3)
                 
                 # 3. Final Weighted Score
                 final_score = (titan_score * w_titan) + (scanner_score * w_scanner)
-                # Normalize (تقريباً)
                 final_score = final_score / (w_titan + w_scanner)
                 
-                # 4. Generate Entries
+                # 4. Generate Entries (Boolean Numpy Array)
                 signals = (final_score > entry_thresh)
                 
                 # 5. Fast Loop for PnL
-                # (Looping over numpy array is fast enough here)
                 prices = df['close'].values
-                sigs = signals.values
+                
+                # 🔥 FIX: signals هو أصلاً numpy array، لا نحتاج .values
+                sigs = signals 
                 
                 in_pos = False
                 entry_p = 0.0
                 
-                # محاكاة سريعة
                 for i in range(len(prices)-1):
                     if not in_pos and sigs[i]:
                         in_pos = True
@@ -149,44 +144,36 @@ class MassiveOptimizer:
                         curr = prices[i]
                         pnl = (curr - entry_p) / entry_p
                         
-                        # TP/SL ثابت للسرعة (يمكن جعله متغير أيضاً)
-                        if pnl > 0.03 or pnl < -0.015: # TP 3%, SL 1.5%
+                        if pnl > 0.03 or pnl < -0.015: 
                             total_pnl += pnl
                             total_trades += 1
                             in_pos = False
                             
-            if total_trades > 5: # تصفية النتائج الضعيفة
+            if total_trades > 5: 
                 results.append({
                     'config': config,
                     'pnl': total_pnl,
                     'trades': total_trades,
-                    'score': total_pnl * np.log(total_trades) # معادلة تفضيل الربح مع عدد الصفقات المعقول
+                    'score': total_pnl * np.log(total_trades) 
                 })
                 
         return results
 
     # ==============================================================
-    # 🚀 The Grid Generator (10k -> 100k Scaler)
+    # 🚀 The Grid Generator
     # ==============================================================
     async def run_optimization(self):
-        # 1. التأكد من البيانات
         market_files = [os.path.join(CACHE_DIR, f) for f in os.listdir(CACHE_DIR) if f.endswith('.pkl')]
         if not market_files:
             await self.fetch_deep_history()
             market_files = [os.path.join(CACHE_DIR, f) for f in os.listdir(CACHE_DIR) if f.endswith('.pkl')]
         
-        # 2. توليد الشبكة (The Grid)
         print(f"🧩 [Optimizer] Generating Grid with Density={self.GRID_DENSITY}...")
         
-        # استخدام linspace لتوليد أرقام دقيقة بناءً على الكثافة
-        # كلما زاد self.GRID_DENSITY، زادت دقة الخطوات
         w_titan_range = np.linspace(0.2, 0.9, num=self.GRID_DENSITY)
         w_scanner_range = np.linspace(0.1, 0.8, num=self.GRID_DENSITY)
         thresh_range = np.linspace(0.50, 0.80, num=self.GRID_DENSITY)
         
-        # يمكن إضافة المزيد من المتغيرات هنا لزيادة العدد لـ 100,000+
-        # مثلاً: scanner_rsi_limit = np.linspace(30, 70, num=5)
-        
         combinations = []
         for wt, ws, th in itertools.product(w_titan_range, w_scanner_range, thresh_range):
             combinations.append({
@@ -198,12 +185,9 @@ class MassiveOptimizer:
         print(f"   📊 Total Unique Combinations: {len(combinations):,}")
         print(f"   🚀 Est. Processing Time: {len(combinations)/2000:.1f} minutes (on parallel cores)")
         
-        # 3. التشغيل المتوازي (Multiprocessing)
         start_time = time.time()
         final_results = []
         
-        # تقسيم التوليفات إلى دفعات (Batches)
-        # كل نواة (Core) ستأخذ دفعة
         batch_size = max(100, len(combinations) // (os.cpu_count() * 4))
         batches = [combinations[i:i + batch_size] for i in range(0, len(combinations), batch_size)]
         
@@ -222,12 +206,10 @@ class MassiveOptimizer:
         elapsed = time.time() - start_time
         print(f"✅ Optimization Finished in {elapsed:.2f}s")
         
-        # 4. اختيار الفائز
         if not final_results:
-            print("⚠️ No profitable strategies found.")
+            print("⚠️ No profitable strategies found (Check Data or lowered thresholds).")
             return None
             
-        # الترتيب حسب معادلة (الربح × ثبات الصفقات)
         best_result = sorted(final_results, key=lambda x: x['score'], reverse=True)[0]
         
         print("\n" + "="*60)
@@ -240,7 +222,7 @@ class MassiveOptimizer:
         return best_result['config']
 
 async def run_strategic_optimization_task():
-    print("\n🧪 [STRATEGIC BACKTEST V51.0] Starting Massive Grid Search...")
+    print("\n🧪 [STRATEGIC BACKTEST V51.1] Starting Massive Grid Search...")
     from r2 import R2Service
     r2 = R2Service()
     dm = DataManager(None, None, r2)
@@ -253,19 +235,14 @@ async def run_strategic_optimization_task():
         hub = AdaptiveHub(r2)
         await hub.initialize()
         
-        # تطبيق النتائج (Hot Reload)
-        regime = "RANGE" # أو اكتشافه
+        regime = "RANGE" 
         if regime in hub.strategies:
             print(f"💉 Injecting new DNA into {regime} Strategy...")
             st = hub.strategies[regime]
             
-            # تحديث الأوزان
             st.model_weights['titan'] = best_config['w_titan']
-            
-            # نفترض أننا نستخدم مفتاح 'patterns' لتخزين وزن الـ Scanner الجديد مؤقتاً
-            # أو نضيف حقلاً جديداً إذا عدلت الكلاس
+            # نستخدم 'patterns' لحفظ وزن الـ Scanner مؤقتاً أو كما اتفقنا سابقاً
             st.model_weights['patterns'] = best_config['w_scanner'] 
-            
             st.filters['l1_min_score'] = best_config['thresh'] * 100
             
             await hub._save_state_to_r2()