Bài 33: Các kiến trúc CNN nổi bật: VGG, ResNet, EfficientNet (overview)

Sau bài học, bạn sẽ:

• Đặt được các kiến trúc CNN nổi bật vào dòng thời gian và biết mỗi kiến trúc đóng góp ý tưởng gì.
• Giải thích residual connection trong ResNet, Inception module, depthwise separable trong MobileNet, compound scaling trong EfficientNet.
• Đọc được bảng so sánh param / accuracy / latency và chọn kiến trúc phù hợp cho một use case cụ thể (edge, balance, highest accuracy).
• Load một pretrained model bất kỳ từ torchvision và đếm số param.
• Biết vị trí của Vision Transformer và xu hướng hybrid CNN + Attention.

Bài này nối Bài 32 — Transfer Learning (đã dùng ResNet làm backbone) với Bài 34 — Sequential Data (Module 5, mở sang RNN).

Tóm tắt các mốc chính trong lịch sử CNN cho image classification:

Quy luật chung qua các năm: số layer tăng, param mỗi layer giảm thông qua kỹ thuật (1x1 bottleneck, depthwise separable), đồng thời mạng được structure hoá rõ hơn (block lặp lại, scaling rule). Accuracy ImageNet top-1 tăng từ ~58% (AlexNet) lên ~88% (ConvNeXt-XL / ViT-Large), trong khi efficiency cũng tăng — EfficientNet-B0 đạt ~77% với chỉ 5.3M param.

LeNet-5 (LeCun et al., 1998) là CNN đầu tiên dùng được trong sản phẩm thực — đọc số viết tay trên check ngân hàng tại Mỹ. Train trên MNIST (28×28 grayscale digit).

Cấu trúc 7 layer (không tính input):

Input (1, 32, 32)
→ Conv 5x5, 6 filter   → (6, 28, 28)
→ AvgPool 2x2          → (6, 14, 14)
→ Conv 5x5, 16 filter  → (16, 10, 10)
→ AvgPool 2x2          → (16, 5, 5)
→ Flatten              → 400
→ FC 120 → FC 84 → FC 10

Tổng param ~60K. Activation gốc là tanh / sigmoid (ReLU chưa phổ biến). Bài học từ LeNet vẫn áp dụng tới nay: stack Conv + Pool để rút gọn dần spatial, kết bằng FC layer cho classification.

Hạn chế: dataset MNIST quá đơn giản; LeNet trên ImageNet không train được vì compute thiếu và mạng không đủ sâu. Phải đợi 14 năm cho đến AlexNet.

AlexNet (Krizhevsky, Sutskever & Hinton, 2012) thắng ImageNet 2012 với top-5 error 15.3% — vượt xa kết quả tốt nhất trước đó (~26% bằng feature engineering thủ công + SVM). Đây là tín hiệu rõ ràng nhất cho cộng đồng CV rằng deep learning hoạt động.

Cấu trúc 8 layer (5 Conv + 3 FC), ~60M param:

Input (3, 224, 224)
→ Conv 11x11 stride 4, 96 filter   → (96, 55, 55)
→ MaxPool 3x3 stride 2             → (96, 27, 27)
→ Conv 5x5, 256 filter             → (256, 27, 27)
→ MaxPool                          → (256, 13, 13)
→ Conv 3x3, 384 filter             → (384, 13, 13)
→ Conv 3x3, 384 filter             → (384, 13, 13)
→ Conv 3x3, 256 filter             → (256, 13, 13)
→ MaxPool                          → (256, 6, 6)
→ Flatten → FC 4096 → FC 4096 → FC 1000

Đóng góp kỹ thuật:

• ReLU thay tanh/sigmoid — train nhanh hơn nhiều và giảm vanishing gradient.
• Dropout trong FC layer — chống overfitting trên dataset 1.2M ảnh.
• GPU training — train trên 2 GPU NVIDIA GTX 580 (3GB VRAM mỗi cái), chia mạng thành hai stream song song. Đây là first major paper coi GPU như công cụ DL chuẩn.
• Data augmentation (random crop, horizontal flip, PCA color jitter).
• Local Response Normalization — sau này được thay bằng BatchNorm.

Hai stream trên 2 GPU không phải kiến trúc bắt buộc mà là constraint phần cứng thời đó. Implementation modern thường gộp lại thành một stream.

VGG (Simonyan & Zisserman, 2014, Oxford) đặt câu hỏi: nếu chỉ dùng Conv 3x3, đẩy mạng sâu hơn, kết quả thế nào? Câu trả lời: rất tốt — VGG-16 đạt top-5 error ~7.3% trên ImageNet.

Quy tắc thiết kế VGG:

• Chỉ Conv 3x3 với padding 1 (giữ same size), stride 1.
• MaxPool 2x2 stride 2 giữa các block để downsample.
• Mỗi lần MaxPool, double số channel: 64 → 128 → 256 → 512.
• VGG-16 có 13 Conv + 3 FC = 16 layer trọng số; VGG-19 có 16 Conv + 3 FC.

Lý do dùng 3x3 thay vì kernel lớn (xem Bài 28 — receptive field): stack 2 Conv 3x3 cho receptive field 5x5 với ít param hơn và thêm phi tuyến giữa các layer.

Số param khá lớn — VGG-16 có ~138M param, trong đó ~123M nằm ở 3 layer FC cuối. Phần Conv chỉ ~15M. Đây cũng là lý do modern architecture thay FC bằng Global Average Pooling.

VGG vẫn được dùng phổ biến hôm nay: feature extractor cho style transfer (Gatys et al., 2015 — neural style dựa trên VGG-19), perceptual loss, GAN evaluator. Kiến trúc đơn giản, regular, dễ chỉnh.

GoogLeNet (Szegedy et al., 2014, Google) thắng ImageNet 2014 cùng năm với VGG. Ý tưởng then chốt: Inception module — thay vì chọn 1 kernel size, dùng nhiều kernel size song song và concat kết quả.

Một Inception module v1 gồm 4 nhánh:

Input feature map
├── Conv 1x1
├── Conv 1x1 → Conv 3x3
├── Conv 1x1 → Conv 5x5
└── MaxPool 3x3 → Conv 1x1
                ↓
       Concat dọc channel

Mỗi nhánh nhìn input qua receptive field khác nhau (1, 3, 5, hoặc pooling). Concat đầu ra cho mạng tự chọn pha trộn scale tốt nhất.

Vai trò Conv 1x1: bottleneck giảm channel trước khi Conv 3x3 hoặc 5x5 đắt tiền (xem Bài 28). Nhờ vậy GoogLeNet chỉ ~7M param — kém VGG-16 gần 20 lần, mà accuracy ngang.

Inception v2 (Ioffe & Szegedy, 2015) thêm BatchNorm; Inception v3 (Szegedy et al., 2016) thay Conv 5x5 bằng 2 Conv 3x3 (theo bài học VGG), thêm factorized Conv (3x3 → 1x3 + 3x1). Inception-ResNet (2016) kết hợp với residual connection.

ResNet (He et al., 2015, Microsoft Research) thắng ImageNet 2015 với top-5 error 3.57% — vượt cả human-level. Đóng góp: residual connection (skip connection) giải bài toán train mạng rất sâu.

Trước ResNet, train mạng >30 layer cho ImageNet thường tệ hơn mạng 20 layer — không phải overfitting mà là optimization khó. Vanishing gradient và degradation problem.

Ý tưởng: thay vì học mapping \( H(x) \) trực tiếp, học residual \( F(x) = H(x) - x \), output là:

\[ y = F(x) + x \]

Skip connection \( + x \) cộng input vào output. Nếu mapping tối ưu gần với identity, mạng chỉ cần đẩy \( F(x) \to 0 \) — dễ hơn nhiều so với học identity từ đầu. Đồng thời gradient có "đường tắt" về layer sớm — giảm vanishing.

Building block trong ResNet:

Basic block (ResNet-18, 34):
x ─┬─ Conv 3x3 → BN → ReLU → Conv 3x3 → BN ─ + ─ ReLU →
   └────────────────── skip ───────────────────┘

Bottleneck block (ResNet-50, 101, 152):
x ─┬─ Conv 1x1 → BN → ReLU
   │   → Conv 3x3 → BN → ReLU
   │   → Conv 1x1 → BN ──── + ─ ReLU →
   └─────── skip ───────────┘

Param theo variant:

ResNet là default backbone cho rất nhiều task hiện nay: detection (Faster R-CNN, Mask R-CNN dùng ResNet-50/101), segmentation (DeepLab), feature extractor cho retrieval, perceptual loss. Khi không chắc dùng gì, ResNet-50 pretrained ImageNet là điểm xuất phát an toàn.

Skip connection đã lan ra ngoài CNN: Transformer (block residual), U-Net (skip cross-resolution), nhiều mô hình modern khác.

DenseNet (Huang et al., 2017) tổng quát hóa skip connection: mỗi layer nhận concat output của tất cả layer trước nó, thay vì chỉ cộng từ một layer.

Layer L nhận: [x0, x1, x2, ..., x_{L-1}]  (concat dọc channel)

Lợi ích:

• Feature reuse: layer sâu có thể dùng feature từ layer rất sớm.
• Gradient flow tốt — mỗi layer có "đường tắt" tới mọi layer sau.
• Số param ít hơn ResNet cùng accuracy. DenseNet-121 chỉ ~8M param vs ResNet-50 ~25M.

Nhược: concat làm tăng channel nhanh; memory access pattern không thân thiện GPU như add. Trong thực tế DenseNet ít phổ biến hơn ResNet vì lý do engineering, nhưng ý tưởng dense connection xuất hiện lại trong nhiều mô hình segmentation và detection.

Smartphone, IoT, drone cần model nhỏ, latency thấp, ít RAM. Hai dòng tiêu biểu:

SqueezeNet (Iandola et al., 2016):

• Fire module: Conv 1x1 squeeze (giảm channel) → song song Conv 1x1 và Conv 3x3 expand.
• ~1.2M param — kém AlexNet 50 lần, accuracy ImageNet tương đương.
• Sau quantization (8-bit) còn ~0.5 MB — vừa firmware.

MobileNet (Howard et al., 2017 — v1, Sandler et al., 2018 — v2, Howard et al., 2019 — v3):

• Ý tưởng cốt lõi: depthwise separable convolution (xem Bài 28). Tách Conv thường thành depthwise (3x3 mỗi channel độc lập) + pointwise (1x1 trộn channel). Giảm param và FLOPs khoảng 8–9 lần với chất lượng feature giảm rất nhẹ.
• MobileNet v2 thêm inverted residual và linear bottleneck.
• MobileNet v3 dùng NAS để tinh chỉnh kiến trúc, kết hợp Squeeze-Excitation block và h-swish activation.
• MobileNet v2 ~3.4M param, ImageNet top-1 ~72%. v3-Large ~5.4M, ~75%.

Các variant này thường được benchmark theo cả accuracy lẫn latency thực đo trên smartphone (vd Pixel 1) chứ không chỉ FLOPs — vì FLOPs không đại diện chính xác cho thời gian thực.

EfficientNet (Tan & Le, 2019, Google) đặt câu hỏi: khi muốn scale up một model có cùng base, scale chiều nào (depth, width, hay input resolution) là tốt nhất?

Câu trả lời: scale đồng thời cả ba theo một tỷ lệ tính toán được. Đây là compound scaling:

\[ \text{depth} = \alpha^\phi, \quad \text{width} = \beta^\phi, \quad \text{resolution} = \gamma^\phi \]

với ràng buộc \( \alpha \cdot \beta^2 \cdot \gamma^2 \approx 2 \) (compute tăng gấp đôi mỗi step \( \phi \)). \( \alpha, \beta, \gamma \) tìm bằng grid search nhỏ trên base model. \( \phi \) là biến scale chính.

EfficientNet base model (B0) tìm bằng NAS với constraint mobile. Sau đó scale lên B1 → B7 bằng compound scaling:

Tại thời điểm 2019–2020, EfficientNet cho tỷ lệ accuracy/param tốt nhất. Sau đó EfficientNet v2 (Tan & Le, 2021) cải thiện thêm tốc độ train với fused-MBConv.

Lưu ý: con số accuracy trên giấy phụ thuộc heavy data augmentation (AutoAugment, RandAugment), stochastic depth, EMA. So sánh cross-architecture nên đảm bảo cùng training recipe.

NAS (Neural Architecture Search) tự động hóa thiết kế kiến trúc thay vì thiết kế tay. Ý tưởng: định nghĩa search space (các block, kernel size, connection có thể) và dùng RL, evolutionary algorithm, hoặc gradient-based search để tìm kiến trúc tốt nhất theo metric (accuracy, latency).

Một số mốc:

• NASNet (Zoph et al., 2018) — search trên CIFAR rồi transfer sang ImageNet. Kết quả tốt nhưng compute rất đắt.
• MnasNet (Tan et al., 2019) — search có constraint latency trên thiết bị thật. Cho ra kiến trúc rẻ cho mobile.
• EfficientNet-B0 — base model tìm bằng MnasNet-style search.
• DARTS (Liu et al., 2019) — differentiable architecture search, dùng gradient để search trực tiếp. Rẻ hơn RL nhiều bậc.

NAS thuộc nhóm AutoML — tự động hoá phần nào pipeline ML. Hạn chế: compute đắt (nhiều GPU-day để search một kiến trúc), kết quả khó interpret, đôi khi overfit search criterion. Trong thực tế đa số team vẫn dùng kiến trúc public đã proven thay vì tự search.

Sau 2020, ViT (Vision Transformer) cạnh tranh trực tiếp với CNN trên ImageNet. ConvNeXt (Liu et al., 2022, Meta AI) đặt câu hỏi: nếu áp dụng các best practice từ Transformer vào CNN cũ, kết quả thế nào?

Các thay đổi so với ResNet:

• Depthwise Conv 7x7 thay Conv 3x3 — bắt chước "global" receptive field của attention.
• LayerNorm thay BatchNorm.
• GELU thay ReLU.
• Inverted bottleneck (giống MobileNet v2, Transformer FFN).
• Patchify stem (Conv 4x4 stride 4) giống ViT.
• Bỏ activation và normalization ở một số chỗ — ít hơn so với ResNet.

Kết quả: ConvNeXt-T (29M param) ~82.1% ImageNet, ConvNeXt-XL (350M) ~87.8% — cạnh tranh với Swin Transformer và ViT cùng size. Bài này cho thấy CNN vẫn còn dư địa khi áp dụng đúng technique.

Bài 33 focus CNN, nhưng cần biết ViT ở mức overview để hiểu landscape hiện tại.

Vision Transformer (Dosovitskiy et al., 2020, Google) áp dụng Transformer encoder (vốn cho NLP) cho ảnh:

1. Chia ảnh thành các patch \( 16 \times 16 \) (hoặc \( 14 \times 14 \), \( 32 \times 32 \)).
2. Flatten mỗi patch thành vector, thêm positional embedding.
3. Đưa vào Transformer encoder (multi-head self-attention + FFN, stack nhiều layer).
4. Class token cuối → MLP head cho classification.

Phát hiện chính: với dataset đủ lớn (JFT-300M, 300 triệu ảnh), ViT vượt ResNet/EfficientNet trên ImageNet. Với dataset nhỏ (chỉ ImageNet 1.2M), ViT hơi kém CNN vì không có inductive bias spatial sẵn (translation equivariance) như Conv.

Các variant kế tiếp: DeiT (data-efficient ViT, Touvron et al., 2021), Swin Transformer (Liu et al., 2021 — windowed attention, hierarchical, cạnh tranh trực tiếp với CNN trên detection/segmentation).

Chi tiết Transformer sẽ học trong Module 6 — đây chỉ là mention.

Số ImageNet top-1 dưới đây từ paper gốc hoặc torchvision model zoo (recipe modern, có thể cao hơn paper gốc vài %). Latency mang tính tương đối — phụ thuộc hardware, framework, batch size.

Gợi ý chọn theo ngữ cảnh:

• Edge / mobile / latency < 30ms trên CPU: MobileNet v2/v3, EfficientNet-B0 hoặc B1. Sau khi train, quantize 8-bit để giảm thêm size.
• Balance accuracy & speed (server với GPU vừa, real-time): ResNet-50 hoặc EfficientNet-B3. ResNet-50 phổ biến hơn, framework / tooling support tốt nhất.
• Highest accuracy (offline batch, server với GPU mạnh): ConvNeXt-XL, EfficientNet-B7, ViT-Large. Khác biệt nhỏ — chọn theo dataset có sẵn pretrained và pipeline.
• Train from scratch nhanh trên dataset nhỏ (CIFAR, vài chục nghìn ảnh): ResNet-18 hoặc ResNet-20-CIFAR. Đủ accuracy, train được trên 1 GPU trong vài giờ.
• Detection / segmentation backbone: ResNet-50/101 vẫn là default vì compatible với Faster R-CNN, Mask R-CNN, FPN. ConvNeXt và Swin Transformer là alternative hiện đại.
• Style transfer, perceptual loss: VGG-16 hoặc VGG-19 — feature có texture detail tốt cho task này.
• Dataset rất lớn (hàng chục triệu ảnh) hoặc có pretrain self-supervised: ViT thường vượt CNN. Với ImageNet thuần (1.2M), khác biệt không lớn.

Quy tắc thực dụng: khi không chắc, bắt đầu với ResNet-50 pretrained ImageNet. Đo baseline, sau đó mới swap sang model lớn hơn hoặc nhỏ hơn theo nhu cầu.

torchvision.models cung cấp khoảng 30+ kiến trúc pretrained ImageNet:

from torchvision import models

resnet = models.resnet50(weights="DEFAULT")
efficientnet = models.efficientnet_b0(weights="DEFAULT")
convnext = models.convnext_tiny(weights="DEFAULT")
vgg = models.vgg16(weights="DEFAULT")
mobilenet = models.mobilenet_v3_large(weights="DEFAULT")
vit = models.vit_b_16(weights="DEFAULT")

weights="DEFAULT" dùng pretrained mới nhất. Mỗi model có thể có nhiều bộ weight (vd ResNet50_Weights.IMAGENET1K_V1 và V2) — V2 dùng recipe train hiện đại hơn, accuracy cao hơn.

Đi kèm transform chuẩn để input đúng phân phối:

weights = models.ResNet50_Weights.DEFAULT
preprocess = weights.transforms()    # Resize, CenterCrop, Normalize
print(weights.meta["_metrics"])      # accuracy trên ImageNet

Cho thư viện rộng hơn (gồm ConvNeXt-V2, Swin-V2, MaxViT, RegNetY, hàng trăm variant), dùng timm (PyTorch Image Models, Wightman 2019):

# pip install timm
import timm

model = timm.create_model("convnext_tiny", pretrained=True)
model = timm.create_model("efficientnet_b0", pretrained=True)
model = timm.create_model("vit_base_patch16_224", pretrained=True)

print(len(timm.list_models()))      # 700+ models

timm là chuẩn de facto cho image classification research vì cập nhật nhanh và bao phủ rộng hơn torchvision.

Một số ý tưởng xuất hiện đi xuất hiện lại — đáng nhớ kỹ:

• Skip / Residual connection (ResNet 2015): \( y = F(x) + x \). Cho phép train mạng rất sâu. Có mặt trong gần như mọi mô hình modern (CNN, Transformer, U-Net).
• 1x1 Convolution (Inception 2014, ResNet bottleneck): giảm/tăng channel với chi phí thấp, trộn channel mà không thay đổi không gian.
• Depthwise Separable Conv (MobileNet 2017, Xception 2017): tách spatial và channel mixing, giảm param/FLOPs ~9 lần.
• Squeeze-Excitation (SE) block (Hu et al., 2018 — SENet): học channel attention qua global pool + 2 FC + sigmoid. Có mặt trong EfficientNet, MobileNet v3.
• Group Convolution (AlexNet, ResNeXt 2017): chia channel thành nhóm độc lập. ResNeXt thay "depth" bằng "cardinality" (số nhóm).
• Global Average Pooling (NIN, GoogLeNet): thay FC cuối bằng average pool toàn feature map, giảm param mạnh.
• Batch / Layer Normalization: cải thiện training stability. BN trong CNN cổ điển, LN trong ConvNeXt và Transformer.

Khi đọc một paper architecture mới, thường gặp tổ hợp các block này với vài tweak nhỏ — biết các "viên gạch" giúp đọc paper nhanh.

Bức tranh tại thời điểm 2024–2026 (dựa trên paper được trích nhiều):

• ViT thắng khi pretrain trên dataset rất lớn (JFT, LAION, DINOv2). Self-supervised pretraining + finetune cho downstream task hoạt động tốt với attention.
• CNN vẫn cạnh tranh tốt trong nhiều use case: detection (ResNet vẫn dominant trong production), edge, dataset trung bình. ConvNeXt-V2 chứng minh CNN khi modern hoá đầy đủ vẫn so kè ViT.
• Hybrid CNN + Attention: nhiều mô hình mới dùng Conv ở lớp đầu (early stage — feature local, có inductive bias spatial) và Attention ở lớp sâu (long-range reasoning). Vd CoAtNet, MaxViT, MobileViT.
• Foundation model cho vision: CLIP (OpenAI 2021 — image-text contrastive), DINOv2 (Meta 2023 — self-supervised), SAM (Meta 2023 — segmentation universal). Đa số dùng ViT backbone, train trên dataset cực lớn, output embedding/feature đủ tổng quát để dùng cho rất nhiều task downstream với rất ít label.

Lưu ý: "model tốt nhất" thay đổi theo task, dataset size, latency budget. Một benchmark tốt phải fix các yếu tố này trước khi so sánh.

Module 4 đi qua 7 bài, từ động lực đến kiến trúc thực tế:

1. Bài 27 — Vì sao MLP không hiệu quả cho ảnh: motivation, locality, translation equivariance.
2. Bài 28 — Convolutional Layer: kernel, feature map, stride/padding/dilation, weight sharing, 1x1 / depthwise / dilated.
3. Bài 29 — Pooling Layer: max-pool, avg-pool, downsampling không học.
4. Bài 30 — Flatten / FC: chuyển từ feature map sang vector, classifier head.
5. Bài 31 — Build CNN: ghép các block thành CNN cụ thể, train trên CIFAR-10.
6. Bài 32 — Transfer Learning: dùng backbone pretrained, freeze / fine-tune.
7. Bài 33 (bài này) — Architectures overview.

Sau bài này, bạn có đủ vốn để đọc paper architecture mới (CNN hoặc ViT), implement một CNN cho task tùy chỉnh, và chọn backbone phù hợp cho project thực tế. Module 5 (từ Bài 34) sẽ rời ảnh, sang dữ liệu tuần tự (sequence) — text, time series, audio — và mô hình RNN/LSTM/GRU. Phần Transformer sẽ học ở Module 6.

Load 3 model và đếm param:

import torch
from torchvision import models

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

resnet = models.resnet50(weights="DEFAULT").to(device).eval()
effnet = models.efficientnet_b0(weights="DEFAULT").to(device).eval()
convnext = models.convnext_tiny(weights="DEFAULT").to(device).eval()

def count_params(m):
    return sum(p.numel() for p in m.parameters())

for name, m in [("ResNet-50", resnet),
                ("EfficientNet-B0", effnet),
                ("ConvNeXt-Tiny", convnext)]:
    print(f"{name:18s} {count_params(m) / 1e6:6.2f}M params")
# ResNet-50           25.56M params
# EfficientNet-B0      5.29M params
# ConvNeXt-Tiny       28.59M params

Benchmark inference time trên 1 batch:

import time

x = torch.randn(8, 3, 224, 224, device=device)

def benchmark(m, n_warmup=10, n_run=50):
    with torch.no_grad():
        for _ in range(n_warmup):
            m(x)
        if device.type == "cuda":
            torch.cuda.synchronize()
        t0 = time.perf_counter()
        for _ in range(n_run):
            m(x)
        if device.type == "cuda":
            torch.cuda.synchronize()
        return (time.perf_counter() - t0) / n_run * 1000  # ms/batch

for name, m in [("ResNet-50", resnet),
                ("EfficientNet-B0", effnet),
                ("ConvNeXt-Tiny", convnext)]:
    print(f"{name:18s} {benchmark(m):.2f} ms/batch (batch=8)")

Kết quả phụ thuộc hardware. Trên GPU consumer thường: EfficientNet-B0 nhanh nhất theo FLOPs nhưng có thể chậm hơn ResNet-50 wall-clock vì depthwise Conv tận dụng GPU kém. Đây là minh chứng "FLOPs không phải latency".

Visualize filter của Conv đầu tiên trong ResNet (kernel 7x7, 3 channel input):

import matplotlib.pyplot as plt

filters = resnet.conv1.weight.detach().cpu()  # shape (64, 3, 7, 7)
print(filters.shape)

# Chuẩn hóa về [0, 1] để hiển thị
f_min, f_max = filters.min(), filters.max()
filters = (filters - f_min) / (f_max - f_min)

fig, axes = plt.subplots(8, 8, figsize=(8, 8))
for i, ax in enumerate(axes.flat):
    ax.imshow(filters[i].permute(1, 2, 0))
    ax.axis("off")
plt.tight_layout()
plt.savefig("resnet_conv1_filters.png")

Quan sát: filter layer đầu của ResNet pretrained ImageNet trông như Gabor wavelet — detect edge ở các hướng, blob màu, gradient. Phù hợp với phân cấp Zeiler & Fergus (2014). Filter ở layer sâu hơn (vd layer3, layer4) cần kỹ thuật visualization phức tạp hơn (activation maximization, Grad-CAM) vì chúng phụ thuộc input, không xem trực tiếp trên weight được.

1. So sánh số param và accuracy của ResNet-18, ResNet-50, EfficientNet-B0 khi fine-tune trên CIFAR-10. Train 10 epoch mỗi model với cùng learning rate, optimizer, augmentation. Báo cáo accuracy test + thời gian train.
2. Implement basic block của ResNet (không bottleneck) bằng nn.Module:

   class BasicBlock(nn.Module):
       def __init__(self, in_c, out_c, stride=1):
           super().__init__()
           # TODO: 2 Conv 3x3, BN, ReLU, skip connection
           # Lưu ý: nếu stride != 1 hoặc in_c != out_c, cần Conv 1x1 trên skip
           ...
       def forward(self, x):
           ...
   

   Test với input torch.randn(1, 64, 32, 32), output shape phải bằng input shape khi stride=1.
3. Đọc paper ResNet (He et al., 2015 — arXiv:1512.03385), viết tóm tắt 5 dòng: vấn đề (degradation), giải pháp (residual), kiến trúc, kết quả ImageNet, ý nghĩa rộng hơn.
4. Load EfficientNet-B0 và EfficientNet-B3 qua torchvision. So sánh số param, input size mặc định, accuracy ImageNet trên metadata. Verify compound scaling (B3 sâu hơn / rộng hơn / input lớn hơn B0).
5. Visualize filter của Conv đầu tiên trong VGG-16 và so sánh với ResNet-50. Cả hai pretrained ImageNet, kernel layer đầu lần lượt là 3x3 và 7x7 — quan sát khác biệt.
6. Cài timm, list các variant của ConvNeXt và Swin Transformer. Chọn một variant tương đương về param với ResNet-50, đo inference time trên cùng batch. So sánh wall-clock vs FLOPs.
7. Cho một use case cụ thể (vd phân loại bệnh lá cây trên smartphone Android, latency < 100ms, accuracy > 85%), đề xuất 2 architecture phù hợp và lý do.

Bài kế tiếp: Bài 34 — Sequential Data — mở Module 5, đặc điểm dữ liệu tuần tự (text, time series, audio), vì sao MLP và CNN không phù hợp, dẫn đến RNN.