Transfer Learning في Computer Vision

ImageNet (1.4M صورة، 1000 صنف)        مهمتك (10k صورة، 10 أصناف)
            ↓ transfer                       ↓
     backbone مُدرَّب              fine-tune / head only

import torchvision.models as models

# ✅ الطريقة الحالية (torchvision 0.13+)
weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)

# ❌ قديم ومهمل
# model = models.resnet18(pretrained=True)

preprocess = weights.transforms()
print(preprocess)
# ImageClassification(
#     crop_size=[224],
#     resize_size=[256],
#     mean=[0.485, 0.456, 0.406],
#     std=[0.229, 0.224, 0.225],
#     interpolation=InterpolationMode.BILINEAR
# )

import torchvision.transforms as transforms

train_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225]),
])

import torch
import torch.nn as nn
import torchvision.models as models

# 1. حمّل backbone
weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)

# 2. جمّد كل الأوزان الموجودة
for param in model.parameters():
    param.requires_grad = False

# 3. استبدل الـ classifier head
num_features = model.fc.in_features     # 512 for ResNet18
num_classes  = 10
model.fc = nn.Linear(num_features, num_classes)

# الآن فقط fc الجديد قابل للتعلّم

total = sum(p.numel() for p in model.parameters())
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"total params:     {total:,}")
print(f"trainable params: {trainable:,}")

total params:     11,181,642
trainable params: 5,130

import torch.optim as optim

# مُحسِّن يحدّث الـ fc فقط
optimizer = optim.Adam(model.fc.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

# حلقة تدريب عادية
for epoch in range(5):
    model.train()
    for xb, yb in train_loader:
        optimizer.zero_grad()
        loss = criterion(model(xb), yb)
        loss.backward()
        optimizer.step()

# مثال: حرّر layer4 فقط من ResNet18 (الطبقات العليا)
for param in model.parameters():
    param.requires_grad = False

# حرّر الطبقة العليا
for param in model.layer4.parameters():
    param.requires_grad = True

# الـ head دائمًا قابل للتعلّم
model.fc = nn.Linear(model.fc.in_features, num_classes)
for param in model.fc.parameters():
    param.requires_grad = True

# احصِ
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"trainable params (fine-tune): {trainable:,}")

backbone_params = [p for p in model.layer4.parameters() if p.requires_grad]
head_params    = list(model.fc.parameters())

optimizer = optim.Adam([
    {"params": backbone_params, "lr": 1e-4},    # 10x أصغر
    {"params": head_params,    "lr": 1e-3},
])

                بيانات تدريب صغيرة            بيانات تدريب كبيرة
                (<10k عيّنة)                    (>100k عيّنة)

تشبه           Feature extraction               Fine-tuning (أو train from
ImageNet        فقط head                         scratch إذا البيانات ضخمة جدًا)

لا تشبه        Fine-tune تدريجي                Train from scratch
ImageNet        (الطبقات العليا فقط)            أو fine-tune شامل

# أخفّ
models.mobilenet_v3_small(weights=models.MobileNet_V3_Small_Weights.DEFAULT)   # 2.5M
models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.DEFAULT)         # 5M

# أثقل، لكن أقوى
models.resnet50(weights=models.ResNet50_Weights.DEFAULT)                      # 25M
models.convnext_tiny(weights=models.ConvNeXt_Tiny_Weights.DEFAULT)            # 28M

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.models as models
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, SubsetRandomSampler
import numpy as np

torch.manual_seed(42)
np.random.seed(42)

# === 1. Backbone + Weights ===
weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)

# === 2. Freeze backbone, replace head ===
for p in model.parameters():
    p.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, 10)

# === 3. Transforms ===
# FashionMNIST رمادي → ResNet18 يتوقع RGB 224x224
train_transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=3),
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225]),
])

eval_transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=3),
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225]),
])

# === 4. Data ===
train_full = torchvision.datasets.FashionMNIST(
    root="./data", train=True, download=True, transform=train_transform
)
test_ds = torchvision.datasets.FashionMNIST(
    root="./data", train=False, download=True, transform=eval_transform
)

# subset للتدريب السريع (1000 train، 500 val، 500 test)
train_loader = DataLoader(train_full, batch_size=32,
    sampler=SubsetRandomSampler(range(1000)))
val_loader = DataLoader(train_full, batch_size=32,
    sampler=SubsetRandomSampler(range(1000, 1500)))
test_loader = DataLoader(test_ds, batch_size=32,
    sampler=SubsetRandomSampler(range(500)))

# === 5. Optimizer + Loss ===
opt = optim.Adam(model.fc.parameters(), lr=1e-3)
crit = nn.CrossEntropyLoss()

# === 6. Train loop ===
for epoch in range(3):
    model.train()
    losses = []
    for xb, yb in train_loader:
        opt.zero_grad()
        loss = crit(model(xb), yb)
        loss.backward()
        opt.step()
        losses.append(loss.item())

    model.eval()
    correct, total = 0, 0
    with torch.no_grad():
        for xb, yb in val_loader:
            yh = model(xb).argmax(1)
            correct += (yh == yb).sum().item()
            total += len(yb)
    print(f"epoch {epoch}: train_loss={sum(losses)/len(losses):.4f} "
          f"val_acc={correct/total:.3f}")

epoch 0: train_loss=1.8946 val_acc=0.416
epoch 1: train_loss=1.2049 val_acc=0.622
epoch 2: train_loss=1.0057 val_acc=0.680

model.train()    # Dropout و BatchNorm في وضع التدريب
model.eval()     # يستخدم running statistics ويُعطّل Dropout