Update ml_engine/patterns.py

ml_engine/patterns.py

@@ -1,59 +1,185 @@
 # ml_engine/patterns.py
-# (V11.1 - XGBoost Multi-Timeframe Engine with Memory Management)
+# (V12.0 - Unified Pattern Engine - XGBoost & Pipeline Merged)
 
 import os
-import json
+import gc
+import logging
 import numpy as np
 import pandas as pd
+import pandas_ta as ta
 import xgboost as xgb
-import asyncio
-import io
-import logging
-import gc # استيراد garbage collector لتنظيف الذاكرة
+import warnings
 
-# استيراد الـ Pipeline الجديد
-try:
-    from .xgboost_pattern_v2 import transform_candles_for_ml
-except ImportError:
-    print("❌ [PatternEngineV11.1] فشل استيراد 'xgboost_pattern_v2'. تأكد من وجود الملف.")
-    transform_candles_for_ml = None
+# إخماد تحذيرات المكتبات للحفاظ على نظافة السجلات
+warnings.filterwarnings("ignore", category=UserWarning)
 
 # إعداد التسجيل
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - [PatternEngine] - %(message)s')
 logger = logging.getLogger(__name__)
 
+try:
+    from hurst import compute_Hc
+    HURST_AVAILABLE = True
+except ImportError:
+    HURST_AVAILABLE = False
+    logger.warning("⚠️ مكتبة 'hurst' غير موجودة. سيتم استخدام القيمة الافتراضية.")
+
+# ==============================================================================
+# 🛠️ INTERNAL HELPER FUNCTIONS (Previously in xgboost_pattern_v2)
+# ==============================================================================
+
+def _zv(x):
+    """حساب Z-Score الآمن (يتجنب القسمة على صفر)"""
+    with np.errstate(divide='ignore', invalid='ignore'):
+        x = np.asarray(x, dtype="float32")
+        m = np.nanmean(x)
+        s = np.nanstd(x) + 1e-9
+        x_norm = (x - m) / s
+        return np.nan_to_num(x_norm, nan=0.0).astype("float32")
+
+def _ema_np_safe(x, n):
+    """حساب المتوسط المتحرك الأسي (EMA) بشكل سريع باستخدام Numpy"""
+    x = np.asarray(x, dtype="float32")
+    k = 2.0 / (n + 1.0)
+    out = np.empty_like(x)
+    out[0] = x[0] if not np.isnan(x[0]) else 0.0
+    for i in range(1, len(x)):
+        val = x[i] if not np.isnan(x[i]) else out[i-1]
+        out[i] = out[i-1] + k * (val - out[i-1])
+    return out
+
+def _mc_simple_fast(closes_np: np.ndarray, target_profit=0.005):
+    """نسخة سريعة من محاكاة مونت كارلو للميزات الإحصائية"""
+    try:
+        if len(closes_np) < 30: return 0.5, 0.0
+        c = closes_np
+        cur = float(c[-1])
+        if cur <= 0: return 0.5, 0.0
+        
+        lr = np.diff(np.log1p(c))
+        lr = lr[np.isfinite(lr)]
+        if len(lr) < 20: return 0.5, 0.0
+        
+        mu = np.mean(lr)
+        sigma = np.std(lr)
+        if sigma < 1e-9: return 0.5, 0.0
+        
+        n_sims = 500
+        drift = (mu - 0.5 * sigma**2)
+        diffusion = sigma * np.random.standard_t(df=10, size=n_sims)
+        sim_prices = cur * np.exp(drift + diffusion)
+        
+        var95 = np.percentile(sim_prices, 5)
+        var95_pct = (cur - var95) / (cur + 1e-9)
+        prob_gain = np.mean(sim_prices >= cur * (1 + target_profit))
+        
+        return float(prob_gain), float(var95_pct)
+    except Exception:
+        return 0.5, 0.0
+
+def _transform_candles_for_ml(df_window: pd.DataFrame):
+    """
+    تحويل نافذة من الشموع (200 شمعة) إلى متجه ميزات جاهز لنموذج ML.
+    """
+    try:
+        if len(df_window) < 200:
+             return None
+        
+        df = df_window.iloc[-200:].copy()
+
+        o = df["open"].to_numpy(dtype="float32")
+        h = df["high"].to_numpy(dtype="float32")
+        l = df["low"].to_numpy(dtype="float32")
+        c = df["close"].to_numpy(dtype="float32")
+        v = df["volume"].to_numpy(dtype="float32")
+
+        # 1. Basic Features
+        base = np.stack([o, h, l, c, v], axis=1)
+        base_z = _zv(base)
+
+        # 2. Extra Features
+        lr = np.zeros_like(c); lr[1:] = np.diff(np.log1p(c))
+        rng = (h - l) / (c + 1e-9)
+        extra = np.stack([lr, rng], axis=1)
+        extra_z = _zv(extra)
+
+        # 3. Technical Indicators
+        ema9 = _ema_np_safe(c, 9)
+        ema21 = _ema_np_safe(c, 21)
+        ema50 = _ema_np_safe(c, 50)
+        ema200 = _ema_np_safe(c, 200)
+        slope21 = np.concatenate([[0.0], np.diff(ema21)])
+        slope50 = np.concatenate([[0.0], np.diff(ema50)])
+
+        try: rsi = ta.rsi(pd.Series(c), length=14).fillna(50).to_numpy(dtype="float32")
+        except: rsi = np.full_like(c, 50.0, dtype="float32")
+
+        try: 
+            macd_data = ta.macd(pd.Series(c), fast=12, slow=26, signal=9)
+            macd_line = macd_data.iloc[:, 0].fillna(0).to_numpy(dtype="float32")
+            macd_hist = macd_data.iloc[:, 2].fillna(0).to_numpy(dtype="float32")
+        except: 
+            macd_line = np.zeros_like(c); macd_hist = np.zeros_like(c)
+
+        try: atr = ta.atr(pd.Series(h), pd.Series(l), pd.Series(c), length=14).fillna(0).to_numpy(dtype="float32")
+        except: atr = np.zeros_like(c)
+
+        try:
+            bb = ta.bbands(pd.Series(c), length=20, std=2)
+            bb_p = ((c - bb.iloc[:, 0]) / (bb.iloc[:, 2] - bb.iloc[:, 0] + 1e-9)).fillna(0.5).to_numpy(dtype="float32")
+        except: bb_p = np.full_like(c, 0.5)
+
+        try: obv = ta.obv(pd.Series(c), pd.Series(v)).fillna(0).to_numpy(dtype="float32")
+        except: obv = np.zeros_like(c)
+
+        indicators = np.stack([ema9, ema21, ema50, ema200, slope21, slope50, rsi, macd_line, macd_hist, atr / (c + 1e-9), bb_p, obv], axis=1)
+        indicators_z = _zv(indicators)
+
+        # 4. Flatten
+        X_seq = np.concatenate([base_z, extra_z, indicators_z], axis=1)
+        X_seq_flat = X_seq.reshape(1, -1)
+
+        # 5. Static Features
+        try: mc_p, mc_var = _mc_simple_fast(c[-100:])
+        except: mc_p, mc_var = 0.5, 0.0
+        
+        hurst_val = 0.5
+        if HURST_AVAILABLE:
+             try: hurst_val = compute_Hc(c[-100:], kind='price', simplified=True)[0]
+             except: pass
+             
+        X_stat = np.array([[mc_p, mc_var, hurst_val]], dtype="float32")
+
+        # 6. Final Merge
+        X_final = np.concatenate([X_seq_flat, X_stat], axis=1)
+        X_final = np.nan_to_num(X_final, nan=0.0, posinf=0.0, neginf=0.0)
+
+        return X_final
+    except Exception:
+        return None
+
+# ==============================================================================
+# 🤖 CHART PATTERN ANALYZER CLASS
+# ==============================================================================
+
 class ChartPatternAnalyzer:
-    def __init__(self, r2_service=None, models_dir="ml_models/xgboost_pattern2"):
+    def __init__(self, models_dir="ml_models/xgboost_pattern2"):
         """
-        تهيئة محرك الأنماط الجديد المعتمد على XGBoost.
-        Args:
-            r2_service: خدمة R2 (اختياري).
-            models_dir: المجلد المحلي الذي يحتوي على نماذج JSON.
+        تهيئة محرك الأنماط الموحد (Unified Pattern Engine).
         """
-        self.r2_service = r2_service
         self.models_dir = models_dir
-        self.models = {} # لتخزين النماذج المحملة
-        
-        # الأطر الزمنية المدعومة وأوزان التصويت الجديدة (التركيز على القصير)
-        self.timeframe_weights = {
-            '15m': 0.40,
-            '1h': 0.30,
-            '5m': 0.20,
-            '4h': 0.10,
-            '1d': 0.00
-        }
+        self.models = {} 
+        self.timeframe_weights = {'15m': 0.40, '1h': 0.30, '5m': 0.20, '4h': 0.10, '1d': 0.00}
         self.supported_timeframes = list(self.timeframe_weights.keys())
         self.initialized = False
 
     async def initialize(self):
-        """
-        تحميل جميع نماذج XGBoost المتوفرة.
-        """
+        """تحميل نماذج XGBoost"""
         if self.initialized: return True
-
-        logger.info(f"بدء تحميل نماذج XGBoost من: {self.models_dir}...")
+        
+        logger.info(f"⚡ [PatternEngine] Loading models from {self.models_dir}...")
         if not os.path.exists(self.models_dir):
-             logger.error(f"❌ المجلد غير موجود: {self.models_dir}")
+             logger.error(f"❌ Models directory not found: {self.models_dir}")
              return False
 
         loaded_count = 0
@@ -65,27 +191,19 @@ class ChartPatternAnalyzer:
                     model.load_model(model_path)
                     self.models[tf] = model
                     loaded_count += 1
-                    logger.info(f"   ✅ تم تحميل نموذج {tf}")
                 except Exception as e:
-                    logger.error(f"   ❌ فشل تحميل نموذج {tf}: {e}")
-            else:
-                if self.timeframe_weights.get(tf, 0) > 0:
-                    logger.warning(f"   ⚠️ نموذج {tf} غير موجود (مطلوب بوزن {self.timeframe_weights[tf]}).")
-
+                    logger.error(f"   ❌ Failed to load {tf}: {e}")
+        
         if loaded_count > 0:
             self.initialized = True
-            logger.info(f"✅ تم تهيئة المحرك. النماذج المحملة: {loaded_count}/{len(self.supported_timeframes)}")
+            logger.info(f"✅ [PatternEngine] Initialized with {loaded_count} models.")
             return True
-        else:
-            logger.error("❌ لم يتم تحميل أي نموذج.")
-            return False
+        return False
 
     async def detect_chart_patterns(self, ohlcv_data: dict) -> dict:
-        """
-        تحليل الأنماط باستخدام النماذج المتاحة وتطبيق التصويت الموزون.
-        """
-        if not self.initialized or not transform_candles_for_ml:
-            return self._get_empty_result("Engine not initialized or pipeline missing")
+        """تحليل الأنماط لكافة الأطر الزمنية المتوفرة"""
+        if not self.initialized:
+            return self._get_empty_result("Not initialized")
 
         details = {}
         weighted_score_sum = 0.0
@@ -93,10 +211,12 @@ class ChartPatternAnalyzer:
 
         for tf, model in self.models.items():
             candles = ohlcv_data.get(tf)
+            # نحتاج 200 شمعة على الأقل للتحويل
             if candles and len(candles) >= 200:
                 try:
                     df = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-                    X_features = transform_candles_for_ml(df)
+                    # استخدام الدالة الداخلية المدمجة
+                    X_features = _transform_candles_for_ml(df)
                     
                     if X_features is not None:
                         dtest = xgb.DMatrix(X_features)
@@ -127,14 +247,11 @@ class ChartPatternAnalyzer:
         }
 
     def _get_empty_result(self, reason=""):
-        return {'pattern_detected': 'Neutral / Error', 'pattern_confidence': 0.0, 'details': {'error': reason}}
+        return {'pattern_detected': 'Neutral', 'pattern_confidence': 0.0, 'details': {'error': reason}}
 
-    # 🔴 دالة جديدة لتنظيف الذاكرة
     def clear_memory(self):
-        """تحرير النماذج من الذاكرة"""
+        """تنظيف الذاكرة"""
         self.models.clear()
         self.initialized = False
         gc.collect()
-        logger.info("🧹 [PatternEngine] تم تنظيف الذاكرة وتحرير النماذج.")
-
-print("✅ ML Module: Pattern Engine V11.1 (Memory Managed) loaded")
+        logger.info("🧹 [PatternEngine] Memory cleared.")