Convolutional Neural Network

CNN (Convolutional Neural Network) là kiến trúc mạng nơ-ron chuyên xử lý dữ liệu có cấu trúc không gian như ảnh, video, âm phổ. Khác với fully-connected (mỗi neuron nối với mọi input), CNN dùng các bộ lọc nhỏ trượt qua toàn bộ input theo phép tích chập. Ba nguyên lý cốt lõi: kết nối cục bộ, chia sẻ trọng số, và phân cấp đặc trưng.

Công thức tích chập:

Kích thước output theo stride và padding:

W = kích thước input, K = kernel, P = padding, S = stride. Với padding = "same" (= ⌊K/2⌋ khi stride 1, K lẻ), kích thước không gian giữ nguyên sau Conv.

Số tham số của một lớp Conv:

Ví dụ Conv 3×3 với 64 input channel → 128 output channel có (3×3×64+1)×128 = 73.856 params. Không phụ thuộc vào kích thước không gian — đây chính là weight sharing.

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    """CNN đơn giản cho MNIST: 28x28 -> 10 lớp."""

    def __init__(self, num_classes: int = 10):
        super().__init__()
        # Block 1: 28x28x1 -> 14x14x32
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.bn1   = nn.BatchNorm2d(32)
        self.pool1 = nn.MaxPool2d(2)  # halving

        # Block 2: 14x14x32 -> 7x7x64
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.bn2   = nn.BatchNorm2d(64)
        self.pool2 = nn.MaxPool2d(2)

        # Block 3: global avg pool tiết kiệm params so với flatten
        self.gap  = nn.AdaptiveAvgPool2d(1)
        self.drop = nn.Dropout(0.3)
        self.fc   = nn.Linear(64, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (B, 1, 28, 28)
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.pool1(x)                          # (B, 32, 14, 14)

        x = F.relu(self.bn2(self.conv2(x)))
        x = self.pool2(x)                          # (B, 64, 7, 7)

        x = self.gap(x)                            # (B, 64, 1, 1)
        x = torch.flatten(x, 1)                    # (B, 64)
        x = self.drop(x)
        return self.fc(x)                          # (B, 10) logits


# Training loop rút gọn
model = SimpleCNN().cuda()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss()

for images, labels in train_loader:
    images, labels = images.cuda(), labels.cuda()
    logits = model(images)
    loss = criterion(logits, labels)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# Tổng tham số: ~30 nghìn — nhỏ gọn nhưng đạt >99% accuracy trên MNIST

import torch
import torchvision.models as models
import torchvision.transforms as T
from PIL import Image

# Dùng ResNet18 pretrained để khảo sát feature map
model = models.resnet18(weights="IMAGENET1K_V1").eval()

# Hook để bắt activation của lớp conv2 trong block1
activations = {}
def hook(module, inp, out):
    activations["conv1"] = out.detach()

model.conv1.register_forward_hook(hook)

# Đưa một ảnh qua mạng
img = Image.open("cat.jpg").convert("RGB")
preprocess = T.Compose([
    T.Resize(256),
    T.CenterCrop(224),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406],
                std=[0.229, 0.224, 0.225]),
])
x = preprocess(img).unsqueeze(0)
with torch.no_grad():
    _ = model(x)

fmap = activations["conv1"]          # (1, 64, 112, 112)
print(fmap.shape)

# Visualize 8 feature map đầu tiên
import matplotlib.pyplot as plt
fig, axes = plt.subplots(2, 4, figsize=(10, 5))
for i, ax in enumerate(axes.flat):
    ax.imshow(fmap[0, i].cpu(), cmap="viridis")
    ax.set_title(f"filter #{i}")
    ax.axis("off")
plt.tight_layout()
plt.savefig("conv1_features.png", dpi=120)

Ứng dụng thực tế

• Nhận dạng ảnh: Google Photos, Facebook face tagging, nhận dạng biển số xe ở trạm thu phí tự động.
• Y tế: CNN phân tích X-quang, MRI, CT giúp bác sĩ phát hiện ung thư, tổn thương, bệnh võng mạc sớm hơn mắt thường.
• Xe tự lái: nhận diện người đi bộ, làn đường, biển báo trong thời gian thực ở độ trễ vài mili-giây.
• Nông nghiệp: phát hiện sâu bệnh qua ảnh lá cây chụp bằng điện thoại — nông dân chỉ cần một cú chụp.
• Bán lẻ: camera AI đếm người, phân tích hành vi mua sắm, theo dõi tồn kho trên kệ theo thời gian thực.
• An ninh: nhận diện khuôn mặt, phát hiện vật đáng ngờ trong video giám sát — luôn cần cân nhắc đạo đức và quyền riêng tư.
• Sản xuất: phát hiện khuyết tật trên dây chuyền ở tốc độ hàng trăm sản phẩm/phút, thay thế kiểm tra thủ công.
• Thiên văn: phân loại thiên hà, tìm hành tinh ngoài hệ mặt trời từ dữ liệu quang phổ và ảnh kính thiên văn.

Các pitfall hay gặp

• Không chuẩn hóa input: quên normalize về [0,1] hoặc mean/std của ImageNet → mạng hội tụ chậm hoặc phân kỳ. Mỗi backbone pretrained có một bộ mean/std riêng, hãy đọc kỹ tài liệu.
• Padding sai: quên padding trong mạng sâu làm kích thước giảm quá nhanh, không còn không gian cho Conv cuối. Nguyên tắc: với kernel K lẻ, padding = ⌊K/2⌋ giữ nguyên kích thước.
• Data leakage: augmentation trên test set, hoặc resize ảnh trước khi chia train/val. Kiểm tra chặt pipeline: chỉ fit thống kê trên train, áp dụng lên val/test.
• Quên BatchNorm:mạng sâu không có BN/LN thường không train được — gradient quá bất ổn. Với batch size nhỏ (< 8), cân nhắc Group Norm hoặc Layer Norm thay BN.
• FC layer khổng lồ: flatten feature map lớn rồi nối FC 1024 là nguyên nhân số một khiến mạng phình tham số. Ưu tiên Global Average Pooling — giảm tham số và thường tăng accuracy.
• Đánh giá chỉ bằng accuracy:bỏ qua precision/recall/F1 trên class mất cân bằng. Với tập 95% âm/5% dương, baseline "luôn đoán âm" đã 95% accuracy nhưng vô dụng.
• Kernel size lớn ở lớp đầu: các model hiện đại thích nhiều Conv 3×3 xếp chồng hơn một Conv 7×7 đơn lẻ — cùng receptive field nhưng ít tham số và nhiều phi tuyến hơn.
• Train quá ít epoch: CNN cần hàng chục epoch để hội tụ; learning rate schedule (cosine, warmup) tạo khác biệt lớn.

Các thuật ngữ liên quan cần nắm

• Feature map: output 2D của một kernel sau khi tích chập toàn ảnh — mỗi kênh output = 1 feature map.
• Channel (kênh): chiều sâu của tensor. Ảnh RGB có 3 kênh; output Conv N filters có N kênh.
• Receptive field:vùng input mà một neuron "nhìn thấy". Càng sâu, receptive field càng lớn.
• Global Average Pooling (GAP): lấy trung bình mỗi feature map thành 1 số; thay thế Flatten+FC, cực gọn.
• Dilated/Atrous Conv: Conv có lỗ — tăng receptive field mà không giảm kích thước, dùng nhiều trong segmentation.
• Depthwise separable Conv: tách Conv thành depthwise + pointwise — giảm tham số mạnh, nền tảng của MobileNet.

CNN chuyên cho ảnh; với dữ liệu tuần tự như văn bản hoặc chuỗi thời gian, hãy xem RNN, LSTM và Transformer. Với ảnh, lựa chọn hiện đại cạnh tranh là Vision Transformer.