مطور الذكاء الاصطناعي التوليدي

# نظام متكامل للذكاء الاصطناعي التوليدي
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import tensorflow as tf

class GenerativeAIBase:
    def __init__(self):
        self.models = {}
        self.generated_data = {}
    
    def load_dataset(self, dataset_path):
        """تحميل مجموعة البيانات"""
        try:
            # محاكاة تحميل البيانات
            print(f"جارِ تحميل البيانات من: {dataset_path}")
            # في التطبيق الحقيقي، هنا يتم تحميل البيانات الفعلية
            data = {
                'images': np.random.randn(100, 64, 64, 3),
                'texts': ["عينة نصية " + str(i) for i in range(100)],
                'labels': np.random.randint(0, 10, 100)
            }
            print(f"تم تحميل {len(data['images'])} صورة")
            print(f"تم تحميل {len(data['texts'])} نص")
            return data
        except Exception as e:
            print(f"خطأ في تحميل البيانات: {e}")
            return None
    
    def preprocess_data(self, data):
        """معالجة البيانات الأولية"""
        print("جارِ معالجة البيانات...")
        
        # تطبيع الصور
        if 'images' in data:
            images = data['images']
            # تحويل إلى نطاق [0, 1]
            images = (images - np.min(images)) / (np.max(images) - np.min(images))
            data['images'] = images
            print("تم تطبيع الصور")
        
        # معالجة النصوص
        if 'texts' in data:
            texts = data['texts']
            # تحويل النصوص إلى tokens (محاكاة)
            data['text_tokens'] = [len(text) for text in texts]
            print("تم معالجة النصوص")
        
        return data
    
    def train_generative_model(self, data, model_type='gan'):
        """تدريب نموذج توليدي"""
        print(f"جارِ تدريب نموذج {model_type.upper()}...")
        
        if model_type == 'gan':
            # محاكاة تدريب GAN
            model = self._create_simple_gan()
            history = {
                'epochs': 100,
                'generator_loss': np.random.rand(100),
                'discriminator_loss': np.random.rand(100)
            }
            self.models['gan'] = model
            return history
        
        elif model_type == 'vae':
            # محاكاة تدريب VAE
            model = self._create_simple_vae()
            history = {
                'epochs': 100,
                'loss': np.random.rand(100),
                'reconstruction_loss': np.random.rand(100)
            }
            self.models['vae'] = model
            return history
        
        else:
            print(f"نوع النموذج {model_type} غير مدعوم")
            return None
    
    def _create_simple_gan(self):
        """إنشاء نموذج GAN بسيط"""
        # Generator
        generator = tf.keras.Sequential([
            tf.keras.layers.Dense(128, activation='relu', input_shape=(100,)),
            tf.keras.layers.Dense(256, activation='relu'),
            tf.keras.layers.Dense(512, activation='relu'),
            tf.keras.layers.Dense(28*28, activation='sigmoid'),
            tf.keras.layers.Reshape((28, 28, 1))
        ])
        
        # Discriminator
        discriminator = tf.keras.Sequential([
            tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
            tf.keras.layers.Dense(512, activation='relu'),
            tf.keras.layers.Dense(256, activation='relu'),
            tf.keras.layers.Dense(1, activation='sigmoid')
        ])
        
        return {'generator': generator, 'discriminator': discriminator}
    
    def _create_simple_vae(self):
        """إنشاء نموذج VAE بسيط"""
        # Encoder
        encoder_inputs = tf.keras.Input(shape=(28, 28, 1))
        x = tf.keras.layers.Flatten()(encoder_inputs)
        x = tf.keras.layers.Dense(256, activation='relu')(x)
        
        # Latent space
        z_mean = tf.keras.layers.Dense(64, name='z_mean')(x)
        z_log_var = tf.keras.layers.Dense(64, name='z_log_var')(x)
        
        # Decoder
        decoder_inputs = tf.keras.Input(shape=(64,))
        x = tf.keras.layers.Dense(256, activation='relu')(decoder_inputs)
        x = tf.keras.layers.Dense(28*28, activation='sigmoid')(x)
        decoder_outputs = tf.keras.layers.Reshape((28, 28, 1))(x)
        
        encoder = tf.keras.Model(encoder_inputs, [z_mean, z_log_var], name='encoder')
        decoder = tf.keras.Model(decoder_inputs, decoder_outputs, name='decoder')
        
        return {'encoder': encoder, 'decoder': decoder}
    
    def generate_samples(self, model_type='gan', num_samples=5):
        """توليد عينات جديدة"""
        print(f"جارِ توليد {num_samples} عينة باستخدام {model_type}...")
        
        if model_type not in self.models:
            print(f"النموذج {model_type} غير مدرب")
            return None
        
        if model_type == 'gan':
            generator = self.models['gan']['generator']
            # توليد ضوضاء عشوائية
            noise = np.random.randn(num_samples, 100)
            generated_images = generator.predict(noise)
            
            self.generated_data['gan_samples'] = generated_images
            return generated_images
        
        elif model_type == 'vae':
            decoder = self.models['vae']['decoder']
            # توليد نقاط في الفضاء الكامن
            latent_points = np.random.randn(num_samples, 64)
            generated_images = decoder.predict(latent_points)
            
            self.generated_data['vae_samples'] = generated_images
            return generated_images
    
    def visualize_results(self, generated_data, title="النتائج المولدة"):
        """تصور النتائج المولدة"""
        if generated_data is None:
            print("لا توجد بيانات للعرض")
            return
        
        num_samples = min(len(generated_data), 10)
        
        plt.figure(figsize=(15, 2))
        plt.suptitle(title, fontsize=16)
        
        for i in range(num_samples):
            plt.subplot(1, num_samples, i + 1)
            
            if len(generated_data[i].shape) == 3:
                # صورة ملونة
                plt.imshow(generated_data[i])
            elif len(generated_data[i].shape) == 2:
                # صورة رمادية
                plt.imshow(generated_data[i], cmap='gray')
            
            plt.axis('off')
            plt.title(f"عينة {i+1}")
        
        plt.tight_layout()
        plt.show()
    
    def evaluate_quality(self, generated_data, real_data=None):
        """تقييم جودة البيانات المولدة"""
        print("جارِ تقييم جودة البيانات المولدة...")
        
        if generated_data is None:
            return {"error": "لا توجد بيانات مولدة"}
        
        # مقاييس الجودة (محاكاة)
        metrics = {
            'عدد العينات': len(generated_data),
            'الأبعاد': generated_data[0].shape if len(generated_data) > 0 else "غير متوفر",
            'التنوع': np.random.uniform(0.7, 0.9),
            'الواقعية': np.random.uniform(0.6, 0.85),
            'الجودة الإجمالية': np.random.uniform(0.65, 0.95)
        }
        
        return metrics

# مثال للاستخدام
ai_system = GenerativeAIBase()

# تحميل ومعالجة البيانات
data = ai_system.load_dataset('dataset/')
if data is not None:
    processed_data = ai_system.preprocess_data(data)
    
    # تدريب نموذج GAN
    history = ai_system.train_generative_model(processed_data, 'gan')
    if history:
        print(f"تم تدريب النموذج لـ {history['epochs']} دورة")
    
    # توليد عينات جديدة
    generated_samples = ai_system.generate_samples('gan', 10)
    
    # تصور النتائج
    if generated_samples is not None:
        ai_system.visualize_results(generated_samples, "الصور المولدة باستخدام GAN")
    
    # تقييم الجودة
    quality_metrics = ai_system.evaluate_quality(generated_samples)
    print("مقاييس الجودة:")
    for metric, value in quality_metrics.items():
        print(f"  {metric}: {value}")

# نظام متكامل لـ GANs مع تدريب وتوليد وتقييم
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import os
from datetime import datetime

class AdvancedGANSystem:
    def __init__(self, latent_dim=100, img_shape=(28, 28, 1)):
        self.latent_dim = latent_dim
        self.img_shape = img_shape
        self.generator = None
        self.discriminator = None
        self.gan = None
        self.history = {
            'd_loss': [],
            'g_loss': [],
            'd_acc': [],
            'g_acc': []
        }
    
    def build_generator(self):
        """بناء نموذج المولد المتقدم"""
        model = keras.Sequential([
            # الطبقة الأولى: تحويل الضوضاء إلى مصفوفة
            layers.Dense(7 * 7 * 256, use_bias=False, 
                        input_shape=(self.latent_dim,)),
            layers.BatchNormalization(),
            layers.LeakyReLU(alpha=0.2),
            
            # إعادة تشكيل إلى 7x7x256
            layers.Reshape((7, 7, 256)),
            
            # الطبقة الثانية: تحويل إلى 14x14x128
            layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), 
                                  padding='same', use_bias=False),
            layers.BatchNormalization(),
            layers.LeakyReLU(alpha=0.2),
            
            # الطبقة الثالثة: تحويل إلى 28x28x64
            layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), 
                                  padding='same', use_bias=False),
            layers.BatchNormalization(),
            layers.LeakyReLU(alpha=0.2),
            
            # الطبقة النهائية: تحويل إلى 28x28x1
            layers.Conv2DTranspose(self.img_shape[2], (5, 5), strides=(1, 1), 
                                  padding='same', activation='tanh')
        ])
        
        self.generator = model
        print("تم بناء المولد")
        return model
    
    def build_discriminator(self):
        """بناء نموذج المميز المتقدم"""
        model = keras.Sequential([
            # الطبقة الأولى
            layers.Conv2D(64, (5, 5), strides=(2, 2), 
                         padding='same', 
                         input_shape=self.img_shape),
            layers.LeakyReLU(alpha=0.2),
            layers.Dropout(0.3),
            
            # الطبقة الثانية
            layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'),
            layers.LeakyReLU(alpha=0.2),
            layers.Dropout(0.3),
            
            # الطبقة الثالثة
            layers.Conv2D(256, (5, 5), strides=(1, 1), padding='same'),
            layers.LeakyReLU(alpha=0.2),
            layers.Dropout(0.3),
            
            # الطبقات الكاملة المتصلة
            layers.Flatten(),
            layers.Dense(1, activation='sigmoid')
        ])
        
        self.discriminator = model
        print("تم بناء المميز")
        return model
    
    def build_gan(self):
        """بناء نموذج GAN كامل"""
        # تجميد المميز أثناء تدريب المولد
        self.discriminator.trainable = False
        
        # إنشاء النموذج الكامل
        gan_input = layers.Input(shape=(self.latent_dim,))
        generated_img = self.generator(gan_input)
        gan_output = self.discriminator(generated_img)
        
        self.gan = models.Model(gan_input, gan_output)
        self.gan.compile(
            optimizer=keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5),
            loss='binary_crossentropy',
            metrics=['accuracy']
        )
        
        print("تم بناء نموذج GAN الكامل")
        return self.gan
    
    def load_data(self, dataset_name='mnist'):
        """تحميل بيانات التدريب"""
        if dataset_name == 'mnist':
            (x_train, _), (_, _) = keras.datasets.mnist.load_data()
            # توسيع الأبعاد وتطبيع
            x_train = np.expand_dims(x_train, axis=-1)
            x_train = x_train.astype('float32') / 127.5 - 1.0
            return x_train
        
        elif dataset_name == 'fashion_mnist':
            (x_train, _), (_, _) = keras.datasets.fashion_mnist.load_data()
            x_train = np.expand_dims(x_train, axis=-1)
            x_train = x_train.astype('float32') / 127.5 - 1.0
            return x_train
        
        elif dataset_name == 'cifar10':
            (x_train, _), (_, _) = keras.datasets.cifar10.load_data()
            x_train = x_train.astype('float32') / 127.5 - 1.0
            return x_train
        
        else:
            raise ValueError(f"مجموعة البيانات {dataset_name} غير مدعومة")
    
    def train(self, dataset, epochs=10000, batch_size=32, sample_interval=1000):
        """تدريب النموذج"""
        # البيانات الحقيقية والمزيفة
        real = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))
        
        for epoch in range(epochs):
            # ----------
            #  تدريب المميز
            # ----------
            
            # عينات حقيقية عشوائية
            idx = np.random.randint(0, dataset.shape[0], batch_size)
            imgs = dataset[idx]
            
            # توليد عينات مزيفة
            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
            gen_imgs = self.generator.predict(noise, verbose=0)
            
            # تدريب المميز
            d_loss_real = self.discriminator.train_on_batch(imgs, real)
            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
            
            # ----------
            #  تدريب المولد
            # ----------
            
            # ضوضاء للمولد
            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
            
            # تدريب المولد
            g_loss = self.gan.train_on_batch(noise, real)
            
            # حفظ السجل
            self.history['d_loss'].append(d_loss[0])
            self.history['g_loss'].append(g_loss[0])
            self.history['d_acc'].append(d_loss[1])
            self.history['g_acc'].append(g_loss[1])
            
            # عرض التقدم
            if epoch % sample_interval == 0:
                print(f"الدورة [{epoch}/{epochs}] "
                      f"خسارة المميز: {d_loss[0]:.4f}, "
                      f"دقة المميز: {100*d_loss[1]:.2f}%, "
                      f"خسارة المولد: {g_loss[0]:.4f}")
                
                # حفظ عينات
                self.save_sample_images(epoch)
                
                # حفظ النماذج
                if epoch % (sample_interval * 10) == 0:
                    self.save_models(epoch)
    
    def generate_samples(self, num_samples=16):
        """توليد عينات جديدة"""
        noise = np.random.normal(0, 1, (num_samples, self.latent_dim))
        generated_images = self.generator.predict(noise)
        
        # إعادة التطبيع إلى [0, 255]
        generated_images = 0.5 * generated_images + 0.5
        generated_images = np.clip(generated_images * 255, 0, 255).astype(np.uint8)
        
        return generated_images
    
    def save_sample_images(self, epoch, grid_size=4):
        """حفظ صور العينات"""
        samples = self.generate_samples(grid_size * grid_size)
        
        fig, axs = plt.subplots(grid_size, grid_size, 
                                figsize=(grid_size, grid_size))
        cnt = 0
        
        for i in range(grid_size):
            for j in range(grid_size):
                if self.img_shape[2] == 1:
                    axs[i, j].imshow(samples[cnt, :, :, 0], cmap='gray')
                else:
                    axs[i, j].imshow(samples[cnt])
                
                axs[i, j].axis('off')
                cnt += 1
        
        # إنشاء مجلد إذا لم يكن موجوداً
        os.makedirs('generated_images', exist_ok=True)
        
        # حفظ الصورة
        fig.savefig(f"generated_images/{epoch}.png")
        plt.close()
    
    def save_models(self, epoch):
        """حفظ النماذج"""
        os.makedirs('models', exist_ok=True)
        
        self.generator.save(f'models/generator_{epoch}.h5')
        self.discriminator.save(f'models/discriminator_{epoch}.h5')
        self.gan.save(f'models/gan_{epoch}.h5')
        
        print(f"تم حفظ النماذج في الدورة {epoch}")
    
    def plot_training_history(self):
        """رسم تاريخ التدريب"""
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
        
        # رسم الخسارة
        ax1.plot(self.history['d_loss'], label='خسارة المميز')
        ax1.plot(self.history['g_loss'], label='خسارة المولد')
        ax1.set_title('تطور الخسارة')
        ax1.set_xlabel('الدورة')
        ax1.set_ylabel('الخسارة')
        ax1.legend()
        ax1.grid(True)
        
        # رسم الدقة
        ax2.plot(self.history['d_acc'], label='دقة المميز')
        ax2.plot(self.history['g_acc'], label='دقة المولد')
        ax2.set_title('تطور الدقة')
        ax2.set_xlabel('الدورة')
        ax2.set_ylabel('الدقة')
        ax2.legend()
        ax2.grid(True)
        
        plt.tight_layout()
        plt.show()
    
    def interpolate_latent_space(self, num_steps=10):
        """استكمال الفضاء الكامن"""
        # نقطتين في الفضاء الكامن
        z1 = np.random.normal(0, 1, (1, self.latent_dim))
        z2 = np.random.normal(0, 1, (1, self.latent_dim))
        
        # إنشاء استكمالات
        interpolations = []
        for alpha in np.linspace(0, 1, num_steps):
            z = alpha * z1 + (1 - alpha) * z2
            interpolations.append(z)
        
        # توليد الصور
        interpolations = np.vstack(interpolations)
        generated = self.generator.predict(interpolations)
        generated = 0.5 * generated + 0.5
        
        # عرض النتائج
        fig, axs = plt.subplots(1, num_steps, figsize=(15, 2))
        for i in range(num_steps):
            if self.img_shape[2] == 1:
                axs[i].imshow(generated[i, :, :, 0], cmap='gray')
            else:
                axs[i].imshow(generated[i])
            axs[i].axis('off')
            axs[i].set_title(f"{i+1}")
        
        plt.suptitle('استكمال الفضاء الكامن')
        plt.show()
    
    def evaluate_metrics(self, real_images, num_samples=1000):
        """تقييم جودة النموذج"""
        # توليد عينات
        noise = np.random.normal(0, 1, (num_samples, self.latent_dim))
        fake_images = self.generator.predict(noise)
        
        # حساب المسافات (محاكاة لـ FID Score)
        def calculate_fid(real_imgs, fake_imgs):
            # في التطبيق الحقيقي، يتم حساب FID باستخدام InceptionV3
            # هذا مثال مبسط
            real_mean = np.mean(real_imgs, axis=0)
            fake_mean = np.mean(fake_imgs, axis=0)
            
            real_cov = np.cov(real_imgs.reshape(real_imgs.shape[0], -1), rowvar=False)
            fake_cov = np.cov(fake_imgs.reshape(fake_imgs.shape[0], -1), rowvar=False)
            
            # حساب المسافة بين التوزيعات
            diff = real_mean - fake_mean
            cov_mean = np.sqrt(np.dot(real_cov, fake_cov))
            
            if np.isscalar(cov_mean):
                cov_mean = cov_mean * np.eye(real_mean.shape[0])
            
            fid = np.sum(diff**2) + np.trace(real_cov + fake_cov - 2*cov_mean)
            return fid
        
        # حساب التنوع
        def calculate_diversity(fake_imgs):
            # حساب المسافات بين العينات المولدة
            fake_flat = fake_imgs.reshape(fake_imgs.shape[0], -1)
            distances = []
            
            for i in range(len(fake_flat)):
                for j in range(i+1, len(fake_flat)):
                    dist = np.linalg.norm(fake_flat[i] - fake_flat[j])
                    distances.append(dist)
            
            return np.mean(distances) if distances else 0
        
        fid_score = calculate_fid(real_images[:num_samples], fake_images)
        diversity = calculate_diversity(fake_images)
        
        metrics = {
            'عدد العينات': num_samples,
            'FID Score (تقريبي)': fid_score,
            'التنوع': diversity,
            'مستوى التنوع': 'عال' if diversity > 0.5 else 'متوسط' if diversity > 0.3 else 'منخفض'
        }
        
        return metrics

# مثال للاستخدام
gan_system = AdvancedGANSystem(latent_dim=100, img_shape=(28, 28, 1))

# بناء النماذج
gan_system.build_generator()
gan_system.build_discriminator()
gan_system.build_gan()

# تحميل البيانات
dataset = gan_system.load_data('mnist')
print(f"حجم مجموعة البيانات: {dataset.shape}")

# تدريب النموذج (يمكن تقليل عدد الدورات للاختبار)
gan_system.train(dataset, epochs=5000, batch_size=32, sample_interval=500)

# عرض تاريخ التدريب
gan_system.plot_training_history()

# توليد عينات جديدة
samples = gan_system.generate_samples(16)

# استكمال الفضاء الكامن
gan_system.interpolate_latent_space()

# تقييم النموذج
metrics = gan_system.evaluate_metrics(dataset)
print("مقاييس التقييم:")
for key, value in metrics.items():
    print(f"  {key}: {value}")

# نظام متكامل لـ Diffusion Models
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import os
from tqdm import tqdm
from diffusers import (
    DDPMPipeline, 
    DDPMScheduler, 
    UNet2DModel,
    StableDiffusionPipeline
)
import torchvision

class DiffusionModelSystem:
    def __init__(self, device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.device = device
        self.model = None
        self.scheduler = None
        self.noise_scheduler = None
        self.history = {'losses': []}
    
    def build_unet_model(self, image_size=32, channels=3):
        """بناء نموذج UNet لـ Diffusion"""
        model = UNet2DModel(
            sample_size=image_size,
            in_channels=channels,
            out_channels=channels,
            layers_per_block=2,
            block_out_channels=(64, 128, 256, 512),
            down_block_types=(
                "DownBlock2D",
                "DownBlock2D",
                "AttnDownBlock2D",
                "DownBlock2D",
            ),
            up_block_types=(
                "UpBlock2D",
                "AttnUpBlock2D",
                "UpBlock2D",
                "UpBlock2D",
            ),
        ).to(self.device)
        
        self.model = model
        return model
    
    def prepare_scheduler(self, num_train_timesteps=1000):
        """إعداد منظم الخطوات الزمنية"""
        self.noise_scheduler = DDPMScheduler(
            num_train_timesteps=num_train_timesteps,
            beta_schedule="squaredcos_cap_v2"
        )
        return self.noise_scheduler
    
    def forward_diffusion(self, x0, t, noise=None):
        """تطبيق الانتشار الأمامي"""
        if noise is None:
            noise = torch.randn_like(x0)
        
        sqrt_alpha_cumprod = self.noise_scheduler.sqrt_alphas_cumprod[t].to(x0.device)
        sqrt_one_minus_alpha_cumprod = self.noise_scheduler.sqrt_one_minus_alphas_cumprod[t].to(x0.device)
        
        # xt = sqrt(alpha_cumprod) * x0 + sqrt(1 - alpha_cumprod) * noise
        xt = sqrt_alpha_cumprod * x0 + sqrt_one_minus_alpha_cumprod * noise
        
        return xt, noise
    
    def train_step(self, batch, optimizer):
        """خطوة تدريب واحدة"""
        clean_images = batch[0].to(self.device)
        
        # عينة خطوات زمنية عشوائية
        batch_size = clean_images.shape[0]
        timesteps = torch.randint(
            0, self.noise_scheduler.config.num_train_timesteps,
            (batch_size,), device=self.device
        ).long()
        
        # إضافة ضوضاء
        noise = torch.randn_like(clean_images)
        noisy_images, noise = self.forward_diffusion(clean_images, timesteps, noise)
        
        # التنبؤ بالضوضاء
        noise_pred = self.model(noisy_images, timesteps, return_dict=False)[0]
        
        # حساب الخسارة
        loss = F.mse_loss(noise_pred, noise)
        
        # تحديث النموذج
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        return loss.item()
    
    def train(self, train_loader, epochs=100, learning_rate=1e-4):
        """تدريب النموذج"""
        optimizer = torch.optim.AdamW(self.model.parameters(), lr=learning_rate)
        
        self.model.train()
        progress_bar = tqdm(range(epochs), desc="التدريب")
        
        for epoch in progress_bar:
            epoch_loss = 0
            num_batches = 0
            
            for batch in train_loader:
                loss = self.train_step(batch, optimizer)
                epoch_loss += loss
                num_batches += 1
            
            avg_loss = epoch_loss / num_batches
            self.history['losses'].append(avg_loss)
            
            progress_bar.set_postfix({'loss': avg_loss})
            
            # حفظ النموذج كل 10 دورات
            if (epoch + 1) % 10 == 0:
                self.save_checkpoint(epoch + 1)
    
    @torch.no_grad()
    def sample(self, num_samples=16, image_size=32, channels=3):
        """توليد عينات جديدة"""
        self.model.eval()
        
        # بدء من ضوضاء عشوائية
        sample = torch.randn(
            (num_samples, channels, image_size, image_size)
        ).to(self.device)
        
        # إنشاء خطوات زمنية
        self.scheduler = DDPMScheduler.from_config(self.noise_scheduler.config)
        
        # عملية إزالة الضوضاء
        for t in tqdm(self.scheduler.timesteps, desc="التوليد"):
            # التنبؤ بالضوضاء
            noise_pred = self.model(sample, t).sample
            
            # حساب x_{t-1}
            sample = self.scheduler.step(noise_pred, t, sample).prev_sample
        
        # تطبيع الصور إلى [0, 1]
        sample = (sample + 1) / 2
        sample = torch.clamp(sample, 0, 1)
        
        return sample
    
    def save_checkpoint(self, epoch):
        """حفظ حالة النموذج"""
        os.makedirs('checkpoints', exist_ok=True)
        
        checkpoint = {
            'epoch': epoch,
            'model_state_dict': self.model.state_dict(),
            'losses': self.history['losses']
        }
        
        torch.save(checkpoint, f'checkpoints/diffusion_epoch_{epoch}.pt')
        print(f"تم حفظ النموذج في الدورة {epoch}")
    
    def load_checkpoint(self, checkpoint_path):
        """تحميل حالة النموذج"""
        checkpoint = torch.load(checkpoint_path, map_location=self.device)
        self.model.load_state_dict(checkpoint['model_state_dict'])
        self.history['losses'] = checkpoint['losses']
        print(f"تم تحميل النموذج من الدورة {checkpoint['epoch']}")
    
    def visualize_samples(self, samples, title="العينات المولدة"):
        """تصور العينات المولدة"""
        grid = torchvision.utils.make_grid(samples, nrow=4)
        grid = grid.cpu().permute(1, 2, 0).numpy()
        
        plt.figure(figsize=(10, 10))
        plt.imshow(grid)
        plt.title(title)
        plt.axis('off')
        plt.show()
    
    def plot_training_history(self):
        """رسم تاريخ التدريب"""
        plt.figure(figsize=(10, 5))
        plt.plot(self.history['losses'])
        plt.title('تطور الخسارة خلال التدريب')
        plt.xlabel('الدورة')
        plt.ylabel('الخسارة')
        plt.grid(True)
        plt.show()
    
    def use_pretrained_stable_diffusion(self, prompt, num_images=1):
        """استخدام Stable Diffusion مسبق التدريب"""
        print(f"جارِ توليد صور لـ: '{prompt}'")
        
        # تحميل النموذج
        pipe = StableDiffusionPipeline.from_pretrained(
            "CompVis/stable-diffusion-v1-4",
            torch_dtype=torch.float16
        ).to(self.device)
        
        # توليد الصور
        images = []
        for i in range(num_images):
            image = pipe(prompt).images[0]
            images.append(image)
            
            # حفظ الصورة
            os.makedirs('stable_diffusion_outputs', exist_ok=True)
            image.save(f'stable_diffusion_outputs/output_{i}.png')
            print(f"تم حفظ الصورة {i+1}")
        
        return images

# مثال للاستخدام
def prepare_mnist_dataset(batch_size=64):
    """تحضير مجموعة بيانات MNIST"""
    transform = transforms.Compose([
        transforms.Resize((32, 32)),
        transforms.ToTensor(),
        transforms.Normalize([0.5], [0.5])
    ])
    
    dataset = datasets.MNIST(
        root='./data',
        train=True,
        download=True,
        transform=transform
    )
    
    loader = DataLoader(
        dataset,
        batch_size=batch_size,
        shuffle=True,
        num_workers=2
    )
    
    return loader

# إنشاء النظام
diffusion_system = DiffusionModelSystem()
print(f"جهاز الحساب: {diffusion_system.device}")

# بناء النموذج
diffusion_system.build_unet_model(image_size=32, channels=1)
diffusion_system.prepare_scheduler()

# تحضير البيانات
train_loader = prepare_mnist_dataset()

# تدريب النموذج (يمكن تقليل عدد الدورات للاختبار)
diffusion_system.train(train_loader, epochs=50, learning_rate=1e-4)

# عرض تاريخ التدريب
diffusion_system.plot_training_history()

# توليد عينات جديدة
samples = diffusion_system.sample(num_samples=16, image_size=32, channels=1)

# تصور العينات
diffusion_system.visualize_samples(samples, "صور MNIST المولدة باستخدام Diffusion Models")

# استخدام Stable Diffusion مسبق التدريب
if torch.cuda.is_available():
    prompts = [
        "منظر طبيعي جبلي في غروب الشمس",
        "مدينة مستقبلية مع ناطحات سحاب",
        "غابة سحرية مع كائنات خيالية"
    ]
    
    for prompt in prompts:
        try:
            images = diffusion_system.use_pretrained_stable_diffusion(prompt, num_images=1)
            print(f"تم توليد صورة لـ: '{prompt}'")
        except Exception as e:
            print(f"خطأ في توليد الصورة: {e}")

# نظام متكامل لتوليد الصور من النصوص
import torch
from transformers import (
    CLIPTextModel, 
    CLIPTokenizer,
    logging
)
from diffusers import (
    AutoencoderKL, 
    UNet2DConditionModel, 
    PNDMScheduler,
    StableDiffusionPipeline,
    EulerDiscreteScheduler
)
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import os
from tqdm import tqdm

# تقليل الرسائل التحذيرية
logging.set_verbosity_error()

class TextToImageGenerator:
    def __init__(self, model_name="runwayml/stable-diffusion-v1-5", device=None):
        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
        self.model_name = model_name
        self.pipe = None
        self.vae = None
        self.unet = None
        self.tokenizer = None
        self.text_encoder = None
        self.scheduler = None
        
        print(f"تهيئة النموذج على جهاز: {self.device}")
    
    def load_pretrained_pipeline(self):
        """تحميل خط أنابيب Stable Diffusion مسبق التدريب"""
        print(f"جارِ تحميل النموذج: {self.model_name}")
        
        self.pipe = StableDiffusionPipeline.from_pretrained(
            self.model_name,
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
            safety_checker=None,  # تعطيل فحص السلامة للسرعة
            requires_safety_checker=False
        ).to(self.device)
        
        print("تم تحميل النموذج بنجاح")
        return self.pipe
    
    def load_components_separately(self):
        """تحميل مكونات النموذج بشكل منفصل"""
        print("جارِ تحميل مكونات النموذج...")
        
        # تحميل Tokenizer و Text Encoder
        self.tokenizer = CLIPTokenizer.from_pretrained(
            self.model_name,
            subfolder="tokenizer"
        )
        self.text_encoder = CLIPTextModel.from_pretrained(
            self.model_name,
            subfolder="text_encoder",
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
        ).to(self.device)
        
        # تحميل VAE
        self.vae = AutoencoderKL.from_pretrained(
            self.model_name,
            subfolder="vae",
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
        ).to(self.device)
        
        # تحميل UNet
        self.unet = UNet2DConditionModel.from_pretrained(
            self.model_name,
            subfolder="unet",
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
        ).to(self.device)
        
        # تحميل Scheduler
        self.scheduler = EulerDiscreteScheduler.from_pretrained(
            self.model_name,
            subfolder="scheduler"
        )
        
        print("تم تحميل جميع المكونات بنجاح")
        return {
            'tokenizer': self.tokenizer,
            'text_encoder': self.text_encoder,
            'vae': self.vae,
            'unet': self.unet,
            'scheduler': self.scheduler
        }
    
    def generate_from_pipeline(self, prompt, num_images=1, 
                               guidance_scale=7.5, num_inference_steps=50):
        """توليد الصور باستخدام خط الأنابيب"""
        if self.pipe is None:
            self.load_pretrained_pipeline()
        
        print(f"جارِ توليد {num_images} صورة لـ: '{prompt}'")
        
        images = []
        for i in range(num_images):
            image = self.pipe(
                prompt,
                guidance_scale=guidance_scale,
                num_inference_steps=num_inference_steps
            ).images[0]
            
            images.append(image)
            
            # حفظ الصورة
            self.save_image(image, f"pipeline_gen_{i}", prompt)
        
        return images
    
    def generate_from_components(self, prompt, height=512, width=512,
                                 num_inference_steps=50, guidance_scale=7.5,
                                 negative_prompt=""):
        """توليد الصور باستخدام المكونات المنفصلة"""
        if self.tokenizer is None:
            self.load_components_separately()
        
        print(f"جارِ توليد صورة باستخدام المكونات: '{prompt}'")
        
        # ترميز النص
        text_input = self.tokenizer(
            [prompt],
            padding="max_length",
            max_length=self.tokenizer.model_max_length,
            truncation=True,
            return_tensors="pt"
        )
        
        negative_input = self.tokenizer(
            [negative_prompt] if negative_prompt else [""],
            padding="max_length",
            max_length=self.tokenizer.model_max_length,
            truncation=True,
            return_tensors="pt"
        )
        
        with torch.no_grad():
            # تشفير النص
            text_embeddings = self.text_encoder(text_input.input_ids.to(self.device))[0]
            uncond_embeddings = self.text_encoder(negative_input.input_ids.to(self.device))[0]
            
            # دمج التضمينات
            text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
        
        # إنشاء ضوضاء أولية
        latents = torch.randn(
            (1, self.unet.config.in_channels, height // 8, width // 8),
            device=self.device,
            dtype=torch.float16 if torch.cuda.is_available() else torch.float32
        )
        
        # ضبط Scheduler
        self.scheduler.set_timesteps(num_inference_steps, device=self.device)
        
        # عملية إزالة الضوضاء
        for t in tqdm(self.scheduler.timesteps, desc="توليد الصورة"):
            # توسيع latents
            latent_model_input = torch.cat([latents] * 2)
            latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
            
            # التنبؤ بالضوضاء
            with torch.no_grad():
                noise_pred = self.unet(
                    latent_model_input,
                    t,
                    encoder_hidden_states=text_embeddings
                ).sample
            
            # فصل التنبؤات
            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
            
            # تطبيق guidance
            noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
            
            # حساب x_{t-1}
            latents = self.scheduler.step(noise_pred, t, latents).prev_sample
        
        # فك تشفير latent إلى صورة
        latents = 1 / 0.18215 * latents
        with torch.no_grad():
            image = self.vae.decode(latents).sample
        
        # معالجة الصورة النهائية
        image = (image / 2 + 0.5).clamp(0, 1)
        image = image.cpu().permute(0, 2, 3, 1).float().numpy()
        
        # تحويل إلى PIL Image
        image = (image[0] * 255).astype(np.uint8)
        image = Image.fromarray(image)
        
        # حفظ الصورة
        self.save_image(image, "components_gen", prompt)
        
        return image
    
    def save_image(self, image, prefix, prompt):
        """حفظ الصورة مع اسم مناسب"""
        # تنظيف النص لاستخدامه كاسم ملف
        clean_prompt = "".join(c for c in prompt[:50] if c.isalnum() or c in (' ', '_')).rstrip()
        clean_prompt = clean_prompt.replace(' ', '_')
        
        # إنشاء المجلد إذا لم يكن موجوداً
        os.makedirs("generated_text2img", exist_ok=True)
        
        # حفظ الصورة
        filename = f"generated_text2img/{prefix}_{clean_prompt}.png"
        image.save(filename)
        print(f"تم حفظ الصورة: {filename}")
        
        return filename
    
    def generate_variations(self, prompt, num_variations=4, 
                           guidance_scale_range=(5, 10),
                           steps_range=(30, 70)):
        """توليد اختلافات لنفس النص"""
        images = []
        settings = []
        
        for i in range(num_variations):
            # إعدادات عشوائية
            guidance = np.random.uniform(*guidance_scale_range)
            steps = np.random.randint(*steps_range)
            
            print(f"الاختلاف {i+1}: guidance={guidance:.1f}, steps={steps}")
            
            # توليد الصورة
            if self.pipe is None:
                self.load_pretrained_pipeline()
            
            image = self.pipe(
                prompt,
                guidance_scale=guidance,
                num_inference_steps=steps,
                generator=torch.Generator(device=self.device).manual_seed(np.random.randint(1000))
            ).images[0]
            
            images.append(image)
            settings.append({'guidance': guidance, 'steps': steps})
            
            # حفظ الصورة
            self.save_image(image, f"variation_{i}", prompt)
        
        return images, settings
    
    def interpolate_prompts(self, prompt1, prompt2, num_steps=5):
        """استكمال بين نصين"""
        if self.pipe is None:
            self.load_pretrained_pipeline()
        
        print(f"استكمال بين: '{prompt1}' و '{prompt2}'")
        
        images = []
        
        for i in range(num_steps):
            alpha = i / (num_steps - 1)
            
            # توليد صورة للنص الوسيط
            intermediate_prompt = f"{prompt1} and {prompt2}"
            
            image = self.pipe(
                intermediate_prompt,
                guidance_scale=7.5,
                num_inference_steps=50
            ).images[0]
            
            images.append(image)
            
            # حفظ الصورة
            self.save_image(image, f"interp_{i}", f"{prompt1}_{prompt2}")
        
        return images
    
    def batch_generate(self, prompts, batch_size=2):
        """توليد دفعات من الصور"""
        if self.pipe is None:
            self.load_pretrained_pipeline()
        
        all_images = []
        
        for i in range(0, len(prompts), batch_size):
            batch_prompts = prompts[i:i+batch_size]
            print(f"جارِ توليد الدفعة {i//batch_size + 1}: {batch_prompts}")
            
            images = self.pipe(
                batch_prompts,
                guidance_scale=7.5,
                num_inference_steps=50
            ).images
            
            for prompt, image in zip(batch_prompts, images):
                all_images.append((prompt, image))
                self.save_image(image, f"batch_{i}", prompt)
        
        return all_images
    
    def visualize_results(self, images, titles=None):
        """تصور نتائج التوليد"""
        num_images = len(images)
        fig, axes = plt.subplots(1, num_images, figsize=(4*num_images, 4))
        
        if num_images == 1:
            axes = [axes]
        
        for i, (img, ax) in enumerate(zip(images, axes)):
            ax.imshow(img)
            if titles and i < len(titles):
                ax.set_title(titles[i], fontsize=10)
            ax.axis('off')
        
        plt.tight_layout()
        plt.show()

# مثال للاستخدام
generator = TextToImageGenerator()

# 1. توليد صورة باستخدام خط الأنابيب
prompt = "قلعة سحرية على قمة جبل في عالم خيالي، غروب الشمس، فني رقمي"
images = generator.generate_from_pipeline(prompt, num_images=2)

print(f"\nتم توليد {len(images)} صور")

# 2. توليد اختلافات
print("\nجارِ توليد اختلافات...")
variations, settings = generator.generate_variations(
    "روبوت ذكي في مختبر مستقبلي",
    num_variations=3
)

# 3. توليد دفعات من الصور
print("\nجارِ توليد دفعات من الصور...")
prompts_batch = [
    "منظر طبيعي خلاب مع بحيرة زرقاء",
    "مدينة فضائية في مجرة بعيدة",
    "تنين أسطوري يحلق فوق الجبال"
]

batch_results = generator.batch_generate(prompts_batch, batch_size=2)

# 4. عرض النتائج
print("\nعرض النتائج...")

# عرض الاختلافات
generator.visualize_results(
    variations[:3],
    [f"اختلاف {i+1}" for i in range(3)]
)

# عرض دفعة من الصور
batch_images = [img for _, img in batch_results]
batch_titles = [prompt for prompt, _ in batch_results]
generator.visualize_results(batch_images, batch_titles)

# 5. استخدام المكونات المنفصلة (اختياري)
print("\nجارِ توليد صورة باستخدام المكونات المنفصلة...")
try:
    detailed_prompt = """
    لوحة فنية بانورامية لمدينة مستقبلية تحت الماء،
    مع مباني زجاجية ومخلوقات بحرية متوهجة،
    أضواء نيون زرقاء وخضراء،
    غواصين بأجهزة متطورة،
    تفاصيل عالية الدقة، واقعية فوتوغرافية
    """
    
    # تقصير النص إذا كان طويلاً جداً
    if len(detailed_prompt) > 400:
        detailed_prompt = detailed_prompt[:400] + "..."
    
    components_image = generator.generate_from_components(
        detailed_prompt,
        num_inference_steps=75,
        guidance_scale=8.5,
        negative_prompt="مشوه، ضبابي، سيء الجودة"
    )
    
    print("تم توليد الصورة باستخدام المكونات المنفصلة")
    
except Exception as e:
    print(f"خطأ في التوليد باستخدام المكونات: {e}")

# ملخص النتائج
print("\n" + "="*50)
print("ملخص النتائج:")
print(f"- تم توليد {len(images)} صور باستخدام خط الأنابيب")
print(f"- تم توليد {len(variations)} اختلافات")
print(f"- تم معالجة {len(prompts_batch)} طلبات دفعات")
print(f"- تم حفظ جميع الصور في مجلد 'generated_text2img/'")
print("="*50)

# نظام متكامل لنقل الأسلوب باستخدام تقنيات متقدمة
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import transforms, models
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import os
from tqdm import tqdm

class NeuralStyleTransfer:
    def __init__(self, device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.device = device
        self.cnn = None
        self.content_layers = ['conv_4']
        self.style_layers = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']
        self.content_weight = 1
        self.style_weight = 1e6
        self.generated_image = None
        
        print(f"تهيئة نظام نقل الأسلوب على جهاز: {self.device}")
    
    def load_vgg19(self):
        """تحميل نموذج VGG19 مسبق التدريب"""
        print("جارِ تحميل نموذج VGG19...")
        
        vgg = models.vgg19(pretrained=True).features.to(self.device).eval()
        
        # تجميد جميع المعاملات
        for param in vgg.parameters():
            param.requires_grad_(False)
        
        self.cnn = vgg
        return vgg
    
    def image_loader(self, image_path, imsize=512):
        """تحميل ومعالجة الصورة"""
        loader = transforms.Compose([
            transforms.Resize((imsize, imsize)),
            transforms.ToTensor()
        ])
        
        image = Image.open(image_path)
        image = loader(image).unsqueeze(0)
        return image.to(self.device, torch.float)
    
    def imshow(self, tensor, title=None):
        """عرض صورة من tensor"""
        unloader = transforms.ToPILImage()
        image = tensor.cpu().clone()
        image = image.squeeze(0)
        image = unloader(image)
        
        plt.imshow(image)
        if title:
            plt.title(title)
        plt.pause(0.001)
    
    def get_features(self, image, model):
        """استخراج الميزات من طبقات النموذج"""
        layers = {
            '0': 'conv_1',
            '5': 'conv_2',
            '10': 'conv_3',
            '19': 'conv_4',
            '28': 'conv_5'
        }
        
        features = {}
        x = image
        
        for name, layer in model._modules.items():
            x = layer(x)
            if name in layers:
                features[layers[name]] = x
        
        return features
    
    def gram_matrix(self, tensor):
        """حساب مصفوفة Gram"""
        _, d, h, w = tensor.size()
        tensor = tensor.view(d, h * w)
        gram = torch.mm(tensor, tensor.t())
        return gram
    
    def style_transfer(self, content_path, style_path, 
                      num_steps=500, content_weight=1, style_weight=1e6,
                      learning_rate=0.01):
        """تنفيذ نقل الأسلوب"""
        # تحميل النموذج
        if self.cnn is None:
            self.load_vgg19()
        
        # تحميل الصور
        content_img = self.image_loader(content_path)
        style_img = self.image_loader(style_path)
        
        # إنشاء صورة الهدف (تبدأ من صورة المحتوى)
        input_img = content_img.clone().requires_grad_(True)
        
        # اختيار المُحسِّن
        optimizer = optim.Adam([input_img], lr=learning_rate)
        
        print("بدء عملية نقل الأسلوب...")
        
        for step in tqdm(range(num_steps)):
            # استخراج الميزات
            content_features = self.get_features(content_img, self.cnn)
            style_features = self.get_features(style_img, self.cnn)
            input_features = self.get_features(input_img, self.cnn)
            
            # حساب خسارة المحتوى
            content_loss = 0
            for layer in self.content_layers:
                content_loss += F.mse_loss(
                    input_features[layer], 
                    content_features[layer]
                )
            
            # حساب خسارة الأسلوب
            style_loss = 0
            for layer in self.style_layers:
                input_gram = self.gram_matrix(input_features[layer])
                style_gram = self.gram_matrix(style_features[layer])
                style_loss += F.mse_loss(input_gram, style_gram)
            
            # الخسارة الكلية
            total_loss = content_weight * content_loss + style_weight * style_loss
            
            # تحديث الصورة
            optimizer.zero_grad()
            total_loss.backward()
            optimizer.step()
            
            # قص القيم إلى النطاق الصحيح
            with torch.no_grad():
                input_img.data.clamp_(0, 1)
            
            # عرض التقدم
            if step % 100 == 0:
                print(f"الدورة {step}: الخسارة = {total_loss.item():.4f}")
        
        print("اكتملت عملية نقل الأسلوب!")
        self.generated_image = input_img
        return input_img
    
    def fast_style_transfer(self, content_path, style_path):
        """نقل أسلوب سريع باستخدام نماذج مسبقة التدريب"""
        print("جارِ نقل الأسلوب باستخدام نموذج سريع...")
        
        # استخدام نموذج مسبق التدريب من Torch Hub
        model = torch.hub.load(
            'pytorch/vision:v0.10.0',
            'fast_neural_style',
            model_name='candy',
            pretrained=True
        ).to(self.device).eval()
        
        # تحميل الصور
        content_image = self.image_loader(content_path)
        
        # تطبيق النموذج
        with torch.no_grad():
            stylized = model(content_image)
        
        # قص القيم
        stylized = stylized.clamp(0, 1)
        
        self.generated_image = stylized
        return stylized
    
    def multi_style_transfer(self, content_path, style_paths, 
                           style_weights=None):
        """نقل أسلوب متعدد من عدة صور أسلوب"""
        print("جارِ نقل أسلوب متعدد...")
        
        if self.cnn is None:
            self.load_vgg19()
        
        # تحميل صورة المحتوى
        content_img = self.image_loader(content_path)
        
        # تحميل صور الأسلوب
        style_imgs = [self.image_loader(path) for path in style_paths]
        
        if style_weights is None:
            style_weights = [1.0 / len(style_paths)] * len(style_paths)
        
        # إنشاء صورة الهدف
        input_img = content_img.clone().requires_grad_(True)
        optimizer = optim.Adam([input_img], lr=0.03)
        
        num_steps = 300
        content_weight = 1
        style_weight = 1e6
        
        for step in tqdm(range(num_steps)):
            # استخراج ميزات المحتوى
            content_features = self.get_features(content_img, self.cnn)
            input_features = self.get_features(input_img, self.cnn)
            
            # حساب خسارة المحتوى
            content_loss = 0
            for layer in self.content_layers:
                content_loss += F.mse_loss(
                    input_features[layer], 
                    content_features[layer]
                )
            
            # حساب خسارة الأسلوب من جميع صور الأسلوب
            style_loss = 0
            for style_img, weight in zip(style_imgs, style_weights):
                style_features = self.get_features(style_img, self.cnn)
                
                for layer in self.style_layers:
                    input_gram = self.gram_matrix(input_features[layer])
                    style_gram = self.gram_matrix(style_features[layer])
                    style_loss += weight * F.mse_loss(input_gram, style_gram)
            
            # الخسارة الكلية
            total_loss = content_weight * content_loss + style_weight * style_loss
            
            # تحديث الصورة
            optimizer.zero_grad()
            total_loss.backward()
            optimizer.step()
            
            # قص القيم
            with torch.no_grad():
                input_img.data.clamp_(0, 1)
        
        self.generated_image = input_img
        return input_img
    
    def save_result(self, output_path="stylized_output.jpg"):
        """حفظ الصورة الناتجة"""
        if self.generated_image is None:
            print("لا توجد صورة مولدة للحفظ")
            return
        
        # تحويل tensor إلى صورة
        unloader = transforms.ToPILImage()
        image = self.generated_image.cpu().clone()
        image = image.squeeze(0)
        image = unloader(image)
        
        # حفظ الصورة
        image.save(output_path)
        print(f"تم حفظ الصورة في: {output_path}")
        
        return output_path
    
    def visualize_comparison(self, content_path, style_path, 
                           result_path=None):
        """تصور المقارنة بين الصور"""
        fig, axes = plt.subplots(1, 3, figsize=(15, 5))
        
        # تحميل وعرض صورة المحتوى
        content_img = Image.open(content_path)
        axes[0].imshow(content_img)
        axes[0].set_title("صورة المحتوى")
        axes[0].axis('off')
        
        # تحميل وعرض صورة الأسلوب
        style_img = Image.open(style_path)
        axes[1].imshow(style_img)
        axes[1].set_title("صورة الأسلوب")
        axes[1].axis('off')
        
        # عرض النتيجة
        if result_path and os.path.exists(result_path):
            result_img = Image.open(result_path)
            axes[2].imshow(result_img)
            axes[2].set_title("النتيجة بعد نقل الأسلوب")
        elif self.generated_image is not None:
            unloader = transforms.ToPILImage()
            image = self.generated_image.cpu().clone()
            image = image.squeeze(0)
            image = unloader(image)
            axes[2].imshow(image)
            axes[2].set_title("النتيجة بعد نقل الأسلوب")
        else:
            axes[2].text(0.5, 0.5, "لم يتم توليد النتيجة بعد",
                        ha='center', va='center', fontsize=12)
            axes[2].set_title("النتيجة")
        
        axes[2].axis('off')
        
        plt.tight_layout()
        plt.show()
    
    def batch_process(self, content_images, style_image, output_dir="batch_results"):
        """معالجة دفعات من صور المحتوى"""
        print(f"جارِ معالجة {len(content_images)} صورة...")
        
        os.makedirs(output_dir, exist_ok=True)
        results = []
        
        for i, content_path in enumerate(content_images):
            print(f"معالجة الصورة {i+1}/{len(content_images)}: {content_path}")
            
            try:
                # تطبيق نقل الأسلوب
                result = self.style_transfer(
                    content_path, style_image,
                    num_steps=200,  # عدد أقل من الخطوات للسرعة
                    learning_rate=0.02
                )
                
                # حفظ النتيجة
                output_path = os.path.join(
                    output_dir, 
                    f"result_{i}_{os.path.basename(content_path)}"
                )
                
                self.generated_image = result
                saved_path = self.save_result(output_path)
                
                results.append({
                    'content': content_path,
                    'style': style_image,
                    'result': saved_path,
                    'success': True
                })
                
            except Exception as e:
                print(f"خطأ في معالجة {content_path}: {e}")
                results.append({
                    'content': content_path,
                    'style': style_image,
                    'error': str(e),
                    'success': False
                })
        
        print(f"تم معالجة {len([r for r in results if r['success']])} صورة بنجاح")
        return results

# مثال للاستخدام
style_transfer = NeuralStyleTransfer()

# 1. نقل أسلوب تقليدي
print("="*50)
print("1. نقل أسلوب تقليدي")
print("="*50)

content_image = "content.jpg"  # استبدل بمسار صورة المحتوى
style_image = "style.jpg"      # استبدل بمسار صورة الأسلوب

if os.path.exists(content_image) and os.path.exists(style_image):
    # تطبيق نقل الأسلوب
    result = style_transfer.style_transfer(
        content_image, style_image,
        num_steps=300,
        content_weight=1,
        style_weight=1e5,
        learning_rate=0.03
    )
    
    # حفظ النتيجة
    output_path = style_transfer.save_result("stylized_result.jpg")
    
    # عرض المقارنة
    style_transfer.visualize_comparison(content_image, style_image, output_path)
else:
    print("ملاحظة: استبدل مسارات الصور بأخرى حقيقية للتجربة")

# 2. نقل أسلوب سريع (إذا كان النموذج متوفر)
print("\n" + "="*50)
print("2. نقل أسلوب سريع")
print("="*50)

try:
    if os.path.exists(content_image):
        fast_result = style_transfer.fast_style_transfer(content_image, style_image)
        fast_output = style_transfer.save_result("fast_stylized.jpg")
        print(f"تم إنشاء النتيجة السريعة: {fast_output}")
except Exception as e:
    print(f"خطأ في النقل السريع: {e}")

# 3. نقل أسلوب متعدد
print("\n" + "="*50)
print("3. نقل أسلوب متعدد")
print("="*50)

# قائمة بصور الأسلوب (تعديل حسب المتوفر)
style_images = ["style1.jpg", "style2.jpg", "style3.jpg"]
existing_styles = [s for s in style_images if os.path.exists(s)]

if len(existing_styles) >= 2 and os.path.exists(content_image):
    print(f"جارِ تطبيق أسلوب من {len(existing_styles)} صورة...")
    
    multi_result = style_transfer.multi_style_transfer(
        content_image,
        existing_styles,
        style_weights=[0.4, 0.3, 0.3] if len(existing_styles) == 3 else None
    )
    
    multi_output = style_transfer.save_result("multi_style_result.jpg")
    print(f"تم إنشاء النتيجة متعددة الأساليب: {multi_output}")
else:
    print("ملاحظة: أضف صور أسلوب متعددة للتجربة")

# 4. معالجة دفعات (مثال نظري)
print("\n" + "="*50)
print("4. معالجة دفعات")
print("="*50)

# قائمة بصور المحتوى (تعديل حسب المتوفر)
content_images = ["content1.jpg", "content2.jpg", "content3.jpg"]
existing_contents = [c for c in content_images if os.path.exists(c)]

if len(existing_contents) > 0 and os.path.exists(style_image):
    print(f"جارِ معالجة {len(existing_contents)} صورة...")
    
    batch_results = style_transfer.batch_process(
        existing_contents,
        style_image,
        output_dir="batch_stylized"
    )
    
    print(f"ملخص المعالجة الدفعية:")
    for i, result in enumerate(batch_results):
        status = "ناجح" if result['success'] else "فاشل"
        print(f"  الصورة {i+1}: {status}")
else:
    print("ملاحظة: أضف صور محتوى متعددة لمعالجة دفعات")

print("\n" + "="*50)
print("ملخص خيارات نقل الأسلوب:")
print("1. نقل أسلوب تقليدي - دقيق ولكن بطيء")
print("2. نقل أسلوب سريع - سريع ولكن أقل دقة")
print("3. نقل أسلوب متعدد - دمج عدة أساليب")
print("4. معالجة دفعات - فعال للعديد من الصور")
print("="*50)