Vision Transformers: الثورة في معالجة الصور

أدخلت Vision Transformers (ViT) نهجًا جديدًا في معالجة الصور، إذ تستخدم بنية Transformers التي صُمّمت في الأصل لمعالجة اللغة الطبيعية.

بنية Vision Transformers

1. Patch Embedding

class PatchEmbed(nn.Module):
    def __init__(self, img_size, patch_size, in_channels=3, embed_dim=768):
        super().__init__()
        self.img_size = img_size
        self.patch_size = patch_size
        self.n_patches = (img_size // patch_size) ** 2
        
        self.proj = nn.Conv2d(
            in_channels,
            embed_dim,
            kernel_size=patch_size,
            stride=patch_size
        )
        
    def forward(self, x):
        x = self.proj(x)  # (B, E, H', W')
        x = x.flatten(2)  # (B, E, N)
        x = x.transpose(1, 2)  # (B, N, E)
        return x

2. Vision Transformer

class VisionTransformer(nn.Module):
    def __init__(self, img_size, patch_size, in_channels, n_classes, embed_dim, 
                 num_heads, num_layers, mlp_ratio=4., qkv_bias=True):
        super().__init__()
        
        self.patch_embed = PatchEmbed(img_size, patch_size, in_channels, embed_dim)
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.pos_embed = nn.Parameter(torch.zeros(1, self.patch_embed.n_patches + 1, embed_dim))
        self.pos_drop = nn.Dropout(p=0.1)
        
        self.blocks = nn.ModuleList([
            TransformerBlock(embed_dim, num_heads, mlp_ratio, qkv_bias)
            for _ in range(num_layers)
        ])
        
        self.norm = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, n_classes)
        
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        nn.init.trunc_normal_(self.cls_token, std=0.02)
        
    def forward(self, x):
        B = x.shape[0]
        
        # Patch embedding
        x = self.patch_embed(x)
        
        # إضافة رمز التصنيف
        cls_token = self.cls_token.expand(B, -1, -1)
        x = torch.cat((cls_token, x), dim=1)
        
        # Position embedding
        x = x + self.pos_embed
        x = self.pos_drop(x)
        
        # Transformer blocks
        for block in self.blocks:
            x = block(x)
            
        x = self.norm(x)
        x = x[:, 0]  # استخدام رمز التصنيف
        
        return self.head(x)

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

1. تصنيف الصور

from transformers import ViTImageProcessor, ViTForImageClassification

# تحميل النموذج والمعالج
processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224')
model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')

# التنبؤ
image = Image.open('image.jpg')
inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

2. كشف الأجسام

class DETR(nn.Module):
    def __init__(self, num_classes, num_queries, hidden_dim):
        super().__init__()
        
        self.backbone = VisionTransformer(...)
        self.transformer = Transformer(...)
        self.class_embed = nn.Linear(hidden_dim, num_classes + 1)
        self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3)
        
    def forward(self, x):
        features = self.backbone(x)
        hs = self.transformer(features)
        
        outputs_class = self.class_embed(hs)
        outputs_coord = self.bbox_embed(hs).sigmoid()
        
        return {'pred_logits': outputs_class[-1], 
                'pred_boxes': outputs_coord[-1]}

المزايا مقارنةً بشبكات CNN

1. الانتباه الشامل

   • فهم أفضل للسياق العام
   • التقاط العلاقات بعيدة المدى
   • أكثر مرونة من الالتفافات المحلية

2. المرونة

   • بنية موحدة لمختلف المهام
   • سهولة التوسعة
   • تكيّف أفضل مع البيانات

3. الأداء

   • نتائج متفوقة في بعض المهام
   • تعميم أفضل
   • كفاءة أعلى مع مجموعات البيانات الكبيرة

القيود والحلول

1. الحاجة إلى البيانات

• الحل: التدريب المسبق على مجموعات بيانات كبيرة
• الضبط الدقيق (Fine-tuning) على مهام محددة

2. التعقيد الحسابي

• الحل: Patch embedding فعّال
• تحسين آلية الانتباه

3. الذاكرة

• الحل: الانتباه المتناثر (Sparse Attention)
• Gradient checkpointing

أمثلة على الاستخدام

تصنيف الصور الطبية

# إعداد النموذج للصور الطبية
model = VisionTransformer(
    img_size=224,
    patch_size=16,
    in_channels=3,
    n_classes=num_classes,
    embed_dim=768,
    num_heads=12,
    num_layers=12
)

# التدريب
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

for epoch in range(num_epochs):
    model.train()
    for batch in train_loader:
        images, labels = batch
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    scheduler.step()

الخاتمة

تمثّل Vision Transformers تقدمًا كبيرًا في معالجة الصور، إذ تقدّم بديلًا قويًا لشبكات CNN التقليدية. وتجعل منها بنيتها المرنة وقدرتها على التقاط العلاقات الشاملة أداةً قيّمة للعديد من التطبيقات.

موارد إضافية

• ViT Paper
• DETR Paper
• Hugging Face Vision Transformers