ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Kiến trúc

AI Builder

Mạng nơ-ron tích chập

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kiến trúc chuyên xử lý ảnh bằng các bộ lọc tích chập trượt qua dữ liệu.

lesson90 minKiến trúcAI Engineer

Giới thiệu

Ảnh 224×224 có ~150.000 pixel. Nếu mỗi pixel kết nối với mọi neuron (fully-connected), lớp đầu tiên cần hàng tỷ tham số. Có cách nào thông minh hơn không?

Để giảm số tham số khi xử lý ảnh lớn, cách nào hợp lý nhất?

Hãy tưởng tượng bạn đang ở quán phở. Từ xa nhìn vào, bạn chỉ thấy hình dạng tổng thể — bàn, ghế, người đứng người ngồi. Tiến lại gần hơn, bạn nhận ra chi tiết: tô phở bốc khói, bó đũa để nghiêng, lọ tương ớt. Sát tận nơi, bạn nhìn rõ kết cấu: sợi phở mềm, lá hành xanh, miếng bò tái hồng. Não bạn đang “nhìn theo tầng” — từ thô đến tinh.

CNN (Convolutional Neural Network) cũng nhìn ảnh theo cách đó. Nó có hàng chục lớp xếp chồng, mỗi lớp dùng các bộ lọc (kernel) nhỏ quét qua ảnh để phát hiện đặc trưng. Lớp đầu bắt cạnh, lớp giữa bắt hình dạng, lớp sâu bắt vật thể hoàn chỉnh. Ý tưởng kinh điển này lấy cảm hứng từ cách vỏ não thị giác của động vật có vú xử lý ánh sáng.

Bí quyết quan trọng nhất: chia sẻ trọng số. Cùng một bộ lọc 3×3 được dùng ở mọi vị trí trên ảnh. Nhờ vậy, nếu mạng học được “cách nhận ra cạnh dọc” ở góc trái, nó cũng nhận ra ở góc phải — không cần học lại. Tính bất biến dịch chuyển này làm CNN hiệu quả hơn fully-connected hàng nghìn lần.

Pipeline CNN mini cho chữ số 7

Một chữ số 7 dạng 28×28 đi qua pipeline: Conv1 → ReLU → Pool → Conv2 → ReLU → Pool → Dense → Softmax.

Các bước của pipeline

1 / 5
  1. 1. Input

    Ảnh 28×28 của chữ số 7.

Kernel làm gì với ảnh

Kernel 3×3Hiệu ứng thường gặp
Tổng trọng số > 0Thường làm sáng vùng ảnh
Tổng trọng số < 0Thường phát hiện cạnh
Cạnh ngangLàm nổi nét nằm ngang
Cạnh dọc, ví dụ [[−1,0,1],[−1,0,1],[−1,0,1]]Làm nổi nét dọc — bạn vừa tự chế một “edge detector dọc” thủ công

CNN không học bằng cách ai đó viết tay các kernel này. Hàng triệu kernel khởi tạo ngẫu nhiên được tinh chỉnh qua backprop để tối đa hóa độ chính xác phân loại.

CNN không phải một bộ lọc đơn lẻ — nó là hàng chục lớp xếp chồng, mỗi lớp phát hiện đặc trưng phức tạp hơn lớp trước. Cạnh → hình dạng → vật thể hoàn chỉnh.

Giống cách bạn xếp LEGO: viên gạch đơn → khối hình → ngôi nhà hoàn chỉnh. Mỗi lớp CNN xây trên nền của lớp trước, và phép màu là mạng tự học mọi kernel chứ không ai lập trình tay.

Ảnh 224×224×3 dùng fully-connected cần ~22,5 tỷ tham số cho lớp đầu. CNN với bộ lọc 3×3×3 và 32 filters cần bao nhiêu tham số?
Feature map 14×14 đi qua Conv 3×3 (no padding, stride 1) rồi MaxPool 2×2. Kích thước không gian sau đó là bao nhiêu?

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:

Output(i,j)=∑m∑nInput(i+m,j+n)⋅Kernel(m,n)+bias\text{Output}(i,j) = \sum_{m}\sum_{n} \text{Input}(i+m, j+n) \cdot \text{Kernel}(m,n) + \text{bias}

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

O=⌊W−K+2PS⌋+1O = \left\lfloor \frac{W - K + 2P}{S} \right\rfloor + 1

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:

params=(K×K×Cin+1)×Cout\text{params} = (K \times K \times C_{\text{in}} + 1) \times C_{\text{out}}

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.

PyTorch — CNN cho MNIST 28×28

PyTorch — CNN cho MNIST 28×28

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

Trích xuất feature map để debug

PyTorch — Trích xuất feature map để debug

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)

Chi tiết: Receptive field và tại sao cần stack nhiều lớp

Receptive field của một neuron là vùng input ban đầu mà nó “nhìn thấy”. Với Conv 3×3 stride 1, receptive field tăng tuyến tính: lớp 1 = 3, lớp 2 = 5, lớp 3 = 7… Nhưng nếu xen kẽ Pool 2×2, nó tăng theo cấp số nhân. Công thức truy hồi:

rℓ=rℓ−1+(kℓ−1)⋅∏i<ℓsir_{\ell} = r_{\ell-1} + (k_\ell - 1) \cdot \prod_{i<\ell} s_i

Đây là lý do VGG/ResNet có chục lớp trở lên — để một neuron ở tầng sâu cuối mạng đủ receptive field phủ toàn ảnh 224×224 và bắt được ngữ cảnh toàn cục của vật thể. Kiến trúc hiện đại như Vision Transformer bỏ qua kỹ thuật này bằng attention toàn cục ngay từ lớp đầu.

Chi tiết: Backprop qua Conv layer (tóm tắt)

Tích chập là phép toán tuyến tính, nên backprop chỉ là chuỗi quy tắc dây chuyền. Gradient của loss theo kernel:

∂L∂K(m,n)=∑i,j∂L∂Output(i,j)⋅Input(i+m,j+n)\frac{\partial L}{\partial K(m,n)} = \sum_{i,j} \frac{\partial L}{\partial \text{Output}(i,j)} \cdot \text{Input}(i+m, j+n)

Nói cách khác, gradient của kernel = tích chập của gradient output với input. Gradient theo input lại là tích chập với kernel “lật ngược” (transposed convolution). Chi tiết đầy đủ ở backpropagation và giải tích cho backprop.

Ứ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.

Ghi nhớ về CNN

  • CNN dùng bộ lọc nhỏ trượt qua ảnh thay vì kết nối đầy đủ — giảm tham số hàng nghìn lần.
  • Chia sẻ trọng số tạo tính bất biến dịch chuyển — vật thể ở đâu trong ảnh cũng được nhận ra.
  • Phân cấp đặc trưng: cạnh → hình dạng → vật thể — mỗi lớp xây trên nền lớp trước.
  • Kiến trúc điển hình: Conv → ReLU → Pool → ... → Flatten/GAP → FC → Softmax. Stride và padding kiểm soát kích thước.
  • Thuộc lòng công thức kích thước: O = ⌊(W − K + 2P)/S⌋ + 1 và số params: (K·K·C_in + 1)·C_out.
  • Từ LeNet đến ConvNeXt, CNN là nền tảng của thị giác máy tính — và vẫn cạnh tranh hiệu quả với Vision Transformer hiện đại.

Continue the module

Lesson 1 of 12