Update ml_engine/oracle_engine.py

ml_engine/oracle_engine.py

@@ -10,14 +10,16 @@ from typing import Dict, Any, List, Optional
 # --- [ إعدادات النظام ] ---
 warnings.filterwarnings('ignore', category=FutureWarning)
 
-# العتبة الذهبية المستخرجة من اختباراتك (عند 0.65 الدقة ~77%)
+# العتبة الذهبية (للدخول شراء فقط)
 CONFIDENCE_THRESHOLD = 0.65 
 
 class OracleEngine:
     def __init__(self, model_dir: str = "ml_models/Unified_Models_V1"):
         """
-        Oracle V3.0: The Strategic Brain
-        يدمج نماذج: Direction (Binary), Target (Multiclass), Strength (Regression)
+        Oracle V4.0: Spot-Only Strategic Brain
+        - يحلل الاتجاه (صعود/هبوط).
+        - يمرر فقط فرص الصعود (Long) للتنفيذ.
+        - يحجب فرص الهبوط (Short) ويعتبرها "مخاطرة" (WAIT).
         """
         self.model_dir = model_dir
         self.model_direction = None
@@ -26,23 +28,20 @@ class OracleEngine:
         
         self.feature_cols = []
         self.initialized = False
-        print("🧠 [Oracle V3] Engine Instance Created.")
+        print("🧠 [Oracle V4 - Spot] Engine Instance Created.")
 
     async def initialize(self):
         """تحميل النماذج وخريطة الميزات"""
         if self.initialized: return True
             
-        print(f"🧠 [Oracle V3] Loading artifacts from {self.model_dir}...")
+        print(f"🧠 [Oracle V4] Loading artifacts from {self.model_dir}...")
         try:
-            # 1. تحميل خريطة الميزات (لضمان ترتيب الأعمدة)
             feat_path = os.path.join(self.model_dir, "feature_columns.pkl")
             if not os.path.exists(feat_path):
                 print(f"❌ [Oracle] Feature map missing: {feat_path}")
                 return False
             self.feature_cols = joblib.load(feat_path)
 
-            # 2. تحميل النماذج
-            # ملاحظة: تأكد من نقل ملفات .txt من Drive إلى مجلد المشروع المحلي
             dir_path = os.path.join(self.model_dir, "lgbm_direction.txt")
             tgt_path = os.path.join(self.model_dir, "lgbm_target_class.txt")
             str_path = os.path.join(self.model_dir, "lgbm_strength.txt")
@@ -50,7 +49,6 @@ class OracleEngine:
             if os.path.exists(dir_path):
                 self.model_direction = lgb.Booster(model_file=dir_path)
             else:
-                print("❌ [Oracle] Direction Model missing!")
                 return False
 
             if os.path.exists(tgt_path):
@@ -60,7 +58,7 @@ class OracleEngine:
                 self.model_strength = lgb.Booster(model_file=str_path)
 
             self.initialized = True
-            print(f"✅ [Oracle V3] Ready. Threshold: {CONFIDENCE_THRESHOLD}")
+            print(f"✅ [Oracle V4] Ready (Spot Mode). Threshold: {CONFIDENCE_THRESHOLD}")
             return True
 
         except Exception as e:
@@ -68,46 +66,33 @@ class OracleEngine:
             return False
 
     # ==========================================================================
-    # 🛠️ هندسة الميزات (يجب أن تطابق DataFactory حرفياً)
+    # 🛠️ هندسة الميزات (مطابقة لـ DataFactory)
     # ==========================================================================
-    
     def _calculate_snapshot_features(self, df, tf_prefix):
-        """حساب المؤشرات الفنية المضغوطة"""
         df = df.copy()
-        # تحويلات لضمان الدقة
         df['close'] = df['close'].astype(float)
         df['volume'] = df['volume'].astype(float)
         
-        # 1. Slope
         df[f'{tf_prefix}_slope'] = ta.slope(df['close'], length=7)
-        # 2. RSI
         df[f'{tf_prefix}_rsi'] = ta.rsi(df['close'], length=14)
-        # 3. ATR Ratio
         atr = ta.atr(df['high'], df['low'], df['close'], length=14)
         df[f'{tf_prefix}_atr_pct'] = atr / df['close']
-        # 4. Volume Z-Score
         vol_mean = df['volume'].rolling(20).mean()
         vol_std = df['volume'].rolling(20).std()
         df[f'{tf_prefix}_vol_z'] = (df['volume'] - vol_mean) / (vol_std + 1e-9)
         
-        # إرجاع الأعمدة فقط (مع ملء الفراغات للحسابات اللحظية)
         cols = [f'{tf_prefix}_slope', f'{tf_prefix}_rsi', f'{tf_prefix}_atr_pct', f'{tf_prefix}_vol_z']
         return df[cols].ffill().bfill()
 
     def _create_feature_vector(self, ohlcv_data: Dict[str, Any], titan_score: float, mc_score: float, pattern_score: float) -> Optional[pd.DataFrame]:
-        """تجميع متجه الميزات ومحاكاة مدخلات الطبقة الثانية"""
         try:
-            # 1. التحقق من البيانات
             raw_1h = ohlcv_data.get('1h')
             if not raw_1h or len(raw_1h) < 30: return None
             
-            # تحويل البيانات إلى DataFrame
             df_1h = pd.DataFrame(raw_1h, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             df_15m = pd.DataFrame(ohlcv_data.get('15m', []), columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             df_4h = pd.DataFrame(ohlcv_data.get('4h', []), columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
 
-            # 2. حساب الميزات الفنية (Snapshot)
-            # نأخذ آخر صف فقط (State الحالية)
             feats_1h = self._calculate_snapshot_features(df_1h, "1h").iloc[-1:].reset_index(drop=True)
             
             if len(df_15m) > 20:
@@ -120,97 +105,81 @@ class OracleEngine:
             else:
                 feats_4h = pd.DataFrame(np.zeros((1, 4)), columns=[f'4h_{c}' for c in ['slope', 'rsi', 'atr_pct', 'vol_z']])
 
-            # 3. التجميع (Vector Assembly)
             vector = pd.concat([feats_1h, feats_15m, feats_4h], axis=1)
-
-            # 4. حقن درجات الطبقة الثانية (Injection)
-            # هنا نربط الدرجات الحقيقية بالأعمدة التي تدرب عليها النموذج (sim_...)
             vector['sim_titan_score'] = float(titan_score)
             vector['sim_mc_score'] = float(mc_score)
             vector['sim_pattern_score'] = float(pattern_score)
 
-            # 5. محاذاة الأعمدة (Column Alignment)
-            # يجب أن نرسل للنموذج نفس الأعمدة بنفس الترتيب
             final_vector = pd.DataFrame(columns=self.feature_cols)
             for col in self.feature_cols:
                 if col in vector.columns:
                     final_vector.at[0, col] = vector[col].iloc[0]
                 else:
-                    final_vector.at[0, col] = 0.0 # Missing features default to 0
+                    final_vector.at[0, col] = 0.0 
             
             return final_vector.astype(float)
 
         except Exception as e:
-            print(f"⚠️ [Oracle] Vector build failed: {e}")
             return None
 
     # ==========================================================================
-    # 🔮 التنبؤ (Inference Logic)
+    # 🔮 التنبؤ (Inference Logic - SPOT MODE)
     # ==========================================================================
-
     async def predict(self, symbol_data: Dict[str, Any]) -> Dict[str, Any]:
-        """تحليل الفرصة وإصدار التوصية"""
+        """تحليل الفرصة: هل هي صالحة للشراء (SPOT)؟"""
         if not self.initialized:
             return {'action': 'WAIT', 'reason': 'Not initialized'}
 
         try:
-            # استلام البيانات
             ohlcv = symbol_data.get('ohlcv')
             current_price = symbol_data.get('current_price', 0.0)
-            
-            # الدرجات القادمة من L2
             titan = symbol_data.get('titan_score', 0.5)
             mc = symbol_data.get('mc_score', 0.5)
             patt = symbol_data.get('patterns_score', 0.5)
 
-            # 1. بناء المتجه
             features = self._create_feature_vector(ohlcv, titan, mc, patt)
             if features is None:
                 return {'action': 'WAIT', 'reason': 'Features failed'}
 
-            # 2. التنبؤ بالاتجاه (Direction)
-            # النموذج يعيد احتمالية لكل كلاس. بما أننا دربنا 1=Long, 2=Short
-            # LightGBM (Multi-class) يعيد array: [Prob_Wait(محذوف عملياً), Prob_Long, Prob_Short]
-            # أو إذا كان Binary (0=Long, 1=Short) يعيد احتمالية Short.
-            # *تذكير*: في كود التدريب الأخير استخدمنا: y - 1. إذن: 0=Long, 1=Short.
+            # 1. التنبؤ بالاتجاه (Direction)
+            # 0=Long (Buy), 1=Short (Drop/Avoid)
+            dir_probs = self.model_direction.predict(features)[0] 
             
-            dir_probs = self.model_direction.predict(features)[0] # Array [Prob_Long, Prob_Short]
-            
-            # التعامل مع نوع المخرجات (حسب نسخة LightGBM)
             if isinstance(dir_probs, (np.ndarray, list)):
                 prob_long = dir_probs[0]
                 prob_short = dir_probs[1]
             else:
-                # Binary objective case
                 prob_short = dir_probs
                 prob_long = 1.0 - dir_probs
 
-            # تحديد الاتجاه الأقوى
-            if prob_long > prob_short:
-                direction = "LONG"
-                confidence = prob_long
-            else:
-                direction = "SHORT"
-                confidence = prob_short
+            # --- [SPOT LOGIC ENFORCEMENT] ---
+            # إذا كان احتمال الهبوط (Short) أعلى، فهذا يعني "تجنب العملة".
+            # لا نفتح صفقة Short، بل نقول WAIT.
+            if prob_short > prob_long:
+                return {
+                    'action': 'WAIT',
+                    'reason': f'Bearish Forecast (Short Prob: {prob_short:.2f})',
+                    'direction': 'SHORT' # For debugging only
+                }
+
+            # إذا وصلنا هنا، فالاتجاه هو LONG (شراء)
+            confidence = prob_long
 
-            # 3. البوابة المنطقية (Threshold Check)
+            # 2. البوابة المنطقية (Threshold Check)
             if confidence < CONFIDENCE_THRESHOLD:
                 return {
                     'action': 'WAIT',
-                    'reason': f'Low Confidence ({confidence:.2f} < {CONFIDENCE_THRESHOLD})',
-                    'direction': direction
+                    'reason': f'Low Buy Confidence ({confidence:.2f})',
+                    'direction': 'LONG'
                 }
 
-            # 4. التنبؤ بالأهداف والقوة (فقط للفرص المؤكدة)
-            
-            # Strength (Regression: 0.0 - 1.0)
+            # 3. التنبؤ بالأهداف والقوة
             strength = 0.5
             if self.model_strength:
                 strength = float(self.model_strength.predict(features)[0])
-                strength = max(0.0, min(1.0, strength)) # Clip
+                strength = max(0.0, min(1.0, strength))
 
-            # Target Class (0=TP1, 1=TP2, 2=TP3, 3=TP4)
-            tp_class_idx = 1 # Default TP2
+            tp_class_idx = 1
             if self.model_target:
                 tgt_probs = self.model_target.predict(features)[0]
                 tp_class_idx = np.argmax(tgt_probs)
@@ -218,41 +187,32 @@ class OracleEngine:
             tp_labels = ['TP1', 'TP2', 'TP3', 'TP4']
             target_profile = tp_labels[tp_class_idx]
 
-            # 5. حساب المستويات السعرية (ATR-Based)
-            # نحتاج قيمة ATR الحالية
+            # 4. حساب المستويات السعرية (للاتجاه الصاعد فقط)
             atr_pct_val = features['1h_atr_pct'].iloc[0]
             atr_abs = atr_pct_val * current_price
             
-            dir_mult = 1 if direction == "LONG" else -1
-            
-            # خريطة الأهداف
             tp_map = {
-                'TP1': current_price + (dir_mult * 0.8 * atr_abs),
-                'TP2': current_price + (dir_mult * 1.5 * atr_abs),
-                'TP3': current_price + (dir_mult * 2.5 * atr_abs),
-                'TP4': current_price + (dir_mult * 4.0 * atr_abs),
+                'TP1': current_price + (1.0 * atr_abs),
+                'TP2': current_price + (1.8 * atr_abs),
+                'TP3': current_price + (2.8 * atr_abs),
+                'TP4': current_price + (4.5 * atr_abs),
             }
             
-            # الهدف الأساسي الموصى به
             primary_tp = tp_map[target_profile]
-            
-            # الوقف (Stop Loss) - دائماً 1.2 ATR كبداية
-            sl_price = current_price - (dir_mult * 1.2 * atr_abs)
+            sl_price = current_price - (1.2 * atr_abs) # وقف الخسارة تحت السعر
 
             return {
-                'action': 'WATCH',         # إشارة صالحة للمتابعة
-                'action_type': 'BUY' if direction == "LONG" else 'SELL',
+                'action': 'WATCH',         # إشارة شراء صالحة
+                'action_type': 'BUY',      # دائماً BUY في Spot
                 'confidence': float(confidence),
                 'strength': float(strength),
                 'target_class': target_profile,
                 'primary_tp': float(primary_tp),
                 'sl_price': float(sl_price),
                 'tp_map': tp_map,
-                'analysis_summary': f"{direction} (Conf: {confidence:.0%}) | Strength: {strength:.2f} | Aiming: {target_profile}"
+                'analysis_summary': f"SPOT BUY (Conf: {confidence:.0%}) | Str: {strength:.2f} | Aim: {target_profile}"
             }
 
         except Exception as e:
             print(f"❌ [Oracle] Prediction Error: {e}")
-            import traceback
-            traceback.print_exc()
             return {'action': 'WAIT', 'reason': 'Error'}