البنى المتقدمة للـ Transformers: الابتكارات والتطبيقات

تعرّف على البنى المتقدمة للـ Transformers، من النماذج متعددة الوسائط إلى البنى التكيفية، مع تطبيقات برمجية مفصّلة.

النماذج متعددة الوسائط

1. CLIP (Contrastive Language-Image Pre-training)

class CLIP(nn.Module):
    def __init__(self, image_encoder, text_encoder, projection_dim=512):
        super().__init__()
        self.image_encoder = image_encoder
        self.text_encoder = text_encoder
        
        self.image_projection = nn.Linear(
            image_encoder.output_dim, 
            projection_dim
        )
        self.text_projection = nn.Linear(
            text_encoder.output_dim, 
            projection_dim
        )
        
    def forward(self, image, text):
        # ترميز الصور
        image_features = self.image_encoder(image)
        image_features = self.image_projection(image_features)
        
        # ترميز النص
        text_features = self.text_encoder(text)
        text_features = self.text_projection(text_features)
        
        # التطبيع
        image_features = F.normalize(image_features, dim=-1)
        text_features = F.normalize(text_features, dim=-1)
        
        # حساب التشابه
        similarity = torch.matmul(
            image_features, 
            text_features.t()
        )
        
        return similarity

2. DALL-E

class DALLE(nn.Module):
    def __init__(self, vae, text_encoder, image_decoder):
        super().__init__()
        self.vae = vae
        self.text_encoder = text_encoder
        self.image_decoder = image_decoder
        
    def forward(self, text, image=None):
        # ترميز النص
        text_features = self.text_encoder(text)
        
        if image is not None:
            # وضع إعادة البناء
            image_tokens = self.vae.encode(image)
            reconstructed = self.image_decoder(
                image_tokens, 
                text_features
            )
            return reconstructed
        else:
            # وضع التوليد
            image_tokens = self.image_decoder.generate(
                text_features
            )
            return self.vae.decode(image_tokens)

البنى التكيفية

1. Mixture of Experts (MoE)

class MixtureOfExperts(nn.Module):
    def __init__(self, num_experts, expert_size, routing_size):
        super().__init__()
        self.num_experts = num_experts
        self.expert_size = expert_size
        
        # الخبراء
        self.experts = nn.ModuleList([
            nn.Linear(routing_size, expert_size)
            for _ in range(num_experts)
        ])
        
        # الموجّه
        self.router = nn.Linear(routing_size, num_experts)
        
    def forward(self, x):
        # التوجيه
        router_logits = self.router(x)
        router_probs = F.softmax(router_logits, dim=-1)
        
        # اختيار الخبراء
        expert_outputs = []
        for i in range(self.num_experts):
            expert_output = self.experts[i](x)
            expert_outputs.append(
                expert_output * router_probs[:, i].unsqueeze(-1)
            )
        
        # دمج المخرجات
        return sum(expert_outputs)

2. Sparse Attention

class SparseAttention(nn.Module):
    def __init__(self, dim, num_heads, block_size=64):
        super().__init__()
        self.dim = dim
        self.num_heads = num_heads
        self.block_size = block_size
        
        self.qkv = nn.Linear(dim, dim * 3)
        self.proj = nn.Linear(dim, dim)
        
    def forward(self, x):
        B, N, C = x.shape
        
        # إسقاط QKV
        qkv = self.qkv(x).reshape(
            B, N, 3, self.num_heads, C // self.num_heads
        ).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]
        
        # حساب الانتباه على شكل كتل
        output = torch.zeros_like(q)
        for i in range(0, N, self.block_size):
            for j in range(0, N, self.block_size):
                # الانتباه للكتلة
                q_block = q[:, :, i:i+self.block_size]
                k_block = k[:, :, j:j+self.block_size]
                v_block = v[:, :, j:j+self.block_size]
                
                # حساب الانتباه
                attn = torch.matmul(
                    q_block, 
                    k_block.transpose(-2, -1)
                )
                attn = attn.softmax(dim=-1)
                
                # تحديث المخرجات
                output[:, :, i:i+self.block_size] += torch.matmul(
                    attn, 
                    v_block
                )
        
        return self.proj(output.transpose(1, 2).reshape(B, N, C))

البنى المتخصصة

1. Longformer

class LongformerAttention(nn.Module):
    def __init__(self, dim, num_heads, window_size=512):
        super().__init__()
        self.dim = dim
        self.num_heads = num_heads
        self.window_size = window_size
        
        self.qkv = nn.Linear(dim, dim * 3)
        self.proj = nn.Linear(dim, dim)
        
    def forward(self, x, attention_mask=None):
        B, N, C = x.shape
        
        # إسقاط QKV
        qkv = self.qkv(x).reshape(
            B, N, 3, self.num_heads, C // self.num_heads
        ).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]
        
        # الانتباه بالنافذة المنزلقة
        output = torch.zeros_like(q)
        for i in range(0, N, self.window_size):
            # النافذة المنزلقة
            window_end = min(i + self.window_size, N)
            q_window = q[:, :, i:window_end]
            k_window = k[:, :, i:window_end]
            v_window = v[:, :, i:window_end]
            
            # الانتباه المحلي
            attn = torch.matmul(
                q_window, 
                k_window.transpose(-2, -1)
            )
            if attention_mask is not None:
                attn = attn.masked_fill(
                    attention_mask[:, i:window_end, i:window_end] == 0,
                    float('-inf')
                )
            attn = attn.softmax(dim=-1)
            
            # تحديث المخرجات
            output[:, :, i:window_end] = torch.matmul(attn, v_window)
        
        return self.proj(output.transpose(1, 2).reshape(B, N, C))

2. Performer

class PerformerAttention(nn.Module):
    def __init__(self, dim, num_heads, feature_dim=256):
        super().__init__()
        self.dim = dim
        self.num_heads = num_heads
        self.feature_dim = feature_dim
        
        self.q_proj = nn.Linear(dim, dim)
        self.k_proj = nn.Linear(dim, dim)
        self.v_proj = nn.Linear(dim, dim)
        self.out_proj = nn.Linear(dim, dim)
        
        # إسقاطات عشوائية
        self.random_features = torch.randn(
            feature_dim, 
            num_heads
        )
        
    def forward(self, x):
        B, N, C = x.shape
        
        # إسقاطات QKV
        q = self.q_proj(x).reshape(
            B, N, self.num_heads, C // self.num_heads
        ).transpose(1, 2)
        k = self.k_proj(x).reshape(
            B, N, self.num_heads, C // self.num_heads
        ).transpose(1, 2)
        v = self.v_proj(x).reshape(
            B, N, self.num_heads, C // self.num_heads
        ).transpose(1, 2)
        
        # تقريب الانتباه
        q_prime = torch.matmul(q, self.random_features)
        k_prime = torch.matmul(k, self.random_features)
        
        # حساب الانتباه التقريبي
        attn = torch.matmul(q_prime, k_prime.transpose(-2, -1))
        attn = attn.softmax(dim=-1)
        
        # تحديث المخرجات
        output = torch.matmul(attn, v)
        output = output.transpose(1, 2).reshape(B, N, C)
        
        return self.out_proj(output)

التطبيقات المتقدمة

1. معالجة المستندات الطويلة

class LongDocumentTransformer(nn.Module):
    def __init__(self, dim, num_heads, num_layers):
        super().__init__()
        self.layers = nn.ModuleList([
            LongformerAttention(dim, num_heads)
            for _ in range(num_layers)
        ])
        
        self.norm = nn.LayerNorm(dim)
        self.mlp = nn.Sequential(
            nn.Linear(dim, dim * 4),
            nn.GELU(),
            nn.Linear(dim * 4, dim)
        )
        
    def forward(self, x, attention_mask=None):
        for layer in self.layers:
            x = layer(x, attention_mask)
            x = self.norm(x)
            x = self.mlp(x)
        return x

2. المعالجة متعددة الوسائط

class MultimodalTransformer(nn.Module):
    def __init__(self, image_dim, text_dim, fusion_dim):
        super().__init__()
        self.image_encoder = ImageEncoder(image_dim)
        self.text_encoder = TextEncoder(text_dim)
        
        self.fusion = nn.Sequential(
            nn.Linear(image_dim + text_dim, fusion_dim),
            nn.LayerNorm(fusion_dim),
            nn.GELU(),
            nn.Linear(fusion_dim, fusion_dim)
        )
        
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(
                d_model=fusion_dim,
                nhead=8,
                dim_feedforward=fusion_dim * 4
            ),
            num_layers=6
        )
        
    def forward(self, image, text):
        # ترميز الوسائط
        image_features = self.image_encoder(image)
        text_features = self.text_encoder(text)
        
        # دمج الخصائص
        combined = torch.cat([image_features, text_features], dim=-1)
        fused = self.fusion(combined)
        
        # المعالجة بواسطة الـ transformer
        output = self.transformer(fused)
        
        return output

اختبارات الأداء والمقارنات

1. مقاييس الأداء

def benchmark_architectures():
    architectures = {
        "Standard": StandardTransformer(),
        "Longformer": LongformerTransformer(),
        "Performer": PerformerTransformer(),
        "MoE": MoETransformer()
    }
    
    results = {}
    for name, model in architectures.items():
        # اختبار السرعة
        speed = measure_inference_time(model)
        
        # اختبار الذاكرة
        memory = measure_memory_usage(model)
        
        # اختبار الدقة
        accuracy = measure_accuracy(model)
        
        results[name] = {
            "speed": speed,
            "memory": memory,
            "accuracy": accuracy
        }
    
    return results

2. مقارنة البنى

البنية	الطول الأقصى	الذاكرة	السرعة	الدقة
Standard	512	1x	1x	100%
Longformer	4096	2x	1.5x	98%
Performer	2048	1.5x	2x	97%
MoE	1024	3x	1.2x	99%

توصيات الاستخدام

1. للمستندات الطويلة

   • Longformer
   • الانتباه بالنافذة المنزلقة
   • تحسين الذاكرة

2. للمعالجة السريعة

   • Performer
   • تقريب الانتباه
   • أداء محسّن

3. للنماذج المتخصصة

   • MoE
   • خبراء متخصصون
   • تكيّف ديناميكي

الخاتمة

تقدّم البنى المتقدمة للـ Transformers حلولًا مبتكرة لمختلف حالات الاستخدام، بدءًا من معالجة المستندات الطويلة وصولًا إلى المعالجة متعددة الوسائط.

مصادر إضافية

• Longformer Paper
• Performer Paper
• MoE Paper