CHƯƠNG 43 Nhận dạng & học sâu

Mạng nơ-ron tích chập (CNN) từ bên trong

CNN thay các đặc trưng thiết kế tay (SIFT, HOG, túi từ) bằng một chuỗi tầng tích chập – phi tuyến – gộp học trực tiếp từ dữ liệu. Hiểu từng tầng làm gì giúp ta đọc được kiến trúc từ AlexNet tới ResNet và dùng lại chúng cho phân đoạn, so khớp, định vị.

Nhận dạng & học sâu Nâng cao 25 phút đọc bài thử tương tác
Ảnh minh hoạ cho Mạng nơ-ron tích chập (CNN) từ bên trong 43 / 46
CNN · Backpropagation Một khung hình, một câu hỏi.
01 Trực giác

Chuyện gì đang xảy ra?

Một nơ-ron nhân tạo làm việc rất đơn giản: nhân đầu vào với trọng số, cộng lại, thêm độ lệch rồi đi qua một hàm phi tuyến. Perceptron một tầng chỉ vẽ được ranh giới tuyến tính; xếp nhiều tầng với phi tuyến ở giữa (mạng nhiều lớp, MLP) thì xấp xỉ được hàm phức tạp tuỳ ý. Mạng học bằng lan truyền ngược (backpropagation): tính mất mát ở đầu ra, dùng quy tắc chuỗi để biết mỗi trọng số góp bao nhiêu vào sai số, rồi chỉnh ngược hướng gradient (SGD).

Nối thẳng mọi điểm ảnh vào một tầng kết nối đầy đủ thì quá nhiều tham số và không tận dụng cấu trúc ảnh. Tầng tích chập sửa hai điều: mỗi nơ-ron chỉ nhìn một vùng nhỏ (trường tiếp nhận cục bộ), và cùng một bộ lọc được dùng ở mọi vị trí (chia sẻ trọng số). Kết quả: ít tham số hơn hàng bậc, và vật dịch chỗ thì bản đồ đặc trưng dịch theo (đồng biến tịnh tiến). Đây chính là phép lọc ảnh bạn đã biết — chỉ khác là nhân bộ lọc được học thay vì tự chọn.

Sau tích chập là ReLU max(0, x): rẻ, không bão hoà ở phía dương nên gradient không tắt dần như sigmoid. Max-pooling lấy giá trị lớn nhất trong ô 2×2, giảm độ phân giải một nửa và cho chút bất biến với xê dịch nhỏ. Lặp tích chập → ReLU → pooling, tầng đầu học các bộ lọc giống biên và Gabor, tầng giữa ghép thành góc, vân, bộ phận, tầng sâu phản ứng với cả khuôn mặt hay bánh xe. Thật ra SIFT, HOG và kim tự tháp không gian đã ngầm có cùng công thức “lọc – phi tuyến – gộp”; CNN chỉ học hết mọi thứ đầu–cuối.

Lịch sử kiến trúc là câu chuyện đi sâu hơn. AlexNet (2012) thắng ImageNet nhờ GPU, ReLU, dropout (tắt ngẫu nhiên nơ-ron khi huấn luyện để chống quá khớp) và tăng cường dữ liệu (cắt, lật, đổi màu). VGG chỉ dùng tích chập 3×3 xếp chồng; GoogLeNet dùng khối Inception chạy song song nhiều cỡ lọc với rất ít tham số. Mạng sâu hơn nữa lại khó huấn luyện — ResNet (2015) thêm kết nối tắt để mỗi khối chỉ học phần dư, nhờ đó huấn luyện được hàng trăm tầng.

Mạng phân loại cũng là bộ trích đặc trưng tổng quát. Đổi các tầng kết nối đầy đủ thành tích chập 1×1, ta có mạng tích chập toàn phần (FCN) nhận ảnh cỡ bất kỳ và dự đoán nhãn cho từng điểm ảnh — phân đoạn ngữ nghĩa. Hai nhánh chung trọng số (mạng Siamese) học một không gian nhúng mà ảnh giống nhau nằm gần: dùng xác minh khuôn mặt hoặc khớp ảnh mặt đất với ảnh vệ tinh để định vị địa lý. Các bộ dữ liệu lớn có nhãn chi tiết như COCO (80 lớp vật, mặt nạ cho từng thực thể) đẩy CNN sang phát hiện, phân đoạn thực thể và ước lượng tư thế người.

Thuật toán không “hiểu” ảnh. Nó chỉ tìm một cách biến đổi có thể kiểm tra được.

02 Công thức

Viết lại bằng toán.

Không cần thuộc lòng. Hãy đọc công thức như một câu mô tả: đại lượng nào được cộng, cái gì bị chuẩn hoá, và điều kiện nào khiến nó thất bại.

CÔNG THỨC / 01

Tầng tích chập nhiều kênh

\[ y_k(i,j) = b_k + \sum_{c=1}^{C}\sum_{u=0}^{F-1}\sum_{v=0}^{F-1} w_{k,c}(u,v)\, x_c(i\,S+u,\ j\,S+v) \]
  • x_c: kênh đầu vào thứ c (C kênh)
  • w_k: bộ lọc thứ k cỡ C × F × F, dùng chung mọi vị trí
  • S: bước (stride); y_k: bản đồ đặc trưng thứ k

Các thư viện học sâu thực ra tính tương quan chéo (không lật nhân); với nhân được học, khác biệt này không quan trọng.

CÔNG THỨC / 02

Cỡ đầu ra và số tham số

\[ W_{out} = \left\lfloor \frac{W_{in} - F + 2P}{S} \right\rfloor + 1, \qquad \#\theta = K\,(C F^2 + 1) \]
  • P: số pixel đệm (padding) mỗi phía
  • K: số bộ lọc của tầng
  • +1: độ lệch b_k

Ví dụ 64 bộ lọc 3×3 trên ảnh RGB chỉ có 64·(3·9+1) = 1792 tham số, bất kể ảnh to cỡ nào.

CÔNG THỨC / 03

Softmax, cross-entropy và bước SGD

\[ p_k = \frac{e^{z_k}}{\sum_{j} e^{z_j}}, \qquad \mathcal{L} = -\log p_{y}, \qquad \theta \leftarrow \theta - \eta\, \frac{\partial \mathcal{L}}{\partial \theta} \]
  • z: điểm số thô (logit) của các lớp
  • y: lớp đúng
  • η: tốc độ học; gradient tính bằng lan truyền ngược

Quy tắc chuỗi: ∂L/∂w của một tầng = (∂L/∂đầu ra tầng đó) × (∂đầu ra/∂w); với tích chập, gradient theo w lại là một phép tương quan giữa đầu vào và gradient đầu ra.

CÔNG THỨC / 04

Khối phần dư (ResNet)

\[ \mathbf{y} = \mathcal{F}(\mathbf{x};\{W_i\}) + \mathbf{x} \]
  • F: hai–ba tầng tích chập + chuẩn hoá + ReLU
  • x: đầu vào đi tắt, cộng thẳng vào đầu ra

Nếu ánh xạ tốt nhất gần đồng nhất, mạng chỉ cần đẩy F về 0; gradient cũng chảy thẳng qua đường tắt về các tầng đầu.

03 Từng bước

Luồng xử lý bằng lời.

  1. 01

    Chuẩn bị dữ liệu

    Chuẩn hoá ảnh (trừ trung bình, chia độ lệch chuẩn từng kênh), chia train / validation, bật tăng cường: cắt ngẫu nhiên, lật ngang, đổi sáng.

  2. 02

    Tầng tích chập 1

    Một ngân hàng K bộ lọc nhỏ (3×3…11×11) quét ảnh, cho K bản đồ đặc trưng; ở mạng đã học, chúng giống bộ dò biên và Gabor nhiều hướng.

  3. 03

    Phi tuyến + gộp

    ReLU giữ phản ứng dương, max-pool 2×2 giảm một nửa độ phân giải; trường tiếp nhận của tầng sau vì thế rộng gấp đôi.

  4. 04

    Xếp chồng tầng sâu

    Tầng 2 trở đi tích chập trên tất cả bản đồ của tầng trước, ghép đặc trưng đơn giản thành phức tạp; cuối mạng gộp toàn cục rồi tầng tuyến tính + softmax ra xác suất lớp.

  5. 05

    Huấn luyện và kiểm

    Lan truyền ngược + SGD/Adam theo minibatch, dropout / weight decay chống quá khớp, theo dõi độ chính xác validation; trực quan hoá bộ lọc và vùng kích hoạt để kiểm mạng học đúng thứ.

04 Tham số

Núm vặn và cạm bẫy.

Tham sốÝ nghĩaKhoảng
filtersNgân hàng bộ lọc tầng 1 dựng tay: 4 bộ lọc Sobel theo 4 hướng, 8 bộ lọc Gabor 8 hướng, hoặc bộ lọc ngẫu nhiên — giống mạng chưa huấn luyện.edges / gabor / random
layersSố tầng tích chập. Tầng 2 tích chập lại trên các bản đồ của tầng 1, phản ứng với tổ hợp hướng như góc và giao điểm.1…2
reluBật hàm ReLU max(0, x) sau mỗi tầng tích chập; tắt để thấy bản đồ có cả giá trị âm, và hai tầng tuyến tính liên tiếp chỉ tương đương một tầng.bật / tắt
poolBật max-pooling 2×2 sau mỗi tầng: bản đồ nhỏ đi một nửa mỗi chiều, giữ phản ứng mạnh nhất trong mỗi ô.bật / tắt

! Cạm bẫy thường gặp

  • Bỏ hàm phi tuyến: chồng bao nhiêu tầng tích chập tuyến tính cũng chỉ bằng một tầng tuyến tính.
  • Quên chuẩn hoá đầu vào hoặc tốc độ học quá lớn: mất mát dao động hoặc thành NaN; hãy thử giảm η 10 lần trước khi nghi kiến trúc.
  • Đánh giá trên tập đã dùng để chọn siêu tham số — độ chính xác báo cáo bị thổi phồng; giữ riêng tập test.
  • Dữ liệu ít mà huấn luyện từ đầu mạng lớn dễ quá khớp; dùng mạng đã huấn luyện trước trên ImageNet rồi tinh chỉnh (fine-tune).
  • Tăng cường sai ngữ cảnh: lật ngang chữ viết hay biển báo rẽ trái/phải làm đổi nghĩa nhãn.
  • Nhầm thứ tự kênh và dải giá trị: OpenCV cho BGR 0…255, mạng đã huấn luyện thường chờ RGB đã chuẩn hoá theo trung bình / độ lệch của ImageNet.
05 Mã nguồn

Mã nguồn tối giản, không phải giả mã.

MÃ THAM KHẢO / cnn
import cv2
import numpy as np

# ===== Phần 1: một CNN hai tầng dựng tay bằng NumPy/OpenCV (không cần huấn luyện) =====
img = cv2.imread("astronaut.jpg", cv2.IMREAD_GRAYSCALE)
if img is None:
    raise FileNotFoundError("astronaut.jpg")
x = cv2.resize(img, (256, 256)).astype(np.float32) / 255.0


def gabor_bank(n=8, ksize=11):
    return [cv2.getGaborKernel((ksize, ksize), 3.0, np.pi * i / n, 6.0, 0.5, 0) for i in range(n)]


def conv_layer(maps, bank):
    # maps: (C, H, W); mỗi bộ lọc đầu ra cộng phản ứng trên mọi kênh đầu vào
    out = []
    for k in bank:
        k = (k - k.mean()).astype(np.float32)
        out.append(sum(cv2.filter2D(m, -1, k) for m in maps))
    return np.stack(out)


def relu(t):
    return np.maximum(t, 0)


def max_pool2(t):
    C, H, W = t.shape
    t = t[:, :H // 2 * 2, :W // 2 * 2]
    return t.reshape(C, H // 2, 2, W // 2, 2).max(axis=(2, 4))


bank1 = gabor_bank(8)
f1 = max_pool2(relu(conv_layer(x[None], bank1)))            # (8, 128, 128)
rng = np.random.default_rng(0)
bank2 = [rng.normal(0, 1, (5, 5)).astype(np.float32) for _ in range(4)]
f2 = max_pool2(relu(conv_layer(f1, bank2)))                 # (4, 64, 64)
print("tầng 1:", f1.shape, " tầng 2:", f2.shape)

tiles = [cv2.normalize(m, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8) for m in f1]
cv2.imwrite("layer1_maps.jpg", np.hstack(tiles))

# ===== Phần 2 (tuỳ chọn, cần PyTorch): CNN nhỏ học được bằng lan truyền ngược =====
try:
    import torch
    import torch.nn as nn
except ImportError:
    torch = None
    print("Chưa cài PyTorch — bỏ qua phần 2.")

if torch is not None:
    class TinyCNN(nn.Module):
        def __init__(self, n_classes=10):
            super().__init__()
            self.features = nn.Sequential(
                nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),   # 32x32 -> 16x16
                nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),  # 16x16 -> 8x8
            )
            self.head = nn.Sequential(nn.Flatten(), nn.Dropout(0.5), nn.Linear(64 * 8 * 8, n_classes))

        def forward(self, inp):
            return self.head(self.features(inp))

    model = TinyCNN()
    opt = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    loss_fn = nn.CrossEntropyLoss()
    xb = torch.randn(16, 3, 32, 32)           # thay bằng minibatch ảnh thật (vd CIFAR-10)
    yb = torch.randint(0, 10, (16,))
    for step in range(5):
        opt.zero_grad()
        loss = loss_fn(model(xb), yb)
        loss.backward()                       # lan truyền ngược
        opt.step()                            # bước SGD
        print(step, loss.item())
THƯ VIỆN: OPENCV / NUMPY Đọc từ trên xuống · thử từng block
06 Thử

Điều chỉnh tham số.

Chọn ảnh mẫu hoặc tải ảnh của bạn lên, chỉnh tham số, rồi chạy. Kết quả, các bước trung gian và nhật ký được cập nhật ngay tại đây.

CỤC BỘ / KHÔNG GỬI ẢNH
BÀN THỬ / 43 Mạng nơ-ron tích chập (CNN) từ bên trong
SẴN SÀNG
KẾT QUẢ / TRỰC TIẾP —
Ảnh đầu vào mặc định
Bấm “Chạy thử” Kết quả sẽ xuất hiện ở đây.
TRẠNG THÁIChờ chạy
ĐẦU VÀO—
SỐ BƯỚC—
THỜI GIAN—
NHẬT KÝ / LUỒNG XỬ LÝ
$ bài thử chưa chạy
$ chọn ảnh và bấm “Chạy thử”
07 Ứng dụng

Dùng nó ở đâu?

DÙNG / 01

Phân loại ảnh và trích đặc trưng tổng quát cho tìm kiếm ảnh, gom nhóm, học chuyển giao.

DÙNG / 02

Phân đoạn ngữ nghĩa bằng mạng tích chập toàn phần (FCN, U-Net) trong y tế và xe tự lái.

DÙNG / 03

Xác minh khuôn mặt, định vị địa lý ảnh bằng mạng Siamese / học khoảng cách.

DÙNG / 04

Phát hiện vật thể, phân đoạn thực thể, ước lượng tư thế người trên dữ liệu kiểu COCO.

HƯỚNG HIỆN ĐẠI

Những hướng đang được dùng hiện nay.

Các phương pháp dưới đây không thay thế baseline; chúng giải quyết những điểm yếu của cách cổ điển khi có thêm dữ liệu, GPU hoặc yêu cầu độ ổn định cao hơn.

HIỆN ĐẠI / 01

Vision Transformer (ViT)

Cắt ảnh thành mảnh, xử lý như chuỗi token bằng self-attention; ít thiên kiến cục bộ hơn CNN nên cần nhiều dữ liệu / tiền huấn luyện.

Dùng khi: Mô hình nền tảng, tiền huấn luyện quy mô lớn.
HIỆN ĐẠI / 02

ConvNeXt và CNN hiện đại

CNN thuần được thiết kế lại theo các lựa chọn của transformer (nhân lớn, chuẩn hoá lớp, ít phi tuyến) và vẫn cạnh tranh.

Dùng khi: Triển khai hiệu quả trên thiết bị, ảnh độ phân giải cao.