الـ Transfer Learning

import torch
from torch import nn
from torchvision.models import resnet18, ResNet18_Weights

model = resnet18(weights=ResNet18_Weights.DEFAULT)   # downloads pretrained weights

for param in model.parameters():          # freeze everything it already learned
    param.requires_grad = False

print("original last layer:", model.fc)
model.fc = nn.Linear(model.fc.in_features, 3)   # new head: koshari / falafel / molokhia

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 parameters:     {total:,}")
print(f"trainable parameters: {trainable:,}")

food_data/
    train/
        koshari/      img001.jpg, img002.jpg, ...
        falafel/      ...
        molokhia/     ...
    val/
        koshari/      ...
        falafel/      ...
        molokhia/     ...
# folder names become the class names automatically

import torch
from torch import nn
from torchvision import datasets, transforms
from torchvision.models import resnet18, ResNet18_Weights
from torch.utils.data import DataLoader

device = "cuda" if torch.cuda.is_available() else "cpu"
weights = ResNet18_Weights.DEFAULT

train_tf = transforms.Compose([
    transforms.RandomResizedCrop(224),     # data augmentation:
    transforms.RandomHorizontalFlip(),     # new variations every epoch
    weights.transforms(),                  # resize + normalize like ImageNet
])
train_ds = datasets.ImageFolder("food_data/train", transform=train_tf)
val_ds = datasets.ImageFolder("food_data/val", transform=weights.transforms())
train_dl = DataLoader(train_ds, batch_size=32, shuffle=True)
val_dl = DataLoader(val_ds, batch_size=32)

model = resnet18(weights=weights)
for p in model.parameters():
    p.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, len(train_ds.classes))
model = model.to(device)

opt = torch.optim.Adam(model.fc.parameters(), lr=1e-3)   # only the new head
loss_fn = nn.CrossEntropyLoss()

for epoch in range(5):
    model.train()
    for xb, yb in train_dl:
        xb, yb = xb.to(device), yb.to(device)
        opt.zero_grad()
        loss_fn(model(xb), yb).backward()
        opt.step()

    model.eval()
    correct = 0
    with torch.no_grad():
        for xb, yb in val_dl:
            preds = model(xb.to(device)).argmax(1).cpu()
            correct += (preds == yb).sum().item()
    print(f"epoch {epoch}: val accuracy = {correct / len(val_ds):.1%}")