Update ml_engine/patterns.py

ml_engine/patterns.py

@@ -1,294 +1,251 @@
 # ml_engine/patterns.py
+# (V8 - النهائي: يستخدم نموذج ML (58%) القائم على المؤشرات)
+
 import pandas as pd
 import numpy as np
+import joblib
+import asyncio
+import io
+
+# (يجب التأكد من أن pandas-ta مثبت في بيئة Hugging Face)
+try:
+    import pandas_ta as ta
+except ImportError:
+    print("❌❌ [PatternEngineV8] مكتبة pandas_ta غير موجودة! هذا المحرك سيفشل.")
+    ta = None
 
 class ChartPatternAnalyzer:
-    def __init__(self):
-        self.pattern_cache = {}
     
-    async def detect_chart_patterns(self, ohlcv_data):
-        """اكتشاف الأنماط البيانية لجميع الأطر الزمنية"""
-        patterns = {
-            'pattern_detected': 'no_clear_pattern',
-            'pattern_confidence': 0,
-            'predicted_direction': 'neutral',
-            'timeframe_analysis': {},
-            'all_patterns': []
-        }
+    def __init__(self, r2_service=None, 
+                 model_key="lgbm_pattern_model_combined.pkl", 
+                 scaler_key="scaler_combined.pkl",
+                 window_size=60): # (سنستخدم window_size كحد أدنى للبيانات)
+        """
+        تهيئة المحرك بتحميل النماذج من R2.
+        """
+        self.window_size = window_size
+        self.model = None
+        self.scaler = None
+        # (هذه هي الفئات من ملف evaluation_results.txt، مرتبة)
+        self.class_names = ["Bearish Pattern", "Neutral / No Pattern", "Bullish Pattern"] # (IDs: -1, 0, 1)
+        self.r2_service = r2_service
+        self.model_key = model_key
+        self.scaler_key = scaler_key
         
-        try:
-            for timeframe, candles in ohlcv_data.items():
-                if candles and len(candles) >= 20:
-                    dataframe = self._create_dataframe(candles)
-                    timeframe_pattern = await self._analyze_timeframe_patterns(dataframe, timeframe)
-                    patterns['timeframe_analysis'][timeframe] = timeframe_pattern
-                    patterns['all_patterns'].append(timeframe_pattern)
-                    
-                    if timeframe_pattern['confidence'] > patterns['pattern_confidence']:
-                        patterns.update({
-                            'pattern_detected': timeframe_pattern['pattern'],
-                            'pattern_confidence': timeframe_pattern['confidence'],
-                            'predicted_direction': timeframe_pattern['direction']
-                        })
+        # (هذه هي "الوصفة" الدقيقة من X_test_combined.csv)
+        self.feature_names = [
+            'RSI_14', 'MACD_12_26_9', 'MACDh_12_26_9', 'MACDs_12_26_9', 'SMA_20', 
+            'EMA_20', 'BBL_5_2.0_2.0', 'BBM_5_2.0_2.0', 'BBU_5_2.0_2.0', 'BBB_5_2.0_2.0', 
+            'BBP_5_2.0_2.0', 'STOCHk_14_3_3', 'STOCHd_14_3_3', 'STOCHh_14_3_3', 
+            'ADX_14', 'ADXR_14_2', 'DMP_14', 'DMN_14', 'VWAP_D', 'MIDPOINT_14', 
+            'TEMA_20', 'OBV', 'AD', 'ATRr_14', 'DPO_20', 'KVO_34_55_13', 
+            'KVOs_34_55_13', 'CMO_14', 'ROC_10', 'WILLR_14'
+        ]
+        # (إزالة الأعمدة الأساسية التي لا تُستخدم كخصائص)
+        self.base_cols = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
+        # (خصائص المؤشرات فقط)
+        self.indicator_features = [col for col in self.feature_names if col not in self.base_cols]
+
+        if not self.r2_service:
+            print("⚠️ [PatternEngineV8] R2Service غير متوفر. يجب التحميل يدوياً.")
+
+    async def initialize(self):
+        """
+        يجب استدعاؤها من app.py أو data_manager لتحميل النماذج.
+        """
+        if self.model and self.scaler:
+            return True # (تم التحميل مسبقاً)
             
-            return patterns
+        if not self.r2_service:
+            print("❌ [PatternEngineV8] لا يمكن التهيئة بدون R2 Service.")
+            return False
             
-        except Exception as e:
-            print(f"❌ خطأ في اكتشاف الأنماط: {e}")
-            return patterns
-    
-    def _create_dataframe(self, candles):
-        """إنشاء DataFrame من بيانات الشموع"""
         try:
-            df = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-            df[['open', 'high', 'low', 'close', 'volume']] = df[['open', 'high', 'low', 'close', 'volume']].astype(float)
-            return df
+            # 1. تحميل النموذج
+            print(f"   > [PatternEngineV8] تحميل {self.model_key} من R2...")
+            model_obj = self.r2_service.s3_client.get_object(Bucket=self.r2_service.BUCKET_NAME, Key=self.model_key)
+            # (استخدام io.BytesIO لقراءة الجسم)
+            model_bytes = io.BytesIO(model_obj['Body'].read())
+            self.model = joblib.load(model_bytes)
+            
+            # 2. تحميل المقياس (Scaler)
+            print(f"   > [PatternEngineV8] تحميل {self.scaler_key} من R2...")
+            scaler_obj = self.r2_service.s3_client.get_object(Bucket=self.r2_service.BUCKET_NAME, Key=self.scaler_key)
+            scaler_bytes = io.BytesIO(scaler_obj['Body'].read())
+            self.scaler = joblib.load(scaler_bytes)
+
+            print("✅ [PatternEngineV8] تم تحميل النموذج (58%) والمقياس بنجاح.")
+            # (التحقق من الخصائص)
+            if hasattr(self.scaler, 'feature_names_in_'):
+                 print(f"   > يتوقع المقياس {len(self.scaler.feature_names_in_)} خاصية.")
+            
+            return True
+            
         except Exception as e:
-            print(f"❌ خطأ في إنشاء DataFrame: {e}")
-            return pd.DataFrame()
-    
-    async def _analyze_timeframe_patterns(self, dataframe, timeframe):
-        """تحليل الأنماط لإطار زمني محدد"""
-        pattern_info = {
-            'pattern': 'no_clear_pattern',
-            'confidence': 0,
-            'direction': 'neutral',
-            'timeframe': timeframe,
+            print(f"❌❌ [PatternEngineV8] فشل فادح في تحميل النماذج من R2: {e}")
+            self.model = None
+            self.scaler = None
+            return False
+
+    def _extract_features(self, df_window: pd.DataFrame) -> pd.DataFrame:
+        """
+        (الوصفة V8)
+        حساب الـ 30 مؤشراً كما في X_test_combined.csv
+        """
+        if not ta:
+            raise ImportError("مكتبة pandas-ta غير مثبتة.")
+            
+        # (استراتيجية مخصصة لحساب كل شيء نحتاجه)
+        custom_strategy = ta.Strategy(
+            name="V8_Features",
+            description="Calculates the 30 indicators from X_test_combined.csv",
+            ta=[
+                {"kind": "rsi", "length": 14},
+                {"kind": "macd", "fast": 12, "slow": 26, "signal": 9},
+                {"kind": "sma", "length": 20},
+                {"kind": "ema", "length": 20},
+                {"kind": "bbands", "length": 5, "std": 2.0},
+                {"kind": "stoch", "k": 14, "d": 3, "smooth_k": 3},
+                {"kind": "adx", "length": 14, "adxr": 2}, # (ADX, ADXR, DMP, DMN)
+                {"kind": "vwap"}, # (VWAP_D)
+                {"kind": "midpoint", "length": 14},
+                {"kind": "tema", "length": 20},
+                {"kind": "obv"},
+                {"kind": "ad"},
+                {"kind": "atr", "percent": True, "length": 14}, # (ATRr_14)
+                {"kind": "dpo", "length": 20},
+                {"kind": "kvo", "fast": 34, "slow": 55, "signal": 13}, # (KVO_34_55_13, KVOs_34_55_13)
+                {"kind": "cmo", "length": 14},
+                {"kind": "roc", "length": 10},
+                {"kind": "willr", "length": 14},
+            ]
+        )
+        
+        # تطبيق الاستراتيجية على DataFrame
+        df_window.ta.strategy(custom_strategy)
+        
+        # (pandas-ta قد يضيف '_2.0' إلى أسماء bbands)
+        # (سنقوم بإعادة تسمية الأعمدة لتطابق X_test_combined.csv بالضبط)
+        rename_map = {
+            'RSI_14': 'RSI_14', 'MACD_12_26_9': 'MACD_12_26_9', 'MACDh_12_26_9': 'MACDh_12_26_9', 
+            'MACDs_12_26_9': 'MACDs_12_26_9', 'SMA_20': 'SMA_20', 'EMA_20': 'EMA_20',
+            'BBL_5_2.0': 'BBL_5_2.0_2.0', 'BBM_5_2.0': 'BBM_5_2.0_2.0', 'BBU_5_2.0': 'BBU_5_2.0_2.0', 
+            'BBB_5_2.0': 'BBB_5_2.0_2.0', 'BBP_5_2.0': 'BBP_5_2.0_2.0',
+            'STOCHk_14_3_3': 'STOCHk_14_3_3', 'STOCHd_14_3_3': 'STOCHd_14_3_3', 'STOCHh_14_3_3': 'STOCHh_14_3_3',
+            'ADX_14': 'ADX_14', 'ADXR_14_2': 'ADXR_14_2', 'DMP_14': 'DMP_14', 'DMN_14': 'DMN_14', 
+            'VWAP_D': 'VWAP_D', 'MIDPOINT_14': 'MIDPOINT_14', 'TEMA_20': 'TEMA_20', 'OBV': 'OBV', 
+            'AD': 'AD', 'ATRr_14': 'ATRr_14', 'DPO_20': 'DPO_20', 'KVO_34_55_13': 'KVO_34_55_13',
+            'KVOs_34_55_13': 'KVOs_34_55_13', 'CMO_14': 'CMO_14', 'ROC_10': 'ROC_10', 'WILLR_14': 'WILLR_14'
+        }
+        
+        # (إعادة التسمية الآمنة)
+        df_window.rename(columns=rename_map, inplace=True)
+
+        # (العودة بالصف الأخير فقط)
+        last_features = df_window.iloc[-1:]
+        
+        # (ملء أي قيم NaN بـ 0 أو القيمة السابقة)
+        last_features.fillna(method='ffill', inplace=True)
+        last_features.fillna(0, inplace=True)
+        
+        # (التأكد من أننا نرسل فقط الخصائص الـ 30 المطلوبة)
+        # (قد تفشل بعض المؤشرات، لذا سننشئ DataFrame فارغاً ونملأ ما هو موجود)
+        final_features = pd.DataFrame(columns=self.indicator_features)
+        
+        # (إضافة البيانات الموجودة فقط)
+        for col in self.indicator_features:
+            if col in last_features:
+                final_features[col] = last_features[col]
+            else:
+                final_features[col] = 0 # (الافتراضي 0 إذا فشل المؤشر)
+
+        return final_features
+
+    async def detect_chart_patterns(self, ohlcv_data: dict) -> dict:
+        """
+        (الدالة الرئيسية التي يستدعيها النظام)
+        تستخدم نموذج 58% للتنبؤ بالنمط.
+        """
+        best_match = {
+            'pattern_detected': 'no_clear_pattern',
+            'pattern_confidence': 0,
+            'predicted_direction': 'neutral',
+            'timeframe': None,
             'details': {}
         }
         
-        try:
-            if dataframe is None or dataframe.empty or len(dataframe) < 20:
-                return pattern_info
-            
-            closes = dataframe['close'].values
-            highs = dataframe['high'].values
-            lows = dataframe['low'].values
-            current_price = closes[-1]
-            
-            patterns_detected = []
-            
-            double_pattern = self._detect_double_pattern(highs, lows, closes)
-            if double_pattern['detected']:
-                patterns_detected.append(double_pattern)
-            
-            breakout_pattern = self._detect_breakout_pattern(highs, lows, closes)
-            if breakout_pattern['detected']:
-                patterns_detected.append(breakout_pattern)
-            
-            trend_pattern = self._detect_trend_pattern(dataframe)
-            if trend_pattern['detected']:
-                patterns_detected.append(trend_pattern)
-            
-            support_resistance_pattern = self._detect_support_resistance(highs, lows, closes)
-            if support_resistance_pattern['detected']:
-                patterns_detected.append(support_resistance_pattern)
-            
-            if patterns_detected:
-                best_pattern = max(patterns_detected, key=lambda x: x['confidence'])
-                pattern_info.update({
-                    'pattern': best_pattern['pattern'],
-                    'confidence': best_pattern['confidence'],
-                    'direction': best_pattern.get('direction', 'neutral'),
-                    'details': best_pattern.get('details', {})
-                })
-            
-            return pattern_info
-            
-        except Exception as e:
-            print(f"❌ خطأ في تحليل الأنماط للإطار {timeframe}: {e}")
-            return pattern_info
-    
-    def _detect_double_pattern(self, highs, lows, closes):
-        """كشف نمط القمة المزدوجة أو القاع المزدوج"""
-        try:
-            if len(highs) < 15:
-                return {'detected': False}
-            
-            recent_highs = highs[-15:]
-            recent_lows = lows[-15:]
+        if not self.model or not self.scaler:
+            if not hasattr(self, '_init_warned'):
+                print("⚠️ [PatternEngineV8] النموذج/المقياس غير محمل. يجب استدعاء .initialize() أولاً.")
+                self._init_warned = True
+            return best_match
             
-            high_indices = np.argsort(recent_highs)[-2:]
-            high_indices.sort()
-            
-            low_indices = np.argsort(recent_lows)[:2]
-            low_indices.sort()
-            
-            double_top = False
-            double_bottom = False
-            
-            if len(high_indices) == 2:
-                high1 = recent_highs[high_indices[0]]
-                high2 = recent_highs[high_indices[1]]
-                time_diff = high_indices[1] - high_indices[0]
-                
-                if (abs(high1 - high2) / high1 < 0.02 and
-                    time_diff >= 3 and time_diff <= 10 and
-                    closes[-1] < min(high1, high2)):
-                    double_top = True
-            
-            if len(low_indices) == 2:
-                low1 = recent_lows[low_indices[0]]
-                low2 = recent_lows[low_indices[1]]
-                time_diff = low_indices[1] - low_indices[0]
-                
-                if (abs(low1 - low2) / low1 < 0.02 and
-                    time_diff >= 3 and time_diff <= 10 and
-                    closes[-1] > max(low1, low2)):
-                    double_bottom = True
-            
-            if double_top:
-                return {
-                    'detected': True,
-                    'pattern': 'Double Top',
-                    'confidence': 0.75,
-                    'direction': 'down',
-                    'details': {
-                        'resistance_level': np.mean([high1, high2]),
-                        'breakdown_level': min(lows[-5:])
-                    }
-                }
-            elif double_bottom:
-                return {
-                    'detected': True,
-                    'pattern': 'Double Bottom', 
-                    'confidence': 0.75,
-                    'direction': 'up',
-                    'details': {
-                        'support_level': np.mean([low1, low2]),
-                        'breakout_level': max(highs[-5:])
-                    }
-                }
-            
-            return {'detected': False}
-            
-        except Exception as e:
-            return {'detected': False}
-    
-    def _detect_breakout_pattern(self, highs, lows, closes):
-        """كشف نمط الاختراق"""
-        try:
-            if len(highs) < 25:
-                return {'detected': False}
-            
-            current_price = closes[-1]
-            
-            resistance = np.max(highs[-25:-5])
-            support = np.min(lows[-25:-5])
-            
-            if current_price > resistance * 1.01:
-                return {
-                    'detected': True,
-                    'pattern': 'Breakout Up',
-                    'confidence': 0.8,
-                    'direction': 'up',
-                    'details': {
-                        'breakout_level': resistance,
-                        'target_level': resistance * 1.05
-                    }
-                }
-            elif current_price < support * 0.99:
-                return {
-                    'detected': True,
-                    'pattern': 'Breakout Down',
-                    'confidence': 0.8,
-                    'direction': 'down',
-                    'details': {
-                        'breakdown_level': support,
-                        'target_level': support * 0.95
-                    }
-                }
-            
-            return {'detected': False}
-            
-        except Exception as e:
-            return {'detected': False}
-    
-    def _detect_trend_pattern(self, dataframe):
-        """كشف نمط الاتجاه"""
-        try:
-            if dataframe is None or dataframe.empty or len(dataframe) < 20:
-                return {'detected': False}
-            
-            closes = dataframe['close'].values
-            
-            ma_short = np.mean(closes[-5:])
-            ma_medium = np.mean(closes[-13:])
-            ma_long = np.mean(closes[-21:])
-            
-            if ma_short > ma_medium > ma_long and closes[-1] > ma_short:
-                trend_strength = (ma_short - ma_long) / ma_long
-                confidence = min(0.3 + trend_strength * 10, 0.8)
-                return {
-                    'detected': True,
-                    'pattern': 'Uptrend',
-                    'confidence': confidence,
-                    'direction': 'up',
-                    'details': {
-                        'trend_strength': trend_strength,
-                        'support_level': ma_medium
-                    }
-                }
-            elif ma_short < ma_medium < ma_long and closes[-1] < ma_short:
-                trend_strength = (ma_long - ma_short) / ma_long
-                confidence = min(0.3 + trend_strength * 10, 0.8)
-                return {
-                    'detected': True,
-                    'pattern': 'Downtrend',
-                    'confidence': confidence,
-                    'direction': 'down',
-                    'details': {
-                        'trend_strength': trend_strength,
-                        'resistance_level': ma_medium
-                    }
-                }
-            
-            return {'detected': False}
-            
-        except Exception as e:
-            return {'detected': False}
-    
-    def _detect_support_resistance(self, highs, lows, closes):
-        """كشف مستويات الدعم والمقاومة"""
-        try:
-            if len(highs) < 20:
-                return {'detected': False}
-            
-            current_price = closes[-1]
-            
-            resistance_level = np.max(highs[-20:])
-            support_level = np.min(lows[-20:])
-            
-            position = (current_price - support_level) / (resistance_level - support_level)
-            
-            if position < 0.2:
-                return {
-                    'detected': True,
-                    'pattern': 'Near Support',
-                    'confidence': 0.6,
-                    'direction': 'up',
-                    'details': {
-                        'support_level': support_level,
-                        'resistance_level': resistance_level,
-                        'position': position
-                    }
-                }
-            elif position > 0.8:
-                return {
-                    'detected': True,
-                    'pattern': 'Near Resistance',
-                    'confidence': 0.6,
-                    'direction': 'down',
-                    'details': {
-                        'support_level': support_level,
-                        'resistance_level': resistance_level,
-                        'position': position
-                    }
-                }
-            
-            return {'detected': False}
+        all_results = []
+
+        for timeframe, candles in ohlcv_data.items():
+            # (نحتاج إلى بيانات كافية لحساب المؤشرات، 200 شمعة هي الأفضل)
+            if len(candles) >= max(self.window_size, 200):
+                try:
+                    # (استخدام آخر 200 شمعة للحسابات)
+                    window_candles = candles[-200:]
+                    df_window = pd.DataFrame(window_candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+                    
+                    # (يجب أن يكون الفهرس DatetimeIndex لـ VWAP)
+                    df_window['timestamp'] = pd.to_datetime(df_window['timestamp'], unit='ms')
+                    df_window.set_index('timestamp', inplace=True)
+                    
+                    # 1. استخراج الخصائص (الوصفة V8)
+                    features_df = self._extract_features(df_window)
+                    
+                    if features_df is None or features_df.empty:
+                        continue 
+                        
+                    # 2. تطبيع الخصائص (Scaler)
+                    # (يجب التأكد من أن الأعمدة بنفس الترتيب)
+                    features_df = features_df[self.scaler.feature_names_in_]
+                    features_scaled = self.scaler.transform(features_df)
+                    
+                    # 3. التنبؤ بالاحتماليات (Probabilities)
+                    probabilities = self.model.predict_proba(features_scaled)[0]
+                    
+                    # (تقرير التقييم V5 يظهر أن الفئات هي -1, 0, 1)
+                    # (نفترض أن class_names لدينا مرتب: [Bearish (-1), Neutral (0), Bullish (1)])
+                    
+                    # (تعديل: نفترض أن مخرجات النموذج هي 0, 1, 2)
+                    # (Class 0 = -1 (Bearish))
+                    # (Class 1 = 0 (Neutral))
+                    # (Class 2 = 1 (Bullish))
+                    # (هذا يعتمد على كيفية تدريب النموذج، لكننا سنفترض أننا بحاجة لإعادة التعيين)
+                    
+                    # (تحديث: سنستخدم أسماء الفئات من النموذج مباشرة)
+                    best_class_index = np.argmax(probabilities)
+                    confidence = probabilities[best_class_index]
+                    pattern_name = self.class_names[best_class_index] # (e.g., "Bullish Pattern")
+                    
+                    if pattern_name != "Neutral / No Pattern" and confidence > 0.5:
+                        all_results.append({
+                            'pattern': pattern_name,
+                            'confidence': float(confidence),
+                            'timeframe': timeframe
+                        })
+                        
+                except Exception as e:
+                    print(f"❌ [PatternEngineV8] فشل التنبؤ لـ {timeframe}: {e}")
+                    
+        # 4. اختيار أفضل نمط من *جميع* الأطر الزمنية
+        if all_results:
+            best_result = max(all_results, key=lambda x: x['confidence'])
             
-        except Exception as e:
-            return {'detected': False}
+            direction = 'neutral'
+            if "Bullish" in best_result['pattern']: direction = 'up'
+            elif "Bearish" in best_result['pattern']: direction = 'down'
+
+            best_match['pattern_detected'] = best_result['pattern']
+            best_match['pattern_confidence'] = best_result['confidence']
+            best_match['timeframe'] = best_result['timeframe']
+            best_match['predicted_direction'] = direction
+            best_match['details'] = {'ml_confidence': best_result['confidence']}
+
+        return best_match
 
-print("✅ ML Module: Chart Pattern Analyzer loaded")
+print("✅ ML Module: Pattern Engine V8 (Indicator-Based ML) loaded")