Update ml_engine/monte_carlo.py

ml_engine/monte_carlo.py

@@ -1,7 +1,7 @@
 # ml_engine/monte_carlo.py
-# (V11.5 - GEM-Architect: Graded Sensitivity Edition)
-# - Tier 1: Light Check -> Now returns graded scores (-0.10 to +0.10) based on Z-Score.
-# - Tier 2: Advanced Simulation -> Remains high precision GBM.
+# (V11.7 - GEM-Architect: Fixed Light MC Sensitivity)
+# - Tier 1: Light Check -> Continuous Score (No Dead Zones).
+# - Tier 2: Advanced Simulation -> Standard GBM Logic (Top 10 Only).
 
 import numpy as np
 import pandas as pd
@@ -13,37 +13,37 @@ class MonteCarloEngine:
     """
     Advanced Stochastic Simulation Engine.
     Provides two tiers of analysis:
-    1. Light Check: For rapid screening (Graded Output).
-    2. Advanced Simulation: For deep risk assessment (GBM).
+    1. Light Check: For rapid screening (All 150 Coins) -> Returns sensitive micro-scores.
+    2. Advanced Simulation: For deep risk assessment (Top 10 Only).
     """
     
     def __init__(self):
-        print("✅ [MonteCarlo V11.5] Hybrid Engine Loaded (Graded Sensitivity).")
+        print("✅ [MonteCarlo V11.7] Hybrid Engine Loaded (Corrected Sensitivity).")
 
     # ==============================================================================
-    # ⚡ TIER 1: Light Check (Graded Z-Score)
+    # ⚡ TIER 1: Light Check (Applied to ALL 150 Coins)
     # ==============================================================================
     def run_light_check(self, prices: List[float]) -> float:
         """
-        فحص سريع جداً (Micro-Simulation) مع تدرج في النتيجة.
-        بدلاً من 0 أو 0.1، يعطي درجة تعكس قوة الاتجاه (صعوداً أو هبوطاً).
+        فحص سريع يطبق على الـ 150 عملة.
+        
+        [التعديل المطلوب]:
+        إلغاء المنطقة الميتة تماماً.
+        أي انحراف عن 0.50 يعطي نتيجة فوراً.
         
         Logic:
-        - Prob > 60%       -> +0.10 (Strong Bull)
-        - 55% < Prob <= 60% -> +0.05 (Weak Bull)
-        - 45% <= Prob <= 55% ->  0.00 (Neutral / Noise)
-        - 40% <= Prob < 45% -> -0.05 (Weak Bear)
-        - Prob < 40%       -> -0.10 (Strong Bear)
-
-        Returns:
-            float: Score between -0.10 and +0.10
+        - Prob > 0.55 -> +0.10
+        - Prob > 0.52 -> +0.07
+        - Prob > 0.50 -> +0.03 (أي نبض إيجابي يعطي درجة)
+        - Prob < 0.50 -> -0.03 (أي نبض سلبي يخصم درجة)
+        - Prob < 0.48 -> -0.07
+        - Prob < 0.45 -> -0.10
         """
         try:
-            # 1. تنظيف البيانات والتحقق منها
-            if not prices or len(prices) < 30: 
+            # 1. تنظيف البيانات
+            if not prices or len(prices) < 20: 
                 return 0.0
             
-            # [CRITICAL] تحويل القائمة إلى float صراحة لتجنب مشاكل النصوص
             clean_prices = []
             for p in prices:
                 try:
@@ -51,63 +51,59 @@ class MonteCarloEngine:
                     if val > 0: clean_prices.append(val)
                 except: continue
 
-            if len(clean_prices) < 30: return 0.0
+            if len(clean_prices) < 20: return 0.0
 
-            # 2. الحساب السريع (Vectorized)
+            # 2. الحساب الإحصائي (Z-Score)
             price_arr = np.array(clean_prices, dtype=np.float64)
-            
-            # ln(P_t / P_{t-1})
             log_returns = np.diff(np.log(price_arr))
             
             mu = np.mean(log_returns)
             sigma = np.std(log_returns)
             
-            # إذا كان الانحراف صفراً (سعر ثابت)، العائد صفر
             if sigma == 0: return 0.0
             
-            # حساب احتمالية أن يكون العائد القادم > 0
-            # Z-Score Approach: P(X > 0)
+            # احتمالية الصعود P(X > 0)
             prob_up = norm.cdf(mu / sigma)
             
-            # [LOGIC UPDATE] السلم المتدرج (Graded Ladder)
-            score = 0.0
+            # 3. سلم الحساسية (بدون أصفار - No Dead Zone)
+            # الهدف: التخلص من الـ 0.00 في الجدول
             
-            if prob_up >= 0.60:
-                score = 0.10
-            elif prob_up >= 0.55:
-                score = 0.05
-            elif prob_up >= 0.45:
-                score = 0.00  # منطقة الحياد والضوضاء
-            elif prob_up >= 0.40:
-                score = -0.05
-            else:
-                score = -0.10 # احتمالية الصعود ضعيفة جداً (< 40%)
-            
-            # [DEBUG LOG] طباعة الاحتمالية للمراقبة (اختياري)
-            # print(f"   🎲 [Light MC] Prob: {prob_up:.2f} -> Score: {score}")
+            # --- المنطقة الإيجابية ---
+            if prob_up >= 0.55:
+                return 0.10   # صعود قوي
+            elif prob_up >= 0.52:
+                return 0.07   # صعود متوسط
+            elif prob_up > 0.5001: 
+                return 0.03   # صعود طفيف جداً (لكي لا يكون صفر)
 
-            return score
+            # --- المنطقة السلبية ---
+            elif prob_up <= 0.45:
+                return -0.10  # هبوط قوي
+            elif prob_up <= 0.48:
+                return -0.07  # هبوط متوسط
+            elif prob_up < 0.4999:
+                return -0.03  # هبوط طفيف جداً (لكي لا يكون صفر)
+            
+            # الحالة النادرة جداً (التعادل التام)
+            return 0.00
             
         except Exception as e:
             # print(f"⚠️ [Light MC] Error: {e}")
             return 0.0
 
     # ==============================================================================
-    # 🧠 TIER 2: Advanced Simulation (For Top 10 Oracle Candidates)
+    # 🧠 TIER 2: Advanced Simulation (Applied to Top 10 Only)
     # ==============================================================================
     def run_advanced_simulation(self, prices: List[float], num_simulations=5000, time_horizon=24) -> float:
         """
-        المحاكاة المتقدمة الكاملة (Geometric Brownian Motion).
+        المحاكاة المتقدمة للعملات المختارة فقط.
+        تعتمد منطق المخاطرة والعائد (Sharpe/VaR).
         """
         try:
-            if not prices or len(prices) < 50: 
-                return 0.0
-            
-            # تنظيف البيانات
+            if not prices or len(prices) < 50: return 0.0
             clean_prices = [float(p) for p in prices if p is not None]
             if len(clean_prices) < 50: return 0.0
 
-            # 1. إحصائيات
             closing_prices = np.array(clean_prices, dtype=np.float64)
             log_returns = np.diff(np.log(closing_prices))
             
@@ -115,46 +111,35 @@ class MonteCarloEngine:
             daily_volatility = np.std(log_returns)
             last_price = closing_prices[-1]
             
-            # 2. المحاكاة (GBM)
+            # GBM Simulation
             random_shocks = np.random.normal(0, 1, (num_simulations, time_horizon))
             drift = (mean_daily_return - 0.5 * daily_volatility ** 2)
             diffusion = daily_volatility * random_shocks
-            
             daily_returns_sim = np.exp(drift + diffusion)
             
-            # مسارات الأسعار
             price_paths = np.zeros_like(daily_returns_sim)
             price_paths[:, 0] = last_price * daily_returns_sim[:, 0]
-            
             for t in range(1, time_horizon):
                 price_paths[:, t] = price_paths[:, t-1] * daily_returns_sim[:, t]
             
-            # 3. النتائج
             final_prices = price_paths[:, -1]
             
-            # المقاييس
+            # Metrics
             threshold = last_price * 1.002 
             prob_profit = np.mean(final_prices > threshold)
             var_95 = np.percentile(final_prices, 5)
             drawdown_risk = (var_95 - last_price) / last_price
             expected_return = (np.mean(final_prices) - last_price) / last_price
             
-            # print(f"   🎲 [Adv MC] ProfitProb:{prob_profit:.2f} | Risk:{drawdown_risk:.2%} | ExpRet:{expected_return:.2%}")
-
-            # 4. التنقيط (محدث ليكون أكثر توازناً)
+            # Scoring (Standard Logic for Advanced)
             mc_score = 0.0
-            
-            # المكافآت
             if prob_profit > 0.55: mc_score += 0.05
             if prob_profit > 0.65: mc_score += 0.05
             if expected_return > 0.005: mc_score += 0.05
-            
-            # العقوبات
             if drawdown_risk < -0.07: mc_score -= 0.05
             if drawdown_risk < -0.10: mc_score -= 0.05 
                 
             return round(max(-0.10, min(0.20, mc_score)), 2)
 
         except Exception as e:
-            print(f"⚠️ [MonteCarlo] Advanced failed: {e}")
             return 0.0