باحث الذكاء الاصطناعي

# نظام متقدم لمعالجة البيانات البحثية
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler

class ResearchDataProcessor:
    def __init__(self, data_path):
        self.data = pd.read_csv(data_path)
        self.scaler = StandardScaler()
    
    def clean_research_data(self):
        # تنظيف البيانات البحثية
        self.data = self.data.dropna()
        
        # إزالة القيم المتطرفة
        numeric_cols = self.data.select_dtypes(include=[np.number]).columns
        for col in numeric_cols:
            Q1 = self.data[col].quantile(0.25)
            Q3 = self.data[col].quantile(0.75)
            IQR = Q3 - Q1
            lower_bound = Q1 - 1.5 * IQR
            upper_bound = Q3 + 1.5 * IQR
            
            self.data = self.data[
                (self.data[col] >= lower_bound) & 
                (self.data[col] <= upper_bound)
            ]
        
        return self.data
    
    def normalize_features(self, feature_cols):
        # تطبيع الميزات
        features = self.data[feature_cols]
        normalized_features = self.scaler.fit_transform(features)
        self.data[feature_cols] = normalized_features
        
        return self.data
    
    def split_for_research(self, target_col, test_size=0.2):
        # تقسيم البيانات للبحث
        X = self.data.drop(columns=[target_col])
        y = self.data[target_col]
        
        from sklearn.model_selection import train_test_split
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=test_size, random_state=42, stratify=y
        )
        
        return X_train, X_test, y_train, y_test

# مثال للاستخدام في بحث
processor = ResearchDataProcessor('research_data.csv')
clean_data = processor.clean_research_data()
normalized_data = processor.normalize_features(['feature1', 'feature2', 'feature3'])
X_train, X_test, y_train, y_test = processor.split_for_research('target')

# تطبيقات متقدمة للجبر الخطي في أبحاث الذكاء الاصطناعي
import numpy as np
from scipy.linalg import svd, eig

class LinearAlgebraResearch:
    def __init__(self):
        pass
    
    def compute_svd(self, matrix):
        """تحليل القيم المفردة (SVD)"""
        U, S, Vt = svd(matrix)
        
        return {
            'U': U,  # مصفوفة المتجهات الذاتية اليسرى
            'S': S,  # القيم المفردة
            'Vt': Vt,  # مصفوفة المتجهات الذاتية اليمنى
            'rank': np.linalg.matrix_rank(matrix),
            'condition_number': np.linalg.cond(matrix)
        }
    
    def eigenvalue_decomposition(self, matrix):
        """تحليل القيم الذاتية"""
        eigenvalues, eigenvectors = eig(matrix)
        
        return {
            'eigenvalues': eigenvalues,
            'eigenvectors': eigenvectors,
            'dominant_eigenvalue': np.max(np.abs(eigenvalues)),
            'trace': np.trace(matrix),
            'determinant': np.linalg.det(matrix)
        }
    
    def matrix_factorization(self, matrix, rank):
        """تحليل المصفوفة لعوامل منخفضة الرتبة"""
        # استخدام SVD للتحليل
        U, S, Vt = svd(matrix)
        
        # الحفاظ على الرتبة المطلوبة فقط
        U_k = U[:, :rank]
        S_k = np.diag(S[:rank])
        Vt_k = Vt[:rank, :]
        
        # إعادة بناء المصفوفة
        reconstructed = U_k @ S_k @ Vt_k
        
        return {
            'U_k': U_k,
            'S_k': S_k,
            'Vt_k': Vt_k,
            'reconstructed': reconstructed,
            'reconstruction_error': np.linalg.norm(matrix - reconstructed, 'fro')
        }
    
    def neural_network_analysis(self, weight_matrices):
        """تحليل مصفوفات الأوزان في الشبكات العصبية"""
        analysis_results = {}
        
        for i, W in enumerate(weight_matrices):
            # تحليل كل مصفوفة أوزان
            svd_result = self.compute_svd(W)
            eig_result = self.eigenvalue_decomposition(W)
            
            analysis_results[f'layer_{i+1}'] = {
                'shape': W.shape,
                'norm': np.linalg.norm(W),
                'singular_values': svd_result['S'],
                'eigenvalues': eig_result['eigenvalues'],
                'rank': svd_result['rank'],
                'condition_number': svd_result['condition_number']
            }
        
        return analysis_results

# مثال للاستخدام في بحث الشبكات العصبية
researcher = LinearAlgebraResearch()

# مصفوفة وزن نموذجية لطبقة عصبية
weight_matrix = np.random.randn(100, 50)

# تحليل المصفوفة
svd_analysis = researcher.compute_svd(weight_matrix)
eig_analysis = researcher.eigenvalue_decomposition(weight_matrix)

print(f"رتبة المصفوفة: {svd_analysis['rank']}")
print(f"رقم الحالة: {svd_analysis['condition_number']:.2f}")
print(f"القيمة الذاتية المهيمنة: {eig_analysis['dominant_eigenvalue']:.4f}")

# نظام بحث متقدم للشبكات العصبية
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from torch.utils.data import DataLoader, TensorDataset
import matplotlib.pyplot as plt

class NeuralNetworkResearcher:
    def __init__(self, input_size, hidden_sizes, output_size):
        self.input_size = input_size
        self.hidden_sizes = hidden_sizes
        self.output_size = output_size
        self.model = self.build_model()
        self.training_history = []
    
    def build_model(self):
        """بناء نموذج شبكة عصبية متقدم للبحث"""
        layers = []
        
        # طبقة الإدخال
        prev_size = self.input_size
        
        # الطبقات المخفية
        for i, hidden_size in enumerate(self.hidden_sizes):
            layers.append(nn.Linear(prev_size, hidden_size))
            layers.append(nn.BatchNorm1d(hidden_size))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(0.3))
            prev_size = hidden_size
        
        # طبقة الإخراج
        layers.append(nn.Linear(prev_size, self.output_size))
        
        model = nn.Sequential(*layers)
        
        # تهيئة الأوزان
        self.initialize_weights(model)
        
        return model
    
    def initialize_weights(self, model):
        """تهيئة الأوزان باستخدام طرق متقدمة"""
        for module in model.modules():
            if isinstance(module, nn.Linear):
                # تهيئة Xavier/Glorot للأوزان
                nn.init.xavier_uniform_(module.weight)
                if module.bias is not None:
                    nn.init.zeros_(module.bias)
            elif isinstance(module, nn.BatchNorm1d):
                nn.init.ones_(module.weight)
                nn.init.zeros_(module.bias)
    
    def train_research_model(self, X_train, y_train, X_val, y_val, 
                           epochs=100, learning_rate=0.001):
        """تدريب النموذج للبحث العلمي"""
        # تحويل البيانات إلى tensors
        X_train_tensor = torch.FloatTensor(X_train)
        y_train_tensor = torch.LongTensor(y_train)
        X_val_tensor = torch.FloatTensor(X_val)
        y_val_tensor = torch.LongTensor(y_val)
        
        # إنشاء DataLoader
        train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
        train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
        
        # دالة الخسارة والمحسن
        criterion = nn.CrossEntropyLoss()
        optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)
        
        # جدولة معدل التعلم
        scheduler = optim.lr_scheduler.ReduceLROnPlateau(
            optimizer, mode='min', factor=0.5, patience=10
        )
        
        # حلقة التدريب
        for epoch in range(epochs):
            # وضع التدريب
            self.model.train()
            train_loss = 0.0
            
            for batch_X, batch_y in train_loader:
                optimizer.zero_grad()
                
                # التمرير الأمامي
                outputs = self.model(batch_X)
                loss = criterion(outputs, batch_y)
                
                # الانتشار الخلفي
                loss.backward()
                
                # قص التدرج (Gradient Clipping)
                torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
                
                optimizer.step()
                train_loss += loss.item()
            
            # وضع التقييم
            self.model.eval()
            with torch.no_grad():
                val_outputs = self.model(X_val_tensor)
                val_loss = criterion(val_outputs, y_val_tensor)
                
                # حساب الدقة
                _, val_predicted = torch.max(val_outputs, 1)
                val_accuracy = (val_predicted == y_val_tensor).float().mean()
            
            # تحديث معدل التعلم
            scheduler.step(val_loss)
            
            # حفظ تاريخ التدريب
            epoch_stats = {
                'epoch': epoch + 1,
                'train_loss': train_loss / len(train_loader),
                'val_loss': val_loss.item(),
                'val_accuracy': val_accuracy.item(),
                'learning_rate': optimizer.param_groups[0]['lr']
            }
            
            self.training_history.append(epoch_stats)
            
            if (epoch + 1) % 10 == 0:
                print(f"Epoch {epoch+1}/{epochs}: "
                      f"Train Loss: {epoch_stats['train_loss']:.4f}, "
                      f"Val Loss: {epoch_stats['val_loss']:.4f}, "
                      f"Val Acc: {epoch_stats['val_accuracy']:.4f}")
        
        return self.training_history
    
    def analyze_model_performance(self):
        """تحليل أداء النموذج للبحث"""
        if not self.training_history:
            return None
        
        history = np.array([
            [h['train_loss'], h['val_loss'], h['val_accuracy'], h['learning_rate']]
            for h in self.training_history
        ])
        
        analysis = {
            'final_train_loss': self.training_history[-1]['train_loss'],
            'final_val_loss': self.training_history[-1]['val_loss'],
            'final_val_accuracy': self.training_history[-1]['val_accuracy'],
            'best_val_accuracy': max(h['val_accuracy'] for h in self.training_history),
            'convergence_epoch': self.find_convergence_epoch(),
            'overfitting_analysis': self.check_overfitting()
        }
        
        return analysis
    
    def find_convergence_epoch(self):
        """العثور على عصر التقارب"""
        if len(self.training_history) < 20:
            return len(self.training_history)
        
        # البحث عن عصر استقرار الخسارة
        val_losses = [h['val_loss'] for h in self.training_history]
        
        for i in range(10, len(val_losses)):
            window = val_losses[i-10:i]
            if max(window) - min(window) < 0.001:
                return i
        
        return len(self.training_history)
    
    def check_overfitting(self):
        """فحص مشكلة الإفراط في التخصيص (Overfitting)"""
        if len(self.training_history) < 20:
            return "غير كافي البيانات للتحليل"
        
        early_train_loss = np.mean([h['train_loss'] for h in self.training_history[:10]])
        early_val_loss = np.mean([h['val_loss'] for h in self.training_history[:10]])
        
        late_train_loss = np.mean([h['train_loss'] for h in self.training_history[-10:]])
        late_val_loss = np.mean([h['val_loss'] for h in self.training_history[-10:]])
        
        train_gap = late_train_loss - early_train_loss
        val_gap = late_val_loss - early_val_loss
        
        if val_gap > train_gap * 2:
            return "إفراط في التخصيص (Overfitting)"
        elif train_gap > val_gap * 2:
            return "تقصير في التخصيص (Underfitting)"
        else:
            return "أداء متوازن"
    
    def visualize_training(self):
        """تصور عملية التدريب"""
        epochs = [h['epoch'] for h in self.training_history]
        train_losses = [h['train_loss'] for h in self.training_history]
        val_losses = [h['val_loss'] for h in self.training_history]
        val_accuracies = [h['val_accuracy'] for h in self.training_history]
        
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
        
        # رسم الخسارة
        ax1.plot(epochs, train_losses, label='Train Loss')
        ax1.plot(epochs, val_losses, label='Validation Loss')
        ax1.set_xlabel('Epoch')
        ax1.set_ylabel('Loss')
        ax1.set_title('Training and Validation Loss')
        ax1.legend()
        ax1.grid(True)
        
        # رسم الدقة
        ax2.plot(epochs, val_accuracies, label='Validation Accuracy', color='green')
        ax2.set_xlabel('Epoch')
        ax2.set_ylabel('Accuracy')
        ax2.set_title('Validation Accuracy')
        ax2.legend()
        ax2.grid(True)
        
        plt.tight_layout()
        return fig

# نظام بحث متقدم باستخدام PyTorch
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from torch.cuda.amp import autocast, GradScaler

class AdvancedResearchFramework:
    def __init__(self, model_architecture, device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.device = torch.device(device)
        self.model = model_architecture.to(self.device)
        self.scaler = GradScaler()  # لتسريع التدريب المختلط
        self.research_log = []
    
    class ResearchDataset(Dataset):
        """فئة مخصصة لمجموعات البيانات البحثية"""
        def __init__(self, features, labels, transform=None):
            self.features = torch.FloatTensor(features)
            self.labels = torch.LongTensor(labels)
            self.transform = transform
        
        def __len__(self):
            return len(self.features)
        
        def __getitem__(self, idx):
            sample = self.features[idx], self.labels[idx]
            
            if self.transform:
                sample = self.transform(sample)
            
            return sample
    
    def prepare_research_data(self, X, y, test_size=0.2, val_size=0.1):
        """تحضير البيانات للبحث العلمي"""
        # تقسيم التدريب/الاختبار
        X_temp, X_test, y_temp, y_test = train_test_split(
            X, y, test_size=test_size, random_state=42, stratify=y
        )
        
        # تقسيم التدريب/التحقق
        val_ratio = val_size / (1 - test_size)
        X_train, X_val, y_train, y_val = train_test_split(
            X_temp, y_temp, test_size=val_ratio, random_state=42, stratify=y_temp
        )
        
        # إنشاء DataLoaders
        train_dataset = self.ResearchDataset(X_train, y_train)
        val_dataset = self.ResearchDataset(X_val, y_val)
        test_dataset = self.ResearchDataset(X_test, y_test)
        
        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)
        val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=4)
        test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4)
        
        return train_loader, val_loader, test_loader
    
    def train_with_advanced_techniques(self, train_loader, val_loader, 
                                      epochs=100, learning_rate=0.001):
        """التدريب باستخدام تقنيات بحثية متقدمة"""
        # إعداد المحسن مع weight decay
        optimizer = optim.AdamW(
            self.model.parameters(), 
            lr=learning_rate, 
            weight_decay=1e-4
        )
        
        # جدولة معدل التعلم مع warmup
        scheduler = optim.lr_scheduler.OneCycleLR(
            optimizer, 
            max_lr=learning_rate,
            epochs=epochs,
            steps_per_epoch=len(train_loader),
            pct_start=0.1  # 10% من الحلقات للـ warmup
        )
        
        # دالة الخسارة مع label smoothing
        criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
        
        best_val_loss = float('inf')
        patience_counter = 0
        patience = 20
        
        for epoch in range(epochs):
            # التدريب
            self.model.train()
            train_loss = 0.0
            
            for batch_X, batch_y in train_loader:
                batch_X, batch_y = batch_X.to(self.device), batch_y.to(self.device)
                
                optimizer.zero_grad()
                
                # تدريب مختلط الدقة (Mixed Precision Training)
                with autocast():
                    outputs = self.model(batch_X)
                    loss = criterion(outputs, batch_y)
                
                # الانتشار الخلفي باستخدام GradScaler
                self.scaler.scale(loss).backward()
                
                # قص التدرج (Gradient Clipping)
                self.scaler.unscale_(optimizer)
                torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
                
                self.scaler.step(optimizer)
                self.scaler.update()
                
                scheduler.step()
                
                train_loss += loss.item()
            
            avg_train_loss = train_loss / len(train_loader)
            
            # التقييم
            val_loss, val_accuracy = self.evaluate_model(val_loader, criterion)
            
            # تسجيل نتائج البحث
            epoch_log = {
                'epoch': epoch + 1,
                'train_loss': avg_train_loss,
                'val_loss': val_loss,
                'val_accuracy': val_accuracy,
                'learning_rate': optimizer.param_groups[0]['lr']
            }
            
            self.research_log.append(epoch_log)
            
            # حفظ أفضل نموذج
            if val_loss < best_val_loss:
                best_val_loss = val_loss
                patience_counter = 0
                self.save_best_model()
            else:
                patience_counter += 1
            
            # التوقف المبكر (Early Stopping)
            if patience_counter >= patience:
                print(f"التوقف المبكر في العصر {epoch + 1}")
                break
            
            if (epoch + 1) % 10 == 0:
                print(f"Epoch {epoch + 1}/{epochs}: "
                      f"Train Loss: {avg_train_loss:.4f}, "
                      f"Val Loss: {val_loss:.4f}, "
                      f"Val Acc: {val_accuracy:.4f}, "
                      f"LR: {optimizer.param_groups[0]['lr']:.6f}")
        
        return self.research_log
    
    def evaluate_model(self, data_loader, criterion):
        """تقييم النموذج"""
        self.model.eval()
        total_loss = 0.0
        correct = 0
        total = 0
        
        with torch.no_grad():
            for batch_X, batch_y in data_loader:
                batch_X, batch_y = batch_X.to(self.device), batch_y.to(self.device)
                
                outputs = self.model(batch_X)
                loss = criterion(outputs, batch_y)
                
                total_loss += loss.item()
                
                _, predicted = torch.max(outputs, 1)
                total += batch_y.size(0)
                correct += (predicted == batch_y).sum().item()
        
        avg_loss = total_loss / len(data_loader)
        accuracy = correct / total
        
        return avg_loss, accuracy
    
    def save_best_model(self):
        """حفظ أفضل نموذج"""
        torch.save({
            'model_state_dict': self.model.state_dict(),
            'research_log': self.research_log
        }, 'best_research_model.pth')
    
    def load_best_model(self):
        """تحميل أفضل نموذج"""
        checkpoint = torch.load('best_research_model.pth', map_location=self.device)
        self.model.load_state_dict(checkpoint['model_state_dict'])
        self.research_log = checkpoint['research_log']
    
    def analyze_model_interpretability(self, data_loader):
        """تحليل قابلية تفسير النموذج"""
        self.model.eval()
        
        # جمع التوقعات
        all_predictions = []
        all_confidences = []
        all_true_labels = []
        
        with torch.no_grad():
            for batch_X, batch_y in data_loader:
                batch_X = batch_X.to(self.device)
                
                outputs = self.model(batch_X)
                probabilities = torch.softmax(outputs, dim=1)
                confidences, predictions = torch.max(probabilities, 1)
                
                all_predictions.extend(predictions.cpu().numpy())
                all_confidences.extend(confidences.cpu().numpy())
                all_true_labels.extend(batch_y.numpy())
        
        # حساب مقاييس التفسير
        from sklearn.metrics import confusion_matrix, classification_report
        
        cm = confusion_matrix(all_true_labels, all_predictions)
        report = classification_report(all_true_labels, all_predictions, output_dict=True)
        
        interpretability_analysis = {
            'confusion_matrix': cm,
            'classification_report': report,
            'average_confidence': np.mean(all_confidences),
            'confidence_distribution': {
                'min': np.min(all_confidences),
                'max': np.max(all_confidences),
                'std': np.std(all_confidences)
            },
            'calibration_error': self.calculate_calibration_error(all_confidences, all_predictions, all_true_labels)
        }
        
        return interpretability_analysis
    
    def calculate_calibration_error(self, confidences, predictions, true_labels):
        """حساب خطأ المعايرة"""
        bins = np.linspace(0, 1, 11)
        bin_indices = np.digitize(confidences, bins) - 1
        
        calibration_error = 0
        total_samples = len(true_labels)
        
        for i in range(len(bins) - 1):
            mask = bin_indices == i
            if np.sum(mask) > 0:
                bin_confidence = np.mean(confidences[mask])
                bin_accuracy = np.mean(predictions[mask] == true_labels[mask])
                calibration_error += np.sum(mask) * np.abs(bin_confidence - bin_accuracy)
        
        return calibration_error / total_samples
    
    def generate_research_report(self):
        """توليد تقرير بحثي شامل"""
        report = {
            'model_summary': str(self.model),
            'num_parameters': sum(p.numel() for p in self.model.parameters()),
            'training_history': self.research_log,
            'final_performance': self.research_log[-1] if self.research_log else None,
            'best_performance': min(self.research_log, key=lambda x: x['val_loss']) if self.research_log else None
        }
        
        return report

# نظام بحث متقدم للتعلم المعزز
import gym
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from collections import deque
import random
import matplotlib.pyplot as plt

class RLResearcher:
    def __init__(self, env_name='CartPole-v1', device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.env = gym.make(env_name)
        self.device = torch.device(device)
        
        # معلمات الشبكة
        self.state_size = self.env.observation_space.shape[0]
        self.action_size = self.env.action_space.n
        
        # بناء النموذج
        self.model = self.build_dqn_model().to(self.device)
        self.target_model = self.build_dqn_model().to(self.device)
        self.update_target_model()
        
        # معلمات التعلم
        self.gamma = 0.99  # عامل الخصم
        self.epsilon = 1.0  # استكشاف
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.learning_rate = 0.001
        self.batch_size = 64
        
        # الذاكرة
        self.memory = deque(maxlen=2000)
        
        # المحسن
        self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
        self.criterion = nn.MSELoss()
        
        # سجل البحث
        self.research_log = {
            'episodes': [],
            'rewards': [],
            'epsilons': [],
            'losses': []
        }
    
    def build_dqn_model(self):
        """بناء نموذج DQN للبحث"""
        model = nn.Sequential(
            nn.Linear(self.state_size, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, self.action_size)
        )
        return model
    
    def update_target_model(self):
        """تحديث النموذج الهدف"""
        self.target_model.load_state_dict(self.model.state_dict())
    
    def remember(self, state, action, reward, next_state, done):
        """تخزين الخبرة في الذاكرة"""
        self.memory.append((state, action, reward, next_state, done))
    
    def act(self, state):
        """اختيار الإجراء"""
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_size)
        
        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)
        with torch.no_grad():
            q_values = self.model(state)
        return torch.argmax(q_values).item()
    
    def replay(self):
        """إعادة تشغيل الذاكرة للتعلم"""
        if len(self.memory) < self.batch_size:
            return 0
        
        # عينة عشوائية من الذاكرة
        batch = random.sample(self.memory, self.batch_size)
        
        states, actions, rewards, next_states, dones = zip(*batch)
        
        # تحويل إلى tensors
        states = torch.FloatTensor(states).to(self.device)
        actions = torch.LongTensor(actions).unsqueeze(1).to(self.device)
        rewards = torch.FloatTensor(rewards).unsqueeze(1).to(self.device)
        next_states = torch.FloatTensor(next_states).to(self.device)
        dones = torch.FloatTensor(dones).unsqueeze(1).to(self.device)
        
        # حساب Q-values الحالية
        current_q_values = self.model(states).gather(1, actions)
        
        # حساب Q-values الهدف
        with torch.no_grad():
            next_q_values = self.target_model(next_states)
            max_next_q_values = next_q_values.max(1)[0].unsqueeze(1)
            target_q_values = rewards + (self.gamma * max_next_q_values * (1 - dones))
        
        # حساب الخسارة
        loss = self.criterion(current_q_values, target_q_values)
        
        # الانتشار الخلفي
        self.optimizer.zero_grad()
        loss.backward()
        
        # قص التدرج
        torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
        
        self.optimizer.step()
        
        return loss.item()
    
    def train_research_agent(self, episodes=500, target_update_freq=10):
        """تدريب الوكيل للبحث العلمي"""
        for episode in range(episodes):
            state = self.env.reset()
            total_reward = 0
            episode_loss = 0
            step_count = 0
            
            while True:
                # اختيار الإجراء
                action = self.act(state)
                
                # تنفيذ الإجراء
                next_state, reward, done, _ = self.env.step(action)
                
                # تخزين الخبرة
                self.remember(state, action, reward, next_state, done)
                
                # التعلم من الذاكرة
                loss = self.replay()
                if loss:
                    episode_loss += loss
                
                state = next_state
                total_reward += reward
                step_count += 1
                
                if done:
                    break
            
            # تحديث إبسيلون
            self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
            
            # تحديث النموذج الهدف
            if episode % target_update_freq == 0:
                self.update_target_model()
            
            # تسجيل نتائج البحث
            self.research_log['episodes'].append(episode)
            self.research_log['rewards'].append(total_reward)
            self.research_log['epsilons'].append(self.epsilon)
            self.research_log['losses'].append(episode_loss / step_count if step_count > 0 else 0)
            
            if (episode + 1) % 50 == 0:
                avg_reward = np.mean(self.research_log['rewards'][-50:])
                print(f"الحلقة {episode + 1}/{episodes}: "
                      f"المكافأة: {total_reward}, "
                      f"متوسط المكافأة (آخر 50): {avg_reward:.2f}, "
                      f"إبسيلون: {self.epsilon:.4f}")
        
        return self.research_log
    
    def evaluate_research_agent(self, num_episodes=10, render=False):
        """تقييم الوكيل المدرب"""
        total_rewards = []
        
        for episode in range(num_episodes):
            state = self.env.reset()
            episode_reward = 0
            
            while True:
                if render:
                    self.env.render()
                
                state_tensor = torch.FloatTensor(state).unsqueeze(0).to(self.device)
                with torch.no_grad():
                    action = torch.argmax(self.model(state_tensor)).item()
                
                next_state, reward, done, _ = self.env.step(action)
                
                state = next_state
                episode_reward += reward
                
                if done:
                    total_rewards.append(episode_reward)
                    break
        
        evaluation_stats = {
            'mean_reward': np.mean(total_rewards),
            'std_reward': np.std(total_rewards),
            'min_reward': np.min(total_rewards),
            'max_reward': np.max(total_rewards),
            'total_rewards': total_rewards
        }
        
        return evaluation_stats
    
    def analyze_learning_curve(self):
        """تحليل منحنى التعلم"""
        episodes = self.research_log['episodes']
        rewards = self.research_log['rewards']
        
        # حساب المتوسط المتحرك
        window_size = 50
        moving_avg = []
        for i in range(len(rewards)):
            if i < window_size:
                moving_avg.append(np.mean(rewards[:i+1]))
            else:
                moving_avg.append(np.mean(rewards[i-window_size:i+1]))
        
        # إنشاء الرسم البياني
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
        
        # رسم المكافآت
        ax1.plot(episodes, rewards, alpha=0.3, label='Reward per Episode')
        ax1.plot(episodes, moving_avg, 'r-', label=f'{window_size}-Episode Moving Average')
        ax1.set_xlabel('Episode')
        ax1.set_ylabel('Reward')
        ax1.set_title('Learning Curve')
        ax1.legend()
        ax1.grid(True)
        
        # رسم إبسيلون
        ax2.plot(episodes, self.research_log['epsilons'], 'g-')
        ax2.set_xlabel('Episode')
        ax2.set_ylabel('Epsilon')
        ax2.set_title('Exploration Rate Decay')
        ax2.grid(True)
        
        plt.tight_layout()
        return fig
    
    def save_research_results(self, filename='rl_research_results.pth'):
        """حفظ نتائج البحث"""
        torch.save({
            'model_state_dict': self.model.state_dict(),
            'target_model_state_dict': self.target_model.state_dict(),
            'research_log': self.research_log,
            'epsilon': self.epsilon
        }, filename)
    
    def load_research_results(self, filename='rl_research_results.pth'):
        """تحميل نتائج البحث"""
        checkpoint = torch.load(filename, map_location=self.device)
        self.model.load_state_dict(checkpoint['model_state_dict'])
        self.target_model.load_state_dict(checkpoint['target_model_state_dict'])
        self.research_log = checkpoint['research_log']
        self.epsilon = checkpoint['epsilon']
    
    def generate_research_paper_data(self):
        """توليد بيانات لأوراق بحثية"""
        paper_data = {
            'algorithm': 'Deep Q-Network (DQN)',
            'environment': self.env.spec.id,
            'state_space': self.state_size,
            'action_space': self.action_size,
            'hyperparameters': {
                'gamma': self.gamma,
                'learning_rate': self.learning_rate,
                'batch_size': self.batch_size,
                'memory_size': len(self.memory)
            },
            'performance_metrics': {
                'final_average_reward': np.mean(self.research_log['rewards'][-50:]),
                'best_episode_reward': np.max(self.research_log['rewards']),
                'convergence_episode': self.find_convergence_episode(),
                'exploration_final_rate': self.epsilon
            },
            'training_statistics': {
                'total_episodes': len(self.research_log['episodes']),
                'average_loss': np.mean(self.research_log['losses']),
                'total_training_time': 'N/A'  # يمكن إضافة التوقيت
            }
        }
        
        return paper_data
    
    def find_convergence_episode(self):
        """العثور على عصر التقارب"""
        if len(self.research_log['rewards']) < 100:
            return len(self.research_log['rewards'])
        
        rewards = self.research_log['rewards']
        
        # البحث عن عصر استقرار المكافأة
        window_size = 50
        threshold = 10  # الحد الأدنى للتحسن
        
        for i in range(window_size, len(rewards)):
            prev_window = np.mean(rewards[i-window_size:i-window_size//2])
            current_window = np.mean(rewards[i-window_size//2:i])
            
            if abs(current_window - prev_window) < threshold:
                return i
        
        return len(rewards)

# مثال للاستخدام في بحث التعلم المعزز
def main():
    # إنشاء باحث التعلم المعزز
    researcher = RLResearcher(env_name='CartPole-v1')
    
    # تدريب الوكيل
    print("بدء التدريب للبحث العلمي...")
    research_log = researcher.train_research_agent(episodes=200)
    
    # تقييم الأداء
    print("\nتقييم الوكيل المدرب...")
    evaluation = researcher.evaluate_research_agent(num_episodes=10)
    print(f"متوسط المكافأة: {evaluation['mean_reward']:.2f}")
    print(f"انحراف معياري: {evaluation['std_reward']:.2f}")
    
    # تحليل منحنى التعلم
    fig = researcher.analyze_learning_curve()
    
    # توليد بيانات البحث
    paper_data = researcher.generate_research_paper_data()
    
    # حفظ النتائج
    researcher.save_research_results()
    
    return researcher, evaluation, paper_data, fig

if __name__ == "__main__":
    researcher, evaluation, paper_data, fig = main()