Update learning_engine.py

learning_engine.py

@@ -1,6 +1,8 @@
+# learning_engine (37).py (محدث بالكامل مع تعلم ملف الخروج)
 import os, json, asyncio
 from datetime import datetime
 from helpers import normalize_weights, calculate_market_volatility, should_update_weights
+import numpy as np # نحتاج numpy لحساب المتوسطات
 
 class LearningEngine:
     def __init__(self, r2_service, data_manager):
@@ -8,7 +10,8 @@ class LearningEngine:
         self.data_manager = data_manager
         self.weights = {}
         self.performance_history = []
-        self.strategy_effectiveness = {}
+        self.strategy_effectiveness = {} # 🔴 لتعلم استراتيجيات الدخول
+        self.exit_profile_effectiveness = {} # 🔴 جديد: لتعلم (الدخول + الخروج)
         self.market_patterns = {}
         self.risk_profiles = {}
         self.initialized = False
@@ -21,8 +24,10 @@ class LearningEngine:
             try:
                 await self.load_weights_from_r2()
                 await self.load_performance_history()
+                # 🔴 جديد: تحميل أداء ملفات الخروج
+                await self.load_exit_profile_effectiveness()
                 self.initialized = True
-                print("Learning system ready")
+                print("Learning system ready (with Exit Profile learning)")
             except Exception as e:
                 print(f"Weights loading failed: {e}")
                 await self.initialize_default_weights()
@@ -35,6 +40,8 @@ class LearningEngine:
             try:
                 await self.load_weights_from_r2()
                 await self.load_performance_history()
+                # 🔴 جديد: تحميل أداء ملفات الخروج
+                await self.load_exit_profile_effectiveness()
                 await self.fix_weights_structure()
                 if not self.performance_history:
                     print("Starting learning from scratch")
@@ -87,6 +94,8 @@ class LearningEngine:
                 "sideways_market": {"mean_reversion": 0.30, "volume_spike": 0.20, "pattern_recognition": 0.15}
             }
         }
+        # 🔴 جديد: تهيئة افتراضية لملفات الخروج
+        self.exit_profile_effectiveness = {}
     
     async def load_weights_from_r2(self):
         try:
@@ -124,6 +133,32 @@ class LearningEngine:
         except Exception as e:
             print(f"Weights saving failed: {e}")
     
+    # 🔴 جديد: تحميل وحفظ أداء ملف الخروج
+    async def load_exit_profile_effectiveness(self):
+        try:
+            key = "learning_exit_profile_effectiveness.json"
+            response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
+            data = json.loads(response['Body'].read())
+            self.exit_profile_effectiveness = data.get("effectiveness", {})
+            print(f"Exit profile effectiveness loaded - {len(self.exit_profile_effectiveness)} combinations")
+        except Exception as e:
+            print(f"Exit profile effectiveness loading failed: {e}")
+            self.exit_profile_effectiveness = {}
+
+    async def save_exit_profile_effectiveness(self):
+        try:
+            key = "learning_exit_profile_effectiveness.json"
+            data = {
+                "effectiveness": self.exit_profile_effectiveness,
+                "last_updated": datetime.now().isoformat()
+            }
+            data_json = json.dumps(data, indent=2, ensure_ascii=False).encode('utf-8')
+            self.r2_service.s3_client.put_object(
+                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
+            )
+        except Exception as e:
+            print(f"Exit profile effectiveness saving failed: {e}")
+
     async def load_performance_history(self):
         try:
             key = "learning_performance_history.json"
@@ -157,6 +192,10 @@ class LearningEngine:
                 decision_data = trade_data.get('decision_data', {})
                 strategy = decision_data.get('strategy', 'unknown')
             
+            # 🔴 جديد: استخراج ملف الخروج
+            decision_data = trade_data.get('decision_data', {})
+            exit_profile = decision_data.get('exit_profile', 'unknown')
+            
             market_context = await self.get_current_market_conditions()
             
             analysis_entry = {
@@ -165,6 +204,7 @@ class LearningEngine:
                 "outcome": outcome,
                 "market_conditions": market_context,
                 "strategy_used": strategy,
+                "exit_profile_used": exit_profile, # 🔴 جديد
                 "symbol": trade_data.get('symbol', 'unknown'),
                 "pnl_usd": trade_data.get('pnl_usd', 0),
                 "pnl_percent": trade_data.get('pnl_percent', 0)
@@ -178,17 +218,23 @@ class LearningEngine:
                 await self.adapt_weights_based_on_performance()
                 await self.save_weights_to_r2()
                 await self.save_performance_history()
+                # 🔴 جديد: حفظ أداء ملف الخروج
+                await self.save_exit_profile_effectiveness()
             
-            print(f"Trade analyzed {trade_data.get('symbol')} - Strategy: {strategy} - Outcome: {outcome}")
+            print(f"Trade analyzed {trade_data.get('symbol')} - Strategy: {strategy} - Exit: {exit_profile} - Outcome: {outcome}")
         except Exception as e:
             print(f"Trade outcome analysis failed: {e}")
     
     async def update_strategy_effectiveness(self, analysis_entry):
         strategy = analysis_entry['strategy_used']
+        exit_profile = analysis_entry['exit_profile_used'] # 🔴 جديد
+        combined_key = f"{strategy}_{exit_profile}" # 🔴 جديد
+        
         outcome = analysis_entry['outcome']
         market_condition = analysis_entry['market_conditions']['current_trend']
         pnl_percent = analysis_entry.get('pnl_percent', 0)
         
+        # --- 1. تحديث أداء استراتيجية الدخول (كما كان) ---
         if strategy not in self.strategy_effectiveness:
             self.strategy_effectiveness[strategy] = {
                 "total_trades": 0, "successful_trades": 0, "total_profit": 0,
@@ -209,8 +255,27 @@ class LearningEngine:
         self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["trades"] += 1
         self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["total_pnl"] += pnl_percent
         if is_success: self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["successes"] += 1
+        
+        # --- 2. 🔴 جديد: تحديث أداء مزيج (الدخول + الخروج) ---
+        if combined_key not in self.exit_profile_effectiveness:
+            self.exit_profile_effectiveness[combined_key] = {
+                "total_trades": 0, "successful_trades": 0, 
+                "total_pnl_percent": 0, "pnl_list": [] # لتتبع المتوسط والانحراف
+            }
+        
+        self.exit_profile_effectiveness[combined_key]["total_trades"] += 1
+        self.exit_profile_effectiveness[combined_key]["total_pnl_percent"] += pnl_percent
+        self.exit_profile_effectiveness[combined_key]["pnl_list"].append(pnl_percent)
+        # الحفاظ على آخر 100 نتيجة فقط
+        if len(self.exit_profile_effectiveness[combined_key]["pnl_list"]) > 100:
+            self.exit_profile_effectiveness[combined_key]["pnl_list"] = self.exit_profile_effectiveness[combined_key]["pnl_list"][-100:]
+            
+        if is_success:
+            self.exit_profile_effectiveness[combined_key]["successful_trades"] += 1
+
     
     async def update_market_patterns(self, analysis_entry):
+        # ... (هذه الدالة تبقى كما هي، لا تحتاج تعديل)
         market_condition = analysis_entry['market_conditions']['current_trend']
         symbol = analysis_entry['symbol']
         outcome = analysis_entry['outcome']
@@ -246,6 +311,7 @@ class LearningEngine:
         self.market_patterns[market_condition]["best_performing_symbols"][symbol]["total_pnl"] += pnl_percent
     
     async def adapt_weights_based_on_performance(self):
+        # ... (هذه الدالة تبقى كما هي، لتعديل أوزان *الدخول* فقط)
         print("Updating weights based on performance...")
         try:
             if not self.strategy_effectiveness:
@@ -279,6 +345,7 @@ class LearningEngine:
             await self.gradual_weights_adjustment()
 
     async def gradual_weights_adjustment(self):
+        # ... (هذه الدالة تبقى كما هي)
         print("Gradual weights adjustment...")
         if self.market_patterns:
             for market_condition, data in self.market_patterns.items():
@@ -291,6 +358,40 @@ class LearningEngine:
         
         normalize_weights(self.weights["strategy_weights"])
         print("Gradual weights adjustment completed")
+        
+    # 🔴 جديد: دالة التغذية الراجعة لـ LLM
+    async def get_best_exit_profile(self, entry_strategy: str) -> str:
+        """
+        يجد أفضل ملف خروج (Exit Profile) لاستراتيجية دخول معينة
+        بناءً على متوسط الربح/الخسارة (avg_pnl_percent).
+        """
+        if not self.initialized or not self.exit_profile_effectiveness:
+            return "unknown"
+            
+        relevant_profiles = {}
+        
+        for combined_key, data in self.exit_profile_effectiveness.items():
+            if combined_key.startswith(f"{entry_strategy}_"):
+                # يتطلب 3 صفقات على الأقل لاعتباره
+                if data.get("total_trades", 0) >= 3:
+                    exit_profile_name = combined_key.replace(f"{entry_strategy}_", "", 1)
+                    
+                    # استخدام متوسط الربح/الخسارة كمقياس أساسي
+                    avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                    
+                    # استخدام مقياس مركب (مثل Sharpe ratio المبسط)
+                    # pnl_std_dev = np.std(data["pnl_list"]) if len(data["pnl_list"]) > 1 else 0
+                    # risk_adjusted_return = avg_pnl / (pnl_std_dev + 1e-6) # +1e-6 لمنع القسمة على صفر
+                    
+                    relevant_profiles[exit_profile_name] = avg_pnl # استخدام avg_pnl
+        
+        if not relevant_profiles:
+            return "unknown" # لا توجد بيانات كافية
+            
+        # إرجاع اسم ملف الخروج صاحب أعلى متوسط ربح
+        best_profile = max(relevant_profiles, key=relevant_profiles.get)
+        print(f"🧠 Learning Feedback: Best exit for '{entry_strategy}' is '{best_profile}' (Avg PnL: {relevant_profiles[best_profile]:.2f}%)")
+        return best_profile
 
     async def get_current_market_conditions(self):
         try:
@@ -331,6 +432,17 @@ class LearningEngine:
                     "total_trades": data["total_trades"], "successful_trades": data["successful_trades"]
                 }
         
+        # 🔴 جديد: إضافة إحصائيات أداء ملف الخروج
+        exit_profile_performance = {}
+        for combined_key, data in self.exit_profile_effectiveness.items():
+            if data["total_trades"] > 0:
+                profile_success_rate = data["successful_trades"] / data["total_trades"]
+                profile_avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                exit_profile_performance[combined_key] = {
+                    "success_rate": profile_success_rate, "avg_pnl_percent": profile_avg_pnl,
+                    "total_trades": data["total_trades"]
+                }
+
         market_performance = {}
         for condition, data in self.market_patterns.items():
             if data["total_trades"] > 0:
@@ -344,7 +456,9 @@ class LearningEngine:
         return {
             "overall_success_rate": success_rate, "overall_avg_pnl_percent": avg_pnl,
             "total_analyzed_trades": len(self.performance_history), "recent_trades_analyzed": total_trades,
-            "strategy_performance": strategy_performance, "market_performance": market_performance,
+            "strategy_performance": strategy_performance, 
+            "exit_profile_performance": exit_profile_performance, # 🔴 جديد
+            "market_performance": market_performance,
             "last_updated": datetime.now().isoformat()
         }
     
@@ -388,6 +502,7 @@ class LearningEngine:
             improvements.append("Start collecting performance data from first trades")
             return improvements
         
+        # ... (التحليل الأساسي يبقى كما هو)
         for strategy, data in self.strategy_effectiveness.items():
             if data["total_trades"] >= 3:
                 success_rate = data["successful_trades"] / data["total_trades"]
@@ -396,27 +511,23 @@ class LearningEngine:
                     improvements.append(f"Strategy {strategy} poor performance ({success_rate:.1%} success, {avg_pnl:+.1f}% average) - suggest reducing usage")
                 elif success_rate > 0.6 and avg_pnl > 2:
                     improvements.append(f"Strategy {strategy} excellent performance ({success_rate:.1%} success, {avg_pnl:+.1f}% average) - suggest increasing usage")
-                elif success_rate > 0.7:
-                    improvements.append(f"Strategy {strategy} high success ({success_rate:.1%}) - focus on trade quality")
         
+        # 🔴 جديد: اقتراح تحسينات بناءً على ملفات الخروج
+        for combined_key, data in self.exit_profile_effectiveness.items():
+            if data["total_trades"] >= 5: # يتطلب 5 صفقات للمزيج
+                success_rate = data["successful_trades"] / data["total_trades"]
+                avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                if success_rate < 0.3 and avg_pnl < -0.5:
+                    improvements.append(f"Exit Combo '{combined_key}' is failing ({success_rate:.1%} success, {avg_pnl:+.1f}% avg). AVOID.")
+                elif success_rate > 0.7 and avg_pnl > 1.5:
+                     improvements.append(f"Exit Combo '{combined_key}' is performing well ({success_rate:.1%} success, {avg_pnl:+.1f}% avg). PRIORITIZE.")
+
         for market_condition, data in self.market_patterns.items():
+             # ... (التحليل الأساسي يبقى كما هو)
             if data["total_trades"] >= 5:
                 success_rate = data["successful_trades"] / data["total_trades"]
-                avg_pnl = data["total_pnl_percent"] / data["total_trades"]
                 if success_rate < 0.4:
                     improvements.append(f"Poor performance in {market_condition} market ({success_rate:.1%} success) - needs strategy review")
-                
-                best_strategy = None
-                best_performance = -100
-                for strategy, stats in data["best_performing_strategies"].items():
-                    if stats["count"] >= 2:
-                        strategy_avg_pnl = stats["total_pnl"] / stats["count"]
-                        if strategy_avg_pnl > best_performance:
-                            best_performance = strategy_avg_pnl
-                            best_strategy = strategy
-                
-                if best_strategy and best_performance > 1:
-                    improvements.append(f"Best strategy in {market_condition}: {best_strategy} ({best_performance:+.1f}% average profit)")
         
         if not improvements: improvements.append("No suggested improvements currently - continue data collection")
         return improvements
@@ -427,10 +538,11 @@ class LearningEngine:
             print("No performance data to learn from")
             return
         for entry in self.performance_history:
-            await self.update_strategy_effectiveness(entry)
+            await self.update_strategy_effectiveness(entry) # 🔴 هذا سيحدث الآن كلا القاموسين
             await self.update_market_patterns(entry)
         await self.adapt_weights_based_on_performance()
         await self.save_weights_to_r2()
-        print("Strategy update forced successfully")
+        await self.save_exit_profile_effectiveness() # 🔴 جديد
+        print("Strategy update forced successfully (including exit profiles)")
 
-print("Enhanced self-learning system loaded - ready for continuous learning and adaptation")
+print("Enhanced self-learning system loaded - V2 (with Exit Profile Learning)")