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?
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. Input
Ảnh 28×28 của chữ số 7.
Kernel làm gì với ảnh
| Kernel 3×3 | Hiệu ứng thường gặp |
|---|---|
| Tổng trọng số > 0 | Thường làm sáng vùng ảnh |
| Tổng trọng số < 0 | Thường phát hiện cạnh |
| Cạnh ngang | Là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.
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.
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 MNISTTrí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)