مطور أنظمة التوصيات

# نظام أساسي لأنظمة التوصيات باستخدام Python
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder, MinMaxScaler
from sklearn.metrics.pairwise import cosine_similarity
import warnings
warnings.filterwarnings('ignore')

class RecommendationSystemBase:
    def __init__(self):
        self.users_df = None
        self.items_df = None
        self.ratings_df = None
        self.user_encoder = LabelEncoder()
        self.item_encoder = LabelEncoder()
        self.scaler = MinMaxScaler()
        
    def load_sample_data(self):
        """تحميل بيانات عينة"""
        print("جارِ تحميل بيانات العينة...")
        
        # بيانات المستخدمين
        self.users_df = pd.DataFrame({
            'user_id': [1, 2, 3, 4, 5],
            'age': [25, 30, 35, 40, 45],
            'gender': ['M', 'F', 'M', 'F', 'M'],
            'location': ['NYC', 'LA', 'Chicago', 'Miami', 'Seattle']
        })
        
        # بيانات العناصر
        self.items_df = pd.DataFrame({
            'item_id': [101, 102, 103, 104, 105, 106, 107, 108],
            'category': ['Electronics', 'Books', 'Clothing', 'Electronics', 
                        'Books', 'Clothing', 'Electronics', 'Books'],
            'price': [299.99, 19.99, 49.99, 599.99, 29.99, 79.99, 399.99, 14.99],
            'rating': [4.5, 4.2, 3.8, 4.7, 4.0, 4.1, 4.6, 3.9]
        })
        
        # بيانات التقييمات
        self.ratings_df = pd.DataFrame({
            'user_id': [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5],
            'item_id': [101, 102, 103, 101, 104, 105, 102, 103, 106, 104, 107, 108, 101, 107],
            'rating': [5, 4, 3, 4, 5, 4, 3, 4, 5, 4, 5, 3, 5, 4],
            'timestamp': pd.date_range('2024-01-01', periods=14, freq='D')
        })
        
        print(f"تم تحميل {len(self.users_df)} مستخدم")
        print(f"تم تحميل {len(self.items_df)} عنصر")
        print(f"تم تحميل {len(self.ratings_df)} تقييم")
        
        return self.users_df, self.items_df, self.ratings_df
    
    def preprocess_data(self):
        """معالجة البيانات الأولية"""
        print("جارِ معالجة البيانات...")
        
        # ترميز المستخدمين والعناصر
        self.ratings_df['user_encoded'] = self.user_encoder.fit_transform(
            self.ratings_df['user_id']
        )
        self.ratings_df['item_encoded'] = self.item_encoder.fit_transform(
            self.ratings_df['item_id']
        )
        
        # تطبيع التقييمات
        self.ratings_df['rating_normalized'] = self.scaler.fit_transform(
            self.ratings_df[['rating']]
        )
        
        # إضافة ميزات للمستخدمين
        self.users_df['age_normalized'] = self.scaler.fit_transform(
            self.users_df[['age']]
        )
        self.users_df['gender_encoded'] = LabelEncoder().fit_transform(
            self.users_df['gender']
        )
        
        # إضافة ميزات للعناصر
        self.items_df['price_normalized'] = self.scaler.fit_transform(
            self.items_df[['price']]
        )
        self.items_df['rating_normalized'] = self.scaler.fit_transform(
            self.items_df[['rating']]
        )
        self.items_df['category_encoded'] = LabelEncoder().fit_transform(
            self.items_df['category']
        )
        
        print("تمت معالجة البيانات بنجاح")
        return self.ratings_df, self.users_df, self.items_df
    
    def create_user_item_matrix(self):
        """إنشاء مصفوفة المستخدم-العنصر"""
        print("جارِ إنشاء مصفوفة المستخدم-العنصر...")
        
        user_item_matrix = pd.pivot_table(
            self.ratings_df,
            values='rating',
            index='user_encoded',
            columns='item_encoded',
            fill_value=0
        )
        
        print(f"حجم المصفوفة: {user_item_matrix.shape}")
        print(f"الكثافة: {(user_item_matrix > 0).sum().sum() / user_item_matrix.size:.2%}")
        
        return user_item_matrix
    
    def calculate_user_similarity(self, user_item_matrix):
        """حساب التشابه بين المستخدمين"""
        print("جارِ حساب التشابه بين المستخدمين...")
        
        user_similarity = cosine_similarity(user_item_matrix)
        user_similarity_df = pd.DataFrame(
            user_similarity,
            index=user_item_matrix.index,
            columns=user_item_matrix.index
        )
        
        return user_similarity_df
    
    def calculate_item_similarity(self, user_item_matrix):
        """حساب التشابه بين العناصر"""
        print("جارِ حساب التشابه بين العناصر...")
        
        item_similarity = cosine_similarity(user_item_matrix.T)
        item_similarity_df = pd.DataFrame(
            item_similarity,
            index=user_item_matrix.columns,
            columns=user_item_matrix.columns
        )
        
        return item_similarity_df
    
    def analyze_data(self):
        """تحليل البيانات الأساسي"""
        print("\n" + "="*50)
        print("تحليل البيانات")
        print("="*50)
        
        # إحصائيات التقييمات
        print("\nإحصائيات التقييمات:")
        print(f"متوسط التقييم: {self.ratings_df['rating'].mean():.2f}")
        print(f"الحد الأدنى للتقييم: {self.ratings_df['rating'].min()}")
        print(f"الحد الأقصى للتقييم: {self.ratings_df['rating'].max()}")
        
        # توزيع التقييمات
        print("\nتوزيع التقييمات:")
        rating_dist = self.ratings_df['rating'].value_counts().sort_index()
        for rating, count in rating_dist.items():
            print(f"  التقييم {rating}: {count} تقييم ({count/len(self.ratings_df):.1%})")
        
        # المستخدمون الأكثر نشاطاً
        print("\nالمستخدمون الأكثر نشاطاً:")
        user_activity = self.ratings_df['user_id'].value_counts().head(3)
        for user, count in user_activity.items():
            print(f"  المستخدم {user}: {count} تقييم")
        
        # العناصر الأكثر شيوعاً
        print("\nالعناصر الأكثر شيوعاً:")
        item_popularity = self.ratings_df['item_id'].value_counts().head(3)
        for item, count in item_popularity.items():
            item_name = self.items_df[self.items_df['item_id'] == item]['category'].iloc[0]
            print(f"  العنصر {item} ({item_name}): {count} تقييم")
        
        # التحليل الزمني
        print("\nالتحليل الزمني:")
        self.ratings_df['date'] = self.ratings_df['timestamp'].dt.date
        daily_ratings = self.ratings_df.groupby('date').size()
        print(f"عدد الأيام: {len(daily_ratings)}")
        print(f"متوسط التقييمات اليومية: {daily_ratings.mean():.1f}")
    
    def get_recommendation_stats(self):
        """الحصول على إحصائيات التوصيات"""
        stats = {
            'عدد المستخدمين': len(self.users_df),
            'عدد العناصر': len(self.items_df),
            'عدد التقييمات': len(self.ratings_df),
            'كثافة التقييمات': f"{(len(self.ratings_df) / (len(self.users_df) * len(self.items_df))):.2%}",
            'متوسط التقييمات لكل مستخدم': f"{len(self.ratings_df) / len(self.users_df):.1f}",
            'متوسط التقييمات لكل عنصر': f"{len(self.ratings_df) / len(self.items_df):.1f}"
        }
        
        return stats

# مثال للاستخدام
recommendation_system = RecommendationSystemBase()

# تحميل البيانات
users, items, ratings = recommendation_system.load_sample_data()

# معالجة البيانات
processed_ratings, processed_users, processed_items = recommendation_system.preprocess_data()

# إنشاء مصفوفة المستخدم-العنصر
user_item_matrix = recommendation_system.create_user_item_matrix()

# حساب التشابه
user_similarity = recommendation_system.calculate_user_similarity(user_item_matrix)
item_similarity = recommendation_system.calculate_item_similarity(user_item_matrix)

# تحليل البيانات
recommendation_system.analyze_data()

# الحصول على الإحصائيات
stats = recommendation_system.get_recommendation_stats()
print("\n" + "="*50)
print("إحصائيات النظام")
print("="*50)
for key, value in stats.items():
    print(f"{key}: {value}")

# نظام متكامل لـ Collaborative Filtering
import pandas as pd
import numpy as np
from scipy.sparse import csr_matrix
from sklearn.neighbors import NearestNeighbors
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error
import warnings
warnings.filterwarnings('ignore')

class AdvancedCollaborativeFiltering:
    def __init__(self):
        self.ratings_df = None
        self.user_item_matrix = None
        self.user_similarity = None
        self.item_similarity = None
        self.models = {}
        
    def load_movielens_data(self, sample_size=1000):
        """تحميل بيانات MovieLens (عينة)"""
        print("جارِ تحميل بيانات MovieLens...")
        
        # في التطبيق الحقيقي، يتم تحميل البيانات من ملف
        # هنا ننشئ بيانات محاكاة
        np.random.seed(42)
        
        # إنشاء بيانات مستخدمين وعناصر وتقييمات
        n_users = 200
        n_items = 100
        n_ratings = sample_size
        
        user_ids = np.random.randint(1, n_users + 1, n_ratings)
        item_ids = np.random.randint(1, n_items + 1, n_ratings)
        ratings = np.random.randint(1, 6, n_ratings)
        
        self.ratings_df = pd.DataFrame({
            'user_id': user_ids,
            'item_id': item_ids,
            'rating': ratings
        })
        
        print(f"تم تحميل {len(self.ratings_df)} تقييم")
        print(f"عدد المستخدمين الفريدين: {self.ratings_df['user_id'].nunique()}")
        print(f"عدد العناصر الفريدة: {self.ratings_df['item_id'].nunique()}")
        
        return self.ratings_df
    
    def create_sparse_matrix(self):
        """إنشاء مصفوفة متفرقة للمستخدم-العنصر"""
        print("جارِ إنشاء مصفوفة المستخدم-العنصر...")
        
        # إنشاء مصفوفة كاملة
        user_item_pivot = self.ratings_df.pivot(
            index='user_id',
            columns='item_id',
            values='rating'
        ).fillna(0)
        
        # تحويل إلى مصفوفة متفرقة
        self.user_item_matrix = csr_matrix(user_item_pivot.values)
        
        print(f"حجم المصفوفة: {self.user_item_matrix.shape}")
        print(f"الكثافة: {self.user_item_matrix.nnz / (self.user_item_matrix.shape[0] * self.user_item_matrix.shape[1]):.4%}")
        
        return self.user_item_matrix, user_item_pivot
    
    def user_based_collaborative_filtering(self, n_neighbors=5):
        """تصفية تعاوني قائم على المستخدم"""
        print("\n" + "="*50)
        print("User-Based Collaborative Filtering")
        print("="*50)
        
        # نموذج الجيران الأقرب
        model = NearestNeighbors(
            n_neighbors=n_neighbors + 1,  # +1 لأن المستخدم نفسه سيكون الأقرب
            algorithm='auto',
            metric='cosine'
        )
        
        model.fit(self.user_item_matrix)
        
        self.models['user_based'] = model
        
        # العثور على جيران لمستخدم عشوائي
        user_idx = np.random.randint(0, self.user_item_matrix.shape[0])
        distances, indices = model.kneighbors(self.user_item_matrix[user_idx])
        
        print(f"\nالجيران الأقرب للمستخدم {user_idx + 1}:")
        for i in range(1, len(indices[0])):  # تخطي المستخدم نفسه
            neighbor_idx = indices[0][i]
            similarity = 1 - distances[0][i]  # تحويل المسافة إلى تشابه
            print(f"  المستخدم {neighbor_idx + 1}: التشابه = {similarity:.3f}")
        
        return model
    
    def item_based_collaborative_filtering(self, n_neighbors=5):
        """تصفية تعاوني قائم على العنصر"""
        print("\n" + "="*50)
        print("Item-Based Collaborative Filtering")
        print("="*50)
        
        # استخدام مصفوفة العنصر-المستخدم (تبديل)
        item_user_matrix = self.user_item_matrix.T
        
        # نموذج الجيران الأقرب للعناصر
        model = NearestNeighbors(
            n_neighbors=n_neighbors + 1,
            algorithm='auto',
            metric='cosine'
        )
        
        model.fit(item_user_matrix)
        
        self.models['item_based'] = model
        
        # العثور على جيران لعنصر عشوائي
        item_idx = np.random.randint(0, item_user_matrix.shape[0])
        distances, indices = model.kneighbors(item_user_matrix[item_idx])
        
        print(f"\nالجيران الأقرب للعنصر {item_idx + 1}:")
        for i in range(1, len(indices[0])):  # تخطي العنصر نفسه
            neighbor_idx = indices[0][i]
            similarity = 1 - distances[0][i]
            print(f"  العنصر {neighbor_idx + 1}: التشابه = {similarity:.3f}")
        
        return model
    
    def matrix_factorization_svd(self, n_factors=20, n_epochs=20, lr=0.005, reg=0.02):
        """تحليل المصفوفة باستخدام SVD"""
        print("\n" + "="*50)
        print("Matrix Factorization using SVD")
        print("="*50)
        
        # معلمات النموذج
        n_users, n_items = self.user_item_matrix.shape
        
        # تهيئة معاملات المستخدمين والعناصر
        P = np.random.normal(0, 0.1, (n_users, n_factors))  # عوامل المستخدمين
        Q = np.random.normal(0, 0.1, (n_items, n_factors))  # عوامل العناصر
        
        # تدريب النموذج باستخدام SGD
        train_errors = []
        
        for epoch in range(n_epochs):
            epoch_error = 0
            num_samples = 0
            
            # اجتياز جميع التقييمات غير الصفرية
            for i in range(n_users):
                for j in range(n_items):
                    rating = self.user_item_matrix[i, j]
                    if rating > 0:
                        # التنبؤ
                        pred = np.dot(P[i, :], Q[j, :].T)
                        
                        # الخطأ
                        error = rating - pred
                        epoch_error += error ** 2
                        num_samples += 1
                        
                        # تحديث المعاملات
                        P[i, :] += lr * (error * Q[j, :] - reg * P[i, :])
                        Q[j, :] += lr * (error * P[i, :] - reg * Q[j, :])
            
            avg_error = epoch_error / num_samples if num_samples > 0 else 0
            train_errors.append(avg_error)
            
            if (epoch + 1) % 5 == 0:
                print(f"الدورة {epoch + 1}/{n_epochs}: MSE = {avg_error:.4f}")
        
        self.models['svd'] = (P, Q)
        
        # تخزين الأخطاء للرسم البياني
        self.svd_errors = train_errors
        
        return P, Q, train_errors
    
    def predict_rating(self, user_id, item_id, method='svd'):
        """التنبؤ بتقييم مستخدم لعنصر"""
        if method == 'svd' and 'svd' in self.models:
            P, Q = self.models['svd']
            user_idx = user_id - 1  # تحويل إلى فهرس صفري
            item_idx = item_id - 1
            
            if user_idx < P.shape[0] and item_idx < Q.shape[0]:
                pred = np.dot(P[user_idx, :], Q[item_idx, :].T)
                # قص القيمة إلى النطاق الصحيح
                pred = max(1, min(5, pred))
                return pred
        
        return None
    
    def generate_recommendations(self, user_id, n_recommendations=10, method='svd'):
        """توليد توصيات لمستخدم"""
        if method == 'svd' and 'svd' in self.models:
            P, Q = self.models['svd']
            user_idx = user_id - 1
            
            if user_idx < P.shape[0]:
                # حساب نتائج جميع العناصر
                user_vector = P[user_idx, :]
                scores = np.dot(Q, user_vector)
                
                # فرز العناصر حسب النتيجة
                item_indices = np.argsort(scores)[::-1]
                
                recommendations = []
                for idx in item_indices[:n_recommendations]:
                    item_id = idx + 1
                    score = scores[idx]
                    recommendations.append((item_id, score))
                
                return recommendations
        
        return None
    
    def evaluate_model(self, test_size=0.2):
        """تقييم النموذج"""
        print("\n" + "="*50)
        print("تقييم النموذج")
        print("="*50)
        
        # تقسيم البيانات
        train_df, test_df = train_test_split(
            self.ratings_df,
            test_size=test_size,
            random_state=42
        )
        
        print(f"بيانات التدريب: {len(train_df)} عينة")
        print(f"بيانات الاختبار: {len(test_df)} عينة")
        
        # إنشاء مصفوفات التدريب والاختبار
        train_matrix = train_df.pivot(
            index='user_id',
            columns='item_id',
            values='rating'
        ).fillna(0)
        
        test_matrix = test_df.pivot(
            index='user_id',
            columns='item_id',
            values='rating'
        ).fillna(0)
        
        # تدريب نموذج SVD على بيانات التدريب
        train_csr = csr_matrix(train_matrix.values)
        n_users, n_items = train_csr.shape
        
        # معلمات SMD المبسطة
        n_factors = 10
        P = np.random.normal(0, 0.1, (n_users, n_factors))
        Q = np.random.normal(0, 0.1, (n_items, n_factors))
        
        # تدريب بسيط
        n_epochs = 10
        lr = 0.005
        reg = 0.02
        
        for epoch in range(n_epochs):
            for i in range(n_users):
                for j in range(n_items):
                    rating = train_csr[i, j]
                    if rating > 0:
                        pred = np.dot(P[i, :], Q[j, :].T)
                        error = rating - pred
                        P[i, :] += lr * (error * Q[j, :] - reg * P[i, :])
                        Q[j, :] += lr * (error * P[i, :] - reg * Q[j, :])
        
        # التنبؤ على بيانات الاختبار
        predictions = []
        actuals = []
        
        for _, row in test_df.iterrows():
            user_id = row['user_id']
            item_id = row['item_id']
            actual = row['rating']
            
            user_idx = user_id - 1
            item_idx = item_id - 1
            
            if user_idx < P.shape[0] and item_idx < Q.shape[0]:
                pred = np.dot(P[user_idx, :], Q[item_idx, :].T)
                pred = max(1, min(5, pred))  # قص القيمة
                
                predictions.append(pred)
                actuals.append(actual)
        
        # حساب مقاييس التقييم
        if predictions and actuals:
            mse = mean_squared_error(actuals, predictions)
            rmse = np.sqrt(mse)
            mae = mean_absolute_error(actuals, predictions)
            
            print(f"\nنتائج التقييم:")
            print(f"MSE: {mse:.4f}")
            print(f"RMSE: {rmse:.4f}")
            print(f"MAE: {mae:.4f}")
            
            # حساب دقة التصنيف (إذا اعتبرنا 4+ تقييم إيجابي)
            threshold = 4
            pred_binary = [1 if p >= threshold else 0 for p in predictions]
            actual_binary = [1 if a >= threshold else 0 for a in actuals]
            
            accuracy = np.mean(np.array(pred_binary) == np.array(actual_binary))
            print(f"الدقة (عتبة {threshold}+): {accuracy:.2%}")
            
            return {'mse': mse, 'rmse': rmse, 'mae': mae, 'accuracy': accuracy}
        
        return None
    
    def analyze_recommendations(self, user_id=1):
        """تحليل التوصيات لمستخدم"""
        print("\n" + "="*50)
        print(f"تحليل التوصيات للمستخدم {user_id}")
        print("="*50)
        
        # توليد التوصيات
        recommendations = self.generate_recommendations(user_id, n_recommendations=5)
        
        if recommendations:
            print("\nأفضل 5 توصيات:")
            for i, (item_id, score) in enumerate(recommendations, 1):
                print(f"{i}. العنصر {item_id}: النتيجة = {score:.4f}")
            
            # تحليل توزيع النتائج
            scores = [score for _, score in recommendations]
            print(f"\nإحصائيات النتائج:")
            print(f"  المتوسط: {np.mean(scores):.4f}")
            print(f"  الانحراف المعياري: {np.std(scores):.4f}")
            print(f"  الحد الأدنى: {np.min(scores):.4f}")
            print(f"  الحد الأقصى: {np.max(scores):.4f}")
            
            # توصية تنوعية (تجنب العناصر المتشابهة)
            print(f"\nالتنوع في التوصيات:")
            if len(recommendations) > 1:
                # حساب متوسط المسافة بين التوصيات
                item_ids = [item_id for item_id, _ in recommendations]
                diversity_score = len(set(item_ids)) / len(item_ids)
                print(f"  درجة التنوع: {diversity_score:.2%}")
            
            return recommendations
        
        print("لا توجد توصيات متاحة")
        return None

# مثال للاستخدام
cf_system = AdvancedCollaborativeFiltering()

# تحميل البيانات
ratings_data = cf_system.load_movielens_data(sample_size=2000)

# إنشاء مصفوفة متفرقة
matrix, pivot_df = cf_system.create_sparse_matrix()

# تطبيق User-Based Collaborative Filtering
user_based_model = cf_system.user_based_collaborative_filtering(n_neighbors=5)

# تطبيق Item-Based Collaborative Filtering
item_based_model = cf_system.item_based_collaborative_filtering(n_neighbors=5)

# تطبيق Matrix Factorization باستخدام SVD
P, Q, errors = cf_system.matrix_factorization_svd(
    n_factors=15,
    n_epochs=25,
    lr=0.005,
    reg=0.02
)

# تقييم النموذج
evaluation_results = cf_system.evaluate_model(test_size=0.2)

# توليد وتحليل التوصيات
user_id = 5
recommendations = cf_system.analyze_recommendations(user_id)

# التنبؤ بتقييم محدد
if recommendations:
    test_user = user_id
    test_item = recommendations[0][0]  # أول عنصر موصى به
    predicted_rating = cf_system.predict_rating(test_user, test_item, method='svd')
    
    if predicted_rating:
        print(f"\nالتنبؤ بتقييم المستخدم {test_user} للعنصر {test_item}: {predicted_rating:.2f}")

# نظام متكامل لـ Content-Based Filtering
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity, linear_kernel
from sklearn.preprocessing import MinMaxScaler, LabelEncoder
from sklearn.decomposition import TruncatedSVD
import re
from collections import Counter
import warnings
warnings.filterwarnings('ignore')

class AdvancedContentBasedFiltering:
    def __init__(self):
        self.items_df = None
        self.tfidf_matrix = None
        self.cosine_sim = None
        self.feature_weights = None
        
    def load_sample_items(self, n_items=50):
        """تحميل عناصر عينة مع خصائص متنوعة"""
        print("جارِ تحميل عناصر العينة...")
        
        # إنشاء بيانات عناصر متنوعة
        categories = ['Technology', 'Books', 'Movies', 'Music', 'Games', 
                     'Electronics', 'Fashion', 'Home', 'Sports', 'Food']
        
        subcategories = {
            'Technology': ['Programming', 'AI', 'Data Science', 'Web Development', 'Mobile'],
            'Books': ['Fiction', 'Non-Fiction', 'Science', 'History', 'Biography'],
            'Movies': ['Action', 'Comedy', 'Drama', 'Sci-Fi', 'Documentary'],
            'Music': ['Pop', 'Rock', 'Hip Hop', 'Classical', 'Jazz'],
            'Games': ['Action', 'Strategy', 'Puzzle', 'Sports', 'RPG']
        }
        
        np.random.seed(42)
        
        items_data = []
        for i in range(1, n_items + 1):
            category = np.random.choice(categories)
            subcategory_options = subcategories.get(category, ['General'])
            subcategory = np.random.choice(subcategory_options)
            
            # إنشاء وصف نصي غني
            descriptions = [
                f"{category} product with excellent features and high quality.",
                f"Premium {subcategory} item perfect for enthusiasts and professionals.",
                f"Advanced {category} solution with cutting-edge technology.",
                f"Popular {subcategory} choice among customers worldwide.",
                f"Award-winning {category} product with outstanding performance."
            ]
            
            item = {
                'item_id': i,
                'title': f"{subcategory} {category} Item {i}",
                'category': category,
                'subcategory': subcategory,
                'description': np.random.choice(descriptions),
                'price': np.random.uniform(10, 500),
                'rating': np.random.uniform(3.0, 5.0),
                'popularity': np.random.randint(1, 1000),
                'keywords': f"{category.lower()},{subcategory.lower()},product,item"
            }
            
            # إضافة سمات إضافية بناءً على الفئة
            if category == 'Technology':
                item['tech_level'] = np.random.choice(['Beginner', 'Intermediate', 'Advanced'])
                item['platform'] = np.random.choice(['Windows', 'Mac', 'Linux', 'Multi-platform'])
            elif category == 'Books':
                item['author'] = f"Author {np.random.randint(1, 50)}"
                item['pages'] = np.random.randint(100, 1000)
            elif category == 'Movies':
                item['duration'] = f"{np.random.randint(60, 180)} minutes"
                item['director'] = f"Director {np.random.randint(1, 30)}"
            
            items_data.append(item)
        
        self.items_df = pd.DataFrame(items_data)
        print(f"تم تحميل {len(self.items_df)} عنصر")
        print(f"عدد الفئات: {self.items_df['category'].nunique()}")
        print(f"عدد الفئات الفرعية: {self.items_df['subcategory'].nunique()}")
        
        return self.items_df
    
    def preprocess_text_features(self):
        """معالجة السمات النصية"""
        print("جارِ معالجة السمات النصية...")
        
        # دمج جميع السمات النصية
        self.items_df['text_features'] = (
            self.items_df['title'] + ' ' +
            self.items_df['description'] + ' ' +
            self.items_df['keywords'] + ' ' +
            self.items_df['category'] + ' ' +
            self.items_df['subcategory']
        )
        
        # تنظيف النص
        self.items_df['text_features'] = self.items_df['text_features'].apply(
            lambda x: re.sub(r'[^\w\s]', ' ', str(x).lower())
        )
        
        return self.items_df
    
    def create_tfidf_features(self, max_features=1000):
        """إنشاء ميزات TF-IDF من النص"""
        print("جارِ إنشاء ميزات TF-IDF...")
        
        # استخدام TF-IDF Vectorizer
        tfidf = TfidfVectorizer(
            max_features=max_features,
            stop_words='english',
            ngram_range=(1, 2)
        )
        
        self.tfidf_matrix = tfidf.fit_transform(self.items_df['text_features'])
        
        print(f"حجم مصفوفة TF-IDF: {self.tfidf_matrix.shape}")
        print(f"عدد الميزات: {len(tfidf.get_feature_names_out())}")
        
        return self.tfidf_matrix, tfidf
    
    def create_categorical_features(self):
        """إنشاء ميزات من السمات الفئوية"""
        print("جارِ إنشاء ميزات فئوية...")
        
        # ترميز الفئات
        categorical_cols = ['category', 'subcategory']
        encoded_features = []
        
        for col in categorical_cols:
            encoder = LabelEncoder()
            encoded = encoder.fit_transform(self.items_df[col])
            encoded_features.append(encoded)
        
        # تحويل إلى DataFrame
        cat_features_df = pd.DataFrame(
            np.column_stack(encoded_features),
            columns=[f'cat_{i}' for i in range(len(encoded_features))]
        )
        
        return cat_features_df
    
    def create_numerical_features(self):
        """معالجة السمات العددية"""
        print("جارِ معالجة السمات العددية...")
        
        numerical_cols = ['price', 'rating', 'popularity']
        
        # تطبيع السمات العددية
        scaler = MinMaxScaler()
        numerical_features = scaler.fit_transform(self.items_df[numerical_cols])
        
        num_features_df = pd.DataFrame(
            numerical_features,
            columns=[f'num_{col}' for col in numerical_cols]
        )
        
        return num_features_df
    
    def combine_all_features(self):
        """دمج جميع الميزات"""
        print("جارِ دمج جميع الميزات...")
        
        # الحصول على جميع الميزات
        tfidf_matrix, _ = self.create_tfidf_features()
        cat_features = self.create_categorical_features()
        num_features = self.create_numerical_features()
        
        # تحويل TF-IDF إلى مصفوفة كثيفة (يمكن أن يكون هذا مكلفاً للبيانات الكبيرة)
        tfidf_dense = tfidf_matrix.toarray()
        
        # دمج جميع الميزات
        all_features = np.hstack([tfidf_dense, cat_features.values, num_features.values])
        
        print(f"الحجم النهائي للميزات: {all_features.shape}")
        
        return all_features
    
    def calculate_content_similarity(self, features_matrix=None, method='cosine'):
        """حساب التشابه بين العناصر بناءً على المحتوى"""
        print("جارِ حساب التشابه بين العناصر...")
        
        if features_matrix is None:
            features_matrix = self.combine_all_features()
        
        if method == 'cosine':
            # استخدام تشابه جيب التمام
            self.cosine_sim = cosine_similarity(features_matrix)
        elif method == 'linear':
            # استخدام نواة خطية
            self.cosine_sim = linear_kernel(features_matrix)
        
        print(f"حجم مصفوفة التشابه: {self.cosine_sim.shape}")
        
        return self.cosine_sim
    
    def get_content_recommendations(self, item_id, n_recommendations=5, 
                                   diversity_weight=0.3):
        """الحصول على توصيات بناءً على المحتوى"""
        print(f"جارِ توليد توصيات للعنصر {item_id}...")
        
        if self.cosine_sim is None:
            self.calculate_content_similarity()
        
        # العثور على فهرس العنصر
        idx = self.items_df[self.items_df['item_id'] == item_id].index[0]
        
        # الحصول على درجات التشابه
        sim_scores = list(enumerate(self.cosine_sim[idx]))
        
        # فرز حسب التشابه
        sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
        
        # تطبيق التنوع في التوصيات
        recommendations = []
        seen_categories = set()
        
        for i, score in sim_scores[1:]:  # تخطي العنصر نفسه
            if len(recommendations) >= n_recommendations:
                break
            
            current_item = self.items_df.iloc[i]
            current_category = current_item['category']
            
            # تطبيق عامل التنوع
            if current_category in seen_categories:
                diversity_penalty = diversity_weight
            else:
                diversity_penalty = 0
                seen_categories.add(current_category)
            
            # تعديل النتيجة بناءً على التنوع
            adjusted_score = score * (1 - diversity_penalty)
            
            recommendations.append((i, adjusted_score, current_item))
        
        return recommendations
    
    def hybrid_content_scoring(self, content_similarity, popularity_weight=0.2,
                             rating_weight=0.3, price_weight=0.1):
        """تسجيل هجين يجمع بين المحتوى والعوامل الأخرى"""
        print("جارِ حساب التسجيلات الهجينة...")
        
        # تطبيع الشعبية والتقييمات
        popularity_normalized = MinMaxScaler().fit_transform(
            self.items_df[['popularity']]
        ).flatten()
        
        rating_normalized = MinMaxScaler().fit_transform(
            self.items_df[['rating']]
        ).flatten()
        
        # عكس التطبيع للسعر (سعر أقل = أفضل)
        price_normalized = 1 - MinMaxScaler().fit_transform(
            self.items_df[['price']]
        ).flatten()
        
        # حساب الدرجات الهجينة
        hybrid_scores = np.zeros_like(content_similarity)
        
        for i in range(len(content_similarity)):
            for j in range(len(content_similarity)):
                if i != j:
                    content_score = content_similarity[i, j]
                    
                    # جمع العوامل المختلفة
                    hybrid_score = (
                        content_score +
                        popularity_weight * popularity_normalized[j] +
                        rating_weight * rating_normalized[j] +
                        price_weight * price_normalized[j]
                    )
                    
                    hybrid_scores[i, j] = hybrid_score
        
        return hybrid_scores
    
    def analyze_recommendation_quality(self, item_id, recommendations):
        """تحليل جودة التوصيات"""
        print(f"\nتحليل جودة التوصيات للعنصر {item_id}:")
        print("="*50)
        
        target_item = self.items_df[self.items_df['item_id'] == item_id].iloc[0]
        
        print(f"العنصر المستهدف: {target_item['title']}")
        print(f"الفئة: {target_item['category']}")
        print(f"الفئة الفرعية: {target_item['subcategory']}")
        print(f"التقييم: {target_item['rating']:.1f}/5.0")
        print(f"الشعبية: {target_item['popularity']}")
        print(f"السعر: ${target_item['price']:.2f}")
        
        print(f"\nأفضل {len(recommendations)} توصيات:")
        print("-" * 50)
        
        for i, (idx, score, item) in enumerate(recommendations, 1):
            print(f"{i}. {item['title']}")
            print(f"   الفئة: {item['category']}")
            print(f"   الفئة الفرعية: {item['subcategory']}")
            print(f"   درجة التشابه: {score:.4f}")
            print(f"   التقييم: {item['rating']:.1f}/5.0")
            print(f"   السعر: ${item['price']:.2f}")
            print()
        
        # تحليل التنوع
        categories = [item['category'] for _, _, item in recommendations]
        subcategories = [item['subcategory'] for _, _, item in recommendations]
        
        print("تحليل التنوع:")
        print(f"  عدد الفئات الفريدة: {len(set(categories))}/{len(categories)}")
        print(f"  عدد الفئات الفرعية الفريدة: {len(set(subcategories))}/{len(subcategories)}")
        
        # تحليل متوسط خصائص التوصيات
        avg_rating = np.mean([item['rating'] for _, _, item in recommendations])
        avg_price = np.mean([item['price'] for _, _, item in recommendations])
        
        print(f"\nمتوسط خصائص التوصيات:")
        print(f"  متوسط التقييم: {avg_rating:.1f}/5.0")
        print(f"  متوسط السعر: ${avg_price:.2f}")
    
    def visualize_similarity_matrix(self, item_ids=None, n_items=10):
        """تصور مصفوفة التشابه"""
        if item_ids is None:
            item_ids = self.items_df['item_id'].head(n_items).tolist()
        
        indices = [self.items_df[self.items_df['item_id'] == id].index[0] for id in item_ids]
        
        # استخراج جزء من مصفوفة التشابه
        similarity_subset = self.cosine_sim[np.ix_(indices, indices)]
        
        # إنشاء DataFrame للعرض
        similarity_df = pd.DataFrame(
            similarity_subset,
            index=[f"Item {id}" for id in item_ids],
            columns=[f"Item {id}" for id in item_ids]
        )
        
        return similarity_df
    
    def evaluate_recommendation_system(self, test_items, ground_truth):
        """تقييم نظام التوصيات"""
        print("جارِ تقييم نظام التوصيات...")
        
        precision_scores = []
        recall_scores = []
        
        for item_id, true_recommendations in ground_truth.items():
            # الحصول على توصيات النظام
            recommendations = self.get_content_recommendations(item_id, n_recommendations=10)
            recommended_ids = [item['item_id'] for _, _, item in recommendations]
            
            # حساب Precision و Recall
            true_positives = len(set(recommended_ids) & set(true_recommendations))
            
            precision = true_positives / len(recommended_ids) if recommended_ids else 0
            recall = true_positives / len(true_recommendations) if true_recommendations else 0
            
            precision_scores.append(precision)
            recall_scores.append(recall)
        
        avg_precision = np.mean(precision_scores)
        avg_recall = np.mean(recall_scores)
        f1_score = 2 * (avg_precision * avg_recall) / (avg_precision + avg_recall) if (avg_precision + avg_recall) > 0 else 0
        
        print(f"\nنتائج التقييم:")
        print(f"  متوسط Precision: {avg_precision:.3f}")
        print(f"  متوسط Recall: {avg_recall:.3f}")
        print(f"  F1-Score: {f1_score:.3f}")
        
        return {
            'precision': avg_precision,
            'recall': avg_recall,
            'f1_score': f1_score
        }

# مثال للاستخدام
content_system = AdvancedContentBasedFiltering()

# تحميل البيانات
items_df = content_system.load_sample_items(n_items=100)

# معالجة السمات النصية
processed_df = content_system.preprocess_text_features()

# إنشاء ميزات TF-IDF
tfidf_matrix, tfidf_vectorizer = content_system.create_tfidf_features(max_features=500)

# حساب التشابه بين العناصر
similarity_matrix = content_system.calculate_content_similarity()

# الحصول على توصيات لعنصر معين
target_item_id = 1
recommendations = content_system.get_content_recommendations(
    target_item_id, 
    n_recommendations=5,
    diversity_weight=0.2
)

# تحليل جودة التوصيات
content_system.analyze_recommendation_quality(target_item_id, recommendations)

# استخدام التسجيلات الهجينة
hybrid_scores = content_system.hybrid_content_scoring(
    similarity_matrix,
    popularity_weight=0.2,
    rating_weight=0.3,
    price_weight=0.1
)

# تصور مصفوفة التشابه (للعناصر الأولى)
similarity_df = content_system.visualize_similarity_matrix(n_items=8)
print("\nمصفوفة التشابه (8 عناصر أولى):")
print(similarity_df.round(3))

# تقييم النظام (مثال مع بيانات افتراضية)
print("\n" + "="*50)
print("تقييم النظام")
print("="*50)

# بيانات حقيقة الأرض الافتراضية
ground_truth = {
    1: [2, 3, 5, 7, 10],
    5: [1, 6, 8, 12, 15],
    10: [3, 5, 11, 13, 20]
}

evaluation_results = content_system.evaluate_recommendation_system(
    list(ground_truth.keys()),
    ground_truth
)

print("\n" + "="*50)
print("ملخص نظام Content-Based Filtering")
print("="*50)
print("1. يتم تحليل المحتوى النصي للعناصر")
print("2. يتم حساب التشابه بين العناصر")
print("3. يتم توليد توصيات بناءً على التشابه")
print("4. يمكن إضافة عوامل مثل الشعبية والتقييمات")
print("5. يمكن تطبيق التنوع لتجنب التكرار")

# نظام هجين متكامل لأنظمة التوصيات
import pandas as pd
import numpy as np
from scipy.sparse import csr_matrix, hstack
from sklearn.preprocessing import LabelEncoder, MinMaxScaler
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models
import warnings
warnings.filterwarnings('ignore')

class AdvancedHybridRecommendationSystem:
    def __init__(self):
        self.users_df = None
        self.items_df = None
        self.ratings_df = None
        self.user_encoder = LabelEncoder()
        self.item_encoder = LabelEncoder()
        self.scaler = MinMaxScaler()
        
    def load_hybrid_data(self, n_users=200, n_items=100, n_ratings=5000):
        """تحميل بيانات هجينة شاملة"""
        print("جارِ تحميل البيانات الهجينة...")
        np.random.seed(42)
        
        # === بيانات المستخدمين ===
        user_ids = np.arange(1, n_users + 1)
        ages = np.random.randint(18, 65, n_users)
        genders = np.random.choice(['M', 'F'], n_users)
        locations = np.random.choice(['NYC', 'LA', 'Chicago', 'Miami', 'Seattle'], n_users)
        
        self.users_df = pd.DataFrame({
            'user_id': user_ids,
            'age': ages,
            'gender': genders,
            'location': locations
        })
        
        # === بيانات العناصر ===
        item_ids = np.arange(1, n_items + 1)
        categories = np.random.choice(
            ['Electronics', 'Books', 'Movies', 'Music', 'Games', 'Fashion'],
            n_items
        )
        
        # إنشاء أوصاف نصية غنية
        descriptions = []
        titles = []
        
        category_keywords = {
            'Electronics': ['smart', 'digital', 'wireless', 'high-tech', 'innovative'],
            'Books': ['bestseller', 'classic', 'inspirational', 'educational', 'fiction'],
            'Movies': ['blockbuster', 'award-winning', 'thrilling', 'emotional', 'action-packed'],
            'Music': ['chart-topping', 'melodic', 'rhythmic', 'energetic', 'soothing'],
            'Games': ['immersive', 'strategic', 'addictive', 'challenging', 'multiplayer'],
            'Fashion': ['trendy', 'elegant', 'comfortable', 'stylish', 'premium']
        }
        
        for i in range(n_items):
            category = categories[i]
            keywords = category_keywords[category]
            
            title = f"{np.random.choice(keywords)} {category} {i+1}"
            titles.append(title)
            
            description = f"A {np.random.choice(keywords)} {category.lower()} product. "
            description += f"Perfect for {np.random.choice(['beginners', 'enthusiasts', 'professionals', 'everyone'])}. "
            description += f"Features include {np.random.choice(['high quality', 'durability', 'innovation', 'value'])}."
            descriptions.append(description)
        
        prices = np.random.uniform(10, 500, n_items)
        ratings = np.random.uniform(3.0, 5.0, n_items)
        
        self.items_df = pd.DataFrame({
            'item_id': item_ids,
            'title': titles,
            'category': categories,
            'description': descriptions,
            'price': prices,
            'avg_rating': ratings
        })
        
        # === بيانات التقييمات ===
        user_ratings = []
        item_ratings = []
        rating_values = []
        
        for _ in range(n_ratings):
            user = np.random.randint(1, n_users + 1)
            item = np.random.randint(1, n_items + 1)
            
            # جعل التقييمات أكثر واقعية (تعتمد على فئة المستخدم والعنصر)
            user_age = self.users_df[self.users_df['user_id'] == user]['age'].values[0]
            item_category = self.items_df[self.items_df['item_id'] == item]['category'].values[0]
            item_avg_rating = self.items_df[self.items_df['item_id'] == item]['avg_rating'].values[0]
            
            # قاعدة بسيطة للتقييم
            base_rating = item_avg_rating
            
            # تعديل بناءً على عمر المستخدم
            if user_age < 30 and item_category in ['Games', 'Music']:
                base_rating += 0.5
            elif user_age > 40 and item_category in ['Books', 'Electronics']:
                base_rating += 0.3
            
            # إضافة ضوضاء
            rating = np.clip(base_rating + np.random.normal(0, 0.5), 1, 5)
            rating = round(rating * 2) / 2  # تقريب إلى أقرب 0.5
            
            user_ratings.append(user)
            item_ratings.append(item)
            rating_values.append(rating)
        
        self.ratings_df = pd.DataFrame({
            'user_id': user_ratings,
            'item_id': item_ratings,
            'rating': rating_values
        })
        
        print(f"تم تحميل {len(self.users_df)} مستخدم")
        print(f"تم تحميل {len(self.items_df)} عنصر")
        print(f"تم تحميل {len(self.ratings_df)} تقييم")
        print(f"كثافة التقييمات: {len(self.ratings_df) / (len(self.users_df) * len(self.items_df)):.2%}")
        
        return self.users_df, self.items_df, self.ratings_df
    
    def preprocess_hybrid_data(self):
        """معالجة البيانات للأنظمة الهجينة"""
        print("جارِ معالجة البيانات الهجينة...")
        
        # === ترميز المستخدمين والعناصر ===
        self.ratings_df['user_encoded'] = self.user_encoder.fit_transform(
            self.ratings_df['user_id']
        )
        self.ratings_df['item_encoded'] = self.item_encoder.fit_transform(
            self.ratings_df['item_id']
        )
        
        # === معالجة سمات المستخدمين ===
        # العمر
        self.users_df['age_normalized'] = self.scaler.fit_transform(
            self.users_df[['age']]
        )
        
        # النوع
        self.users_df['gender_encoded'] = LabelEncoder().fit_transform(
            self.users_df['gender']
        )
        
        # الموقع
        self.users_df['location_encoded'] = LabelEncoder().fit_transform(
            self.users_df['location']
        )
        
        # === معالجة سمات العناصر ===
        # السعر
        self.items_df['price_normalized'] = self.scaler.fit_transform(
            self.items_df[['price']]
        )
        
        # التقييم المتوسط
        self.items_df['avg_rating_normalized'] = self.scaler.fit_transform(
            self.items_df[['avg_rating']]
        )
        
        # الفئة
        self.items_df['category_encoded'] = LabelEncoder().fit_transform(
            self.items_df['category']
        )
        
        # === معالجة النصوص ===
        # دمج العنوان والوصف
        self.items_df['text_content'] = self.items_df['title'] + ' ' + self.items_df['description']
        
        # TF-IDF للنصوص
        tfidf = TfidfVectorizer(max_features=100, stop_words='english')
        text_features = tfidf.fit_transform(self.items_df['text_content'])
        
        print("تمت معالجة البيانات الهجينة بنجاح")
        
        return {
            'user_features': self.users_df[['age_normalized', 'gender_encoded', 'location_encoded']].values,
            'item_features': self.items_df[['price_normalized', 'avg_rating_normalized', 'category_encoded']].values,
            'text_features': text_features,
            'user_ids': self.ratings_df['user_encoded'].values,
            'item_ids': self.ratings_df['item_encoded'].values,
            'ratings': self.ratings_df['rating'].values
        }
    
    def create_hybrid_model(self, n_users, n_items, user_feature_dim=3, item_feature_dim=3):
        """إنشاء نموذج هجين باستخدام TensorFlow/Keras"""
        print("جارِ إنشاء النموذج الهجين...")
        
        # === مدخلات النموذج ===
        user_id_input = layers.Input(shape=(1,), name='user_id_input')
        item_id_input = layers.Input(shape=(1,), name='item_id_input')
        user_features_input = layers.Input(shape=(user_feature_dim,), name='user_features_input')
        item_features_input = layers.Input(shape=(item_feature_dim,), name='item_features_input')
        
        # === تضمين المستخدمين والعناصر ===
        user_embedding = layers.Embedding(
            input_dim=n_users,
            output_dim=50,
            name='user_embedding'
        )(user_id_input)
        
        item_embedding = layers.Embedding(
            input_dim=n_items,
            output_dim=50,
            name='item_embedding'
        )(item_id_input)
        
        # تسوية المدخلات المتعددة الأبعاد
        user_embedding_flat = layers.Flatten()(user_embedding)
        item_embedding_flat = layers.Flatten()(item_embedding)
        
        # === دمج جميع الميزات ===
        combined = layers.Concatenate()([
            user_embedding_flat,
            item_embedding_flat,
            user_features_input,
            item_features_input
        ])
        
        # === الشبكة العصبية العميقة ===
        x = layers.Dense(128, activation='relu')(combined)
        x = layers.BatchNormalization()(x)
        x = layers.Dropout(0.3)(x)
        
        x = layers.Dense(64, activation='relu')(x)
        x = layers.BatchNormalization()(x)
        x = layers.Dropout(0.2)(x)
        
        x = layers.Dense(32, activation='relu')(x)
        
        # === طبقة الإخراج ===
        output = layers.Dense(1, activation='linear', name='rating_prediction')(x)
        
        # === إنشاء النموذج ===
        model = models.Model(
            inputs=[user_id_input, item_id_input, user_features_input, item_features_input],
            outputs=output
        )
        
        # تجميع النموذج
        model.compile(
            optimizer=keras.optimizers.Adam(learning_rate=0.001),
            loss='mse',
            metrics=['mae', 'mse']
        )
        
        print("تم إنشاء النموذج الهجين بنجاح")
        model.summary()
        
        return model
    
    def prepare_training_data(self, processed_data, test_size=0.2):
        """تحضير بيانات التدريب"""
        print("جارِ تحضير بيانات التدريب...")
        
        # تقسيم البيانات
        indices = np.arange(len(processed_data['user_ids']))
        train_idx, test_idx = train_test_split(indices, test_size=test_size, random_state=42)
        
        # بيانات التدريب
        X_train = [
            processed_data['user_ids'][train_idx],
            processed_data['item_ids'][train_idx],
            processed_data['user_features'][processed_data['user_ids'][train_idx]],
            processed_data['item_features'][processed_data['item_ids'][train_idx]]
        ]
        y_train = processed_data['ratings'][train_idx]
        
        # بيانات الاختبار
        X_test = [
            processed_data['user_ids'][test_idx],
            processed_data['item_ids'][test_idx],
            processed_data['user_features'][processed_data['user_ids'][test_idx]],
            processed_data['item_features'][processed_data['item_ids'][test_idx]]
        ]
        y_test = processed_data['ratings'][test_idx]
        
        print(f"بيانات التدريب: {len(train_idx)} عينة")
        print(f"بيانات الاختبار: {len(test_idx)} عينة")
        
        return X_train, y_train, X_test, y_test, train_idx, test_idx
    
    def train_hybrid_model(self, model, X_train, y_train, X_test, y_test, epochs=50, batch_size=32):
        """تدريب النموذج الهجين"""
        print("بدء تدريب النموذج الهجين...")
        
        # إعداد callbacks
        callbacks = [
            keras.callbacks.EarlyStopping(
                monitor='val_loss',
                patience=10,
                restore_best_weights=True,
                verbose=1
            ),
            keras.callbacks.ReduceLROnPlateau(
                monitor='val_loss',
                factor=0.5,
                patience=5,
                min_lr=0.00001,
                verbose=1
            )
        ]
        
        # تدريب النموذج
        history = model.fit(
            X_train, y_train,
            validation_data=(X_test, y_test),
            epochs=epochs,
            batch_size=batch_size,
            callbacks=callbacks,
            verbose=1
        )
        
        print("اكتمل تدريب النموذج")
        
        return history, model
    
    def evaluate_model_performance(self, model, X_test, y_test):
        """تقييم أداء النموذج"""
        print("جارِ تقييم أداء النموذج...")
        
        # التنبؤ
        predictions = model.predict(X_test, verbose=0).flatten()
        
        # حساب مقاييس التقييم
        mse = mean_squared_error(y_test, predictions)
        rmse = np.sqrt(mse)
        mae = mean_absolute_error(y_test, predictions)
        
        # حساب دقة التصنيف (اعتبار 4+ تقييم إيجابي)
        threshold = 4.0
        pred_binary = (predictions >= threshold).astype(int)
        true_binary = (y_test >= threshold).astype(int)
        
        accuracy = np.mean(pred_binary == true_binary)
        
        print(f"\nنتائج التقييم:")
        print(f"MSE: {mse:.4f}")
        print(f"RMSE: {rmse:.4f}")
        print(f"MAE: {mae:.4f}")
        print(f"الدقة (عتبة {threshold}+): {accuracy:.2%}")
        
        return {
            'mse': mse,
            'rmse': rmse,
            'mae': mae,
            'accuracy': accuracy,
            'predictions': predictions,
            'actual': y_test
        }
    
    def generate_recommendations(self, model, user_id, n_recommendations=10, 
                                diversity_factor=0.3):
        """توليد توصيات هجينة لمستخدم"""
        print(f"جارِ توليد توصيات للمستخدم {user_id}...")
        
        # التحقق من وجود المستخدم
        if user_id not in self.user_encoder.classes_:
            print(f"المستخدم {user_id} غير موجود في البيانات")
            return None
        
        user_encoded = self.user_encoder.transform([user_id])[0]
        
        # الحصول على سمات المستخدم
        user_features = self.users_df[self.users_df['user_id'] == user_id][
            ['age_normalized', 'gender_encoded', 'location_encoded']
        ].values[0]
        
        # احتساب النتائج لجميع العناصر
        all_item_ids = np.arange(len(self.item_encoder.classes_))
        all_user_ids = np.full_like(all_item_ids, user_encoded)
        
        # الحصول على سمات جميع العناصر
        all_item_features = self.items_df[
            ['price_normalized', 'avg_rating_normalized', 'category_encoded']
        ].values
        
        # تكرار سمات المستخدم لكل عنصر
        all_user_features = np.tile(user_features, (len(all_item_ids), 1))
        
        # التنبؤ
        scores = model.predict(
            [all_user_ids, all_item_ids, all_user_features, all_item_features],
            verbose=0
        ).flatten()
        
        # فرز العناصر حسب النتيجة
        sorted_indices = np.argsort(-scores)
        
        # تطبيق التنوع
        recommendations = []
        seen_categories = set()
        
        for idx in sorted_indices:
            if len(recommendations) >= n_recommendations:
                break
            
            item_id = self.item_encoder.inverse_transform([idx])[0]
            item_data = self.items_df[self.items_df['item_id'] == item_id].iloc[0]
            category = item_data['category']
            
            # تطبيق عامل التنوع
            if category in seen_categories:
                diversity_penalty = diversity_factor
            else:
                diversity_penalty = 0
                seen_categories.add(category)
            
            # تعديل النتيجة
            adjusted_score = scores[idx] * (1 - diversity_penalty)
            
            recommendations.append({
                'item_id': int(item_id),
                'title': item_data['title'],
                'category': category,
                'predicted_rating': float(scores[idx]),
                'adjusted_score': float(adjusted_score),
                'price': float(item_data['price']),
                'avg_rating': float(item_data['avg_rating'])
            })
        
        # إعادة الفرز بناءً على النتيجة المعدلة
        recommendations.sort(key=lambda x: x['adjusted_score'], reverse=True)
        
        return recommendations
    
    def analyze_recommendation_quality(self, recommendations, user_id):
        """تحليل جودة التوصيات"""
        print(f"\n" + "="*60)
        print(f"تحليل جودة التوصيات للمستخدم {user_id}")
        print("="*60)
        
        if not recommendations:
            print("لا توجد توصيات متاحة")
            return
        
        user_data = self.users_df[self.users_df['user_id'] == user_id].iloc[0]
        
        print(f"\nمعلومات المستخدم:")
        print(f"  العمر: {user_data['age']}")
        print(f"  النوع: {user_data['gender']}")
        print(f"  الموقع: {user_data['location']}")
        
        print(f"\nأفضل {len(recommendations)} توصيات:")
        print("-" * 60)
        
        for i, rec in enumerate(recommendations, 1):
            print(f"{i}. {rec['title']}")
            print(f"   الفئة: {rec['category']}")
            print(f"   التقييم المتوقع: {rec['predicted_rating']:.2f}/5.0")
            print(f"   التقييم الحالي: {rec['avg_rating']:.1f}/5.0")
            print(f"   السعر: ${rec['price']:.2f}")
            print()
        
        # تحليل التنوع
        categories = [rec['category'] for rec in recommendations]
        avg_price = np.mean([rec['price'] for rec in recommendations])
        avg_predicted_rating = np.mean([rec['predicted_rating'] for rec in recommendations])
        
        print(f"تحليل التنوع:")
        print(f"  عدد الفئات الفريدة: {len(set(categories))}/{len(categories)}")
        print(f"  متوسط السعر: ${avg_price:.2f}")
        print(f"  متوسط التقييم المتوقع: {avg_predicted_rating:.2f}/5.0")
        
        # تحليل العلاقة بين السعر والتقييم
        prices = [rec['price'] for rec in recommendations]
        ratings = [rec['predicted_rating'] for rec in recommendations]
        
        if len(prices) > 1:
            price_rating_corr = np.corrcoef(prices, ratings)[0, 1]
            print(f"  ارتباط السعر بالتقييم: {price_rating_corr:.3f}")
    
    def compare_hybrid_with_baseline(self):
        """مقارنة النموذج الهجين مع النماذج الأساسية"""
        print("\n" + "="*60)
        print("مقارنة النموذج الهجين مع النماذج الأساسية")
        print("="*60)
        
        # هذا قسم نظري في هذا المثال
        # في التطبيق الحقيقي، يمكن تنفيذ نماذج أساسية ومقارنتها
        
        print("\nمزايا النموذج الهجين:")
        print("1. يجمع بين قوة Collaborative Filtering و Content-Based Filtering")
        print("2. يتعامل مع مشكلة البداية الباردة (Cold Start)")
        print("3. يوفر توصيات أكثر تنوعاً وشخصية")
        print("4. يمكنه التعلم من بيانات المستخدمين والعناصر")
        
        print("\nمقارنة الأداء المتوقع:")
        print("  Collaborative Filtering فقط: جيد مع بيانات كثيفة")
        print("  Content-Based فقط: جيد مع بيانات العناصر الغنية")
        print("  النموذج الهجين: أفضل أداء في معظم السيناريوهات")
        
        return {
            'hybrid_advantages': [
                'التعامل مع البداية الباردة',
                'جمع مصادر بيانات متعددة',
                'توصيات أكثر شمولية',
                'أداء أفضل في السيناريوهات المختلفة'
            ]
        }

# مثال للاستخدام
hybrid_system = AdvancedHybridRecommendationSystem()

# تحميل البيانات
users, items, ratings = hybrid_system.load_hybrid_data(
    n_users=200,
    n_items=100,
    n_ratings=5000
)

# معالجة البيانات
processed_data = hybrid_system.preprocess_hybrid_data()

# إنشاء النموذج
n_users = len(hybrid_system.user_encoder.classes_)
n_items = len(hybrid_system.item_encoder.classes_)

hybrid_model = hybrid_system.create_hybrid_model(
    n_users=n_users,
    n_items=n_items,
    user_feature_dim=3,
    item_feature_dim=3
)

# تحضير بيانات التدريب
X_train, y_train, X_test, y_test, train_idx, test_idx = hybrid_system.prepare_training_data(
    processed_data,
    test_size=0.2
)

# تدريب النموذج (يمكن تقليل عدد الدورات للاختبار)
history, trained_model = hybrid_system.train_hybrid_model(
    hybrid_model,
    X_train, y_train,
    X_test, y_test,
    epochs=30,
    batch_size=64
)

# تقييم النموذج
evaluation_results = hybrid_system.evaluate_model_performance(
    trained_model,
    X_test, y_test
)

# توليد توصيات لمستخدم
user_id = 10
recommendations = hybrid_system.generate_recommendations(
    trained_model,
    user_id,
    n_recommendations=8,
    diversity_factor=0.2
)

# تحليل جودة التوصيات
if recommendations:
    hybrid_system.analyze_recommendation_quality(recommendations, user_id)

# مقارنة مع النماذج الأساسية
comparison = hybrid_system.compare_hybrid_with_baseline()

print("\n" + "="*60)
print("ملخص النظام الهجين")
print("="*60)
print("✅ يجمع بين مزايا نماذج متعددة")
print("✅ يتعامل مع بيانات متنوعة (نصية، عددية، فئوية)")
print("✅ يوفر توصيات مخصصة وشخصية")
print("✅ يدعم التنوع في التوصيات")
print("✅ قابل للتطوير مع البيانات الكبيرة")