- Hai nguyên lý cốt lõi: Vùng thụ cảm cục bộ (Local Receptive Fields) và Chia sẻ trọng số (Weight Sharing) giúp giảm hàng triệu tham số so với MLP.
- Phép toán Tích chập 2D: Trượt bộ lọc Filter qua không gian ảnh để phát hiện các đặc trưng từ cấp thấp (cạnh viền, góc) đến cấp cao (bộ phận, khuôn mặt).
- Stride và Padding: Kiểm soát độ phân giải không gian của Feature Map đầu ra, duy trì kích thước hoặc giảm chiều mẫu hình học.
- Tầng Pooling: Max Pooling và Average Pooling nén giảm kích thước không gian, tạo tính bất biến trước các dịch chuyển tịnh tiến nhỏ (Translation Invariance).
Trước khi Mạng nơ-ron tích chập (Convolutional Neural Network - CNN) ra đời, bài toán nhận diện hình ảnh bằng máy tính là một cơn ác mộng kỹ thuật. Nếu sử dụng mạng nơ-ron truyền thẳng (MLP) thông thường, một bức ảnh màu có độ phân giải khiêm tốn \(1000 \times 1000\) pixel sẽ tạo ra \(3\) triệu điểm dữ liệu đầu vào. Chỉ cần kết nối với một tầng ẩn chứa \(1.000\) nơ-ron, mô hình đã cần tới 3 tỷ tham số trọng số, làm nổ tung bộ nhớ máy tính và rơi vào bẫy overfitting nghiêm trọng. Kiến trúc CNN đã giải quyết bài toán này một cách xuất sắc bằng cách mô phỏng vùng vỏ não thị giác (Visual Cortex) thông qua hai nguyên lý kỳ diệu: Vùng thụ cảm cục bộ (Local Receptive Fields) và Chia sẻ trọng số (Weight Sharing).
1. Trụ cột 1: Phép toán Tích chập 2D (Convolution Operation)
Trong mạng CNN, phép “tích chập” 2 chiều (đúng ra là tương quan chéo, cross-correlation, như tài liệu Conv2d của PyTorch ghi; tích chập trong xử lý tín hiệu còn lật ngược bộ lọc) là quá trình trượt một ma trận trọng số nhỏ gọi là Bộ lọc (Kernel hay Filter) qua từng vùng cục bộ của bức ảnh để tạo ra một bản đồ đặc trưng mới (Feature Map):
Giả sử bức ảnh đầu vào là \(\mathbf{X}\) và bộ lọc \(\mathbf{K}\) có kích thước \(k_H \times k_W\). Giá trị tại tọa độ \((i, j)\) của Feature Map đầu ra được tính bằng tổng tích từng phần tử (Frobenius Inner Product): \[\mathbf{C}(i, j) = (\mathbf{X} * \mathbf{K})(i, j) = \sum_{m=0}^{k_H-1} \sum_{n=0}^{k_W-1} \mathbf{X}(i + m, j + n) \cdot \mathbf{K}(m, n)\]
Sức mạnh của Cơ chế Chia sẻ Trọng số (Weight Sharing)
Trong mạng MLP, mỗi kết nối giữa 2 nơ-ron sở hữu một trọng số độc lập. Nhưng trong CNN, cùng một bộ lọc \(3 \times 3\) duy nhất (chỉ gồm 9 trọng số) sẽ được tái sử dụng để quét qua mọi vị trí trên toàn bộ bức ảnh!
- Giảm tham số hàng triệu lần: Thay vì hàng tỷ tham số, lớp tích chập chỉ cần vài nghìn trọng số.
- Tính đẳng biến với phép tịnh tiến (Translation Equivariance): Nếu một bộ lọc được học để nhận diện "mép cạnh dọc" hay "con mắt", thì dù con mắt xuất hiện ở góc trên bên trái hay chính giữa bức ảnh, bộ lọc đó vẫn phát hiện và phát tín hiệu kích hoạt rực sáng tại đúng vị trí đó!
2. Hai Siêu tham số kiểm soát không gian: Stride và Padding
Khi thực hiện phép tích chập, kích thước không gian của Feature Map đầu ra được chi phối bởi hai siêu tham số:
1. Bước nhảy (Stride - \(S\))
Stride quy định số lượng pixel mà bộ lọc dịch chuyển sau mỗi lần tính tích vô hướng:
- Mặc định \(S = 1\): Bộ lọc trượt từng pixel một sang phải và xuống dưới.
- Khi \(S = 2\): Bộ lọc nhảy cóc 2 pixel một lần, giúp giảm kích thước không gian đầu ra xuống một nửa, đóng vai trò như một cơ chế nén thông tin.
2. Phần đệm (Padding - \(P\))
Khi trượt qua ảnh, các pixel ở góc và mép rìa chỉ được tham gia vào rất ít phép tính so với các pixel ở trung tâm, dẫn đến hiện tượng mất mát thông tin biên giới và kích thước Feature Map bị co nhỏ lại sau mỗi lớp tích chập. Để khắc phục, kỹ sư bọc thêm các viền số 0 (Zero-Padding) quanh bức ảnh:
- Valid Padding (\(P = 0\)): Không đệm thêm gì, kích thước đầu ra sẽ bị thu nhỏ.
- Same Padding: Tính toán lượng đệm \(P = \frac{K - 1}{2}\) sao cho kích thước Feature Map đầu ra giữ nguyên bằng đúng kích thước ảnh đầu vào (khi \(S = 1\)).
Công thức vàng tính kích thước Feature Map đầu ra:
Cho ảnh kích thước \(H \times W\), bộ lọc \(K \times K\), đệm \(P\) và bước nhảy \(S\): \[H_{\text{out}} = \left\lfloor \frac{H - K + 2P}{S} \right\rfloor + 1, \quad W_{\text{out}} = \left\lfloor \frac{W - K + 2P}{S} \right\rfloor + 1\]
3. Trụ cột 2: Lớp giảm kích thước Pooling (Max Pooling)
Sau lớp tích chập và hàm kích hoạt phi tuyến ReLU, mô hình thường được kết hợp với một lớp Pooling (Gộp không gian), phổ biến nhất là Max Pooling: Cửa sổ trượt kích thước \(2 \times 2\) với bước nhảy \(S = 2\) quét qua Feature Map và chỉ giữ lại giá trị lớn nhất trong mỗi ô 4 phần tử: \[\mathbf{P}(i, j) = \max \left( \mathbf{C}(2i, 2j), \mathbf{C}(2i+1, 2j), \mathbf{C}(2i, 2j+1), \mathbf{C}(2i+1, 2j+1) \right)\]
Lợi ích sống còn của Max Pooling:
- Giảm 75% lượng dữ liệu: Thu nhỏ diện tích xuống 4 lần, tiết kiệm mạnh mẽ tài nguyên tính toán và bộ nhớ GPU cho các tầng sâu phía sau.
- Tạo tính bất biến tịnh tiến cục bộ (Local Translation Invariance): Nếu một đặc trưng quan trọng dịch chuyển nhẹ 1-2 pixel, giá trị cực đại trong cửa sổ \(2 \times 2\) vẫn không đổi, giúp mô hình nhận diện vật thể vững vàng trước các rung lắc góc chụp.
- Mở rộng vùng thụ cảm (Receptive Field): Giúp các nơ-ron ở tầng sau nhìn bao quát được các vùng không gian lớn hơn của bức ảnh gốc.
4. Quá trình Học Biểu diễn Phân cấp (Hierarchical Feature Learning)
Điều làm cho CNN trở thành biểu tượng của AI chính là khả năng tự động học trích xuất đặc trưng từ cụ thể đến trừu tượng theo từng tầng kiến trúc:
- Tầng 1 (Low-level features): Các bộ lọc tự học nhận diện các cạnh biên (Edges), đường kẻ ngang dọc, góc nhọn và sự chuyển biến màu sắc cơ bản.
- Tầng 2-3 (Mid-level features): Kết hợp các cạnh biên thành kết cấu bề mặt (Textures), hoa văn, hình tròn, mắt lưới.
- Tầng 4 trở lên (High-level features): Tổng hợp các kết cấu thành các bộ phận hoàn chỉnh: mắt, mũi, bánh xe, cánh hoa.
- Tầng cuối cùng (Fully Connected Layer): Trải phẳng toàn bộ đặc trưng trừu tượng thành vector và kết hợp hàm Softmax để đưa ra kết luận xác suất: bức ảnh là "Mèo", "Chó" hay "Xe hơi".
5. Ví dụ chạy tay từng bước Convolution và Max Pooling
Xét bức ảnh đơn sắc kích thước \(6 \times 6\) và bộ lọc phát hiện cạnh dọc \(3 \times 3\):
Bức ảnh \(\mathbf{X}\) (\(6 \times 6\)): \[\begin{bmatrix} 1 & 2 & 3 & 0 & 1 & 2 \\ 0 & 1 & 4 & 2 & 3 & 0 \\ 2 & 0 & 1 & 5 & 2 & 1 \\ 3 & 2 & 0 & 1 & 4 & 3 \\ 1 & 4 & 2 & 0 & 1 & 2 \\ 0 & 2 & 3 & 1 & 0 & 4 \end{bmatrix}, \quad \text{Bộ lọc } \mathbf{K} = \begin{bmatrix} 1 & 0 & -1 \\ 1 & 0 & -1 \\ 1 & 0 & -1 \end{bmatrix}\]
Bước 1: Tính Convolution 2D (Valid, \(P=0, S=1\))
Kích thước đầu ra: \(H_{\text{out}} = 6 - 3 + 1 = 4\), \(W_{\text{out}} = 6 - 3 + 1 = 4\).
-
Tính ô đầu tiên \(\mathbf{C}(0, 0)\) (vùng góc trên trái từ hàng 0-2, cột 0-2): \[\mathbf{X}_{0:3, 0:3} = \begin{bmatrix} 1 & 2 & 3 \\ 0 & 1 & 4 \\ 2 & 0 & 1 \end{bmatrix}\] Nhân vô hướng với \(\mathbf{K}\): \[\mathbf{C}(0,0) = (1)(1) + (2)(0) + (3)(-1) + (0)(1) + (1)(0) + (4)(-1) + (2)(1) + (0)(0) + (1)(-1)\] \[= (1 - 3) + (0 - 4) + (2 - 1) = -2 - 4 + 1 = -5.0\]
-
Tính ô \(\mathbf{C}(0, 1)\) (dịch sang phải 1 cột): \[\mathbf{X}_{0:3, 1:4} = \begin{bmatrix} 2 & 3 & 0 \\ 1 & 4 & 2 \\ 0 & 1 & 5 \end{bmatrix}\] \[\mathbf{C}(0, 1) = (2 - 0) + (1 - 2) + (0 - 5) = 2 - 1 - 5 = -4.0\]
Lặp lại cho toàn bộ 16 ô để thu được Feature Map kích thước \(4 \times 4\).
Bước 2: Thực hiện 2x2 Max Pooling (Stride = 2)
Kích thước sau Pooling: \(4 / 2 = 2 \times 2\). Tính tiếp \(\mathbf{C}(1,0) = (0 - 4) + (2 - 1) + (3 - 0) = 0\) và \(\mathbf{C}(1,1) = (1 - 2) + (0 - 5) + (2 - 1) = -5\), cửa sổ góc trên cùng bên trái của Feature Map chứa 4 giá trị: \[\begin{bmatrix} \mathbf{C}(0,0) & \mathbf{C}(0,1) \\ \mathbf{C}(1,0) & \mathbf{C}(1,1) \end{bmatrix} = \begin{bmatrix} -5.0 & -4.0 \\ 0.0 & -5.0 \end{bmatrix}\] Phần tử lớn nhất trong ô là \(\max(-5.0, -4.0, 0.0, -5.0) = 0.0\). Giá trị \(0.0\) được lưu vào vị trí \((0, 0)\) của Feature Map sau nén. Làm tương tự với 3 cửa sổ còn lại, Feature Map sau nén là \(\begin{bmatrix} 0 & 4 \\ 6 & 0 \end{bmatrix}\), đúng với kết quả chạy code bên dưới.
Chủ đề này nằm trong Lecture 14 - Neural Networks của Khóa AI. Xem đề cương
6. Cài đặt Convolution 2D và Max Pooling bằng Python và C++
def conv2d_maxpool(image, kernel):
H = len(image)
W = len(image[0])
kH = len(kernel)
kW = len(kernel[0])
outH = H - kH + 1
outW = W - kW + 1
# 2D convolution
conv = [[0.0] * outW for _ in range(outH)]
for i in range(outH):
for j in range(outW):
val = 0.0
for di in range(kH):
for dj in range(kW):
val += image[i + di][j + dj] * kernel[di][dj]
conv[i][j] = val
# 2x2 Max Pooling with stride 2
poolH = outH // 2
poolW = outW // 2
pooled = [[0.0] * poolW for _ in range(poolH)]
for i in range(poolH):
for j in range(poolW):
v0 = conv[2 * i][2 * j]
v1 = conv[2 * i + 1][2 * j]
v2 = conv[2 * i][2 * j + 1]
v3 = conv[2 * i + 1][2 * j + 1]
pooled[i][j] = max(v0, v1, v2, v3)
flat = []
for r in pooled:
for v in r:
flat.append(round(v, 4))
return flat
def solve(case):
image, kernel = case
return conv2d_maxpool(image, kernel)
#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <algorithm>
std::vector<double> conv2d_maxpool(const std::vector<std::vector<double>>& image,
const std::vector<std::vector<double>>& kernel) {
int H = image.size();
int W = image[0].size();
int kH = kernel.size();
int kW = kernel[0].size();
int outH = H - kH + 1;
int outW = W - kW + 1;
std::vector<std::vector<double>> conv(outH, std::vector<double>(outW, 0.0));
for (int i = 0; i < outH; ++i) {
for (int j = 0; j < outW; ++j) {
double val = 0.0;
for (int di = 0; di < kH; ++di) {
for (int dj = 0; dj < kW; ++dj) {
val += image[i + di][j + dj] * kernel[di][dj];
}
}
conv[i][j] = val;
}
}
int poolH = outH / 2;
int poolW = outW / 2;
std::vector<double> flat;
for (int i = 0; i < poolH; ++i) {
for (int j = 0; j < poolW; ++j) {
double v0 = conv[2 * i][2 * j];
double v1 = conv[2 * i + 1][2 * j];
double v2 = conv[2 * i][2 * j + 1];
double v3 = conv[2 * i + 1][2 * j + 1];
double m = std::max({v0, v1, v2, v3});
flat.push_back(std::round(m * 10000.0) / 10000.0);
}
}
return flat;
}
int main() {
int H, W, kH, kW;
if (!(std::cin >> H >> W >> kH >> kW)) return 0;
std::vector<std::vector<double>> img(H, std::vector<double>(W));
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) std::cin >> img[i][j];
}
std::vector<std::vector<double>> kern(kH, std::vector<double>(kW));
for (int i = 0; i < kH; ++i) {
for (int j = 0; j < kW; ++j) std::cin >> kern[i][j];
}
auto res = conv2d_maxpool(img, kern);
std::cout << std::fixed << std::setprecision(4);
for (int i = 0; i < (int)res.size(); ++i) {
if (i > 0) std::cout << " ";
std::cout << res[i];
}
std::cout << "\n";
return 0;
}
7. Các kiến trúc CNN kinh điển trong lịch sử AI
| Kiến trúc CNN | Năm ra mắt | Số tầng | Điểm đột phá công nghệ |
|---|---|---|---|
| LeNet-5 | 1998 | 5 | Kiến trúc CNN đầu tiên đọc séc ngân hàng và chữ số MNIST |
| AlexNet | 2012 | 8 | Đưa ReLU, Dropout và huấn luyện GPU song song vào Deep Learning |
| VGG-16 | 2014 | 16 | Chuẩn hóa toàn bộ bộ lọc về kích thước nhỏ \(3 \times 3\) xếp chồng liên tiếp |
| ResNet | 2015 | 152 | Kết nối tắt Residual Skip Connections giải quyết triệt để nghẽn gradient |
| ConvNeXt | 2022 | Biến thiên | Hiện đại hóa CNN cạnh tranh sòng phẳng với Vision Transformer (ViT) |
8. Câu hỏi thường gặp
Tại sao hiện nay người ta luôn dùng bộ lọc nhỏ 3x3 thay vì 7x7 hay 11x11?
Theo nghiên cứu của nhóm VGG (Đại học Oxford), việc xếp chồng hai lớp \(3 \times 3\) liên tiếp có cùng vùng thụ cảm hiệu quả tương đương với một lớp \(5 \times 5\), nhưng số lượng tham số chỉ là \(2 \times (3 \times 3) = 18\) thay vì \(5 \times 5 = 25\) (tiết kiệm \(28\%\) tham số). Quan trọng hơn, việc đi qua hai lớp \(3 \times 3\) cho phép chèn thêm hai hàm kích hoạt phi tuyến ReLU thay vì một, giúp mô hình học được các hàm toán học phức tạp hơn nhiều.
CNN có dùng được cho dữ liệu văn bản hoặc âm thanh không?
Hoàn toàn có thể. Với âm thanh, ta chuyển sóng âm thành phổ âm thanh hình ảnh (Spectrogram) và áp dụng CNN 2D. Với văn bản, 1D-CNN (Tích chập 1 chiều) trượt kernel dọc theo chuỗi các từ trong câu để trích xuất các cụm n-gram đặc trưng với tốc độ xử lý nhanh hơn mạng LSTM hàng chục lần.
9. Các Biến thể Phép Tích chập Tiên tiến trong Thị giác Máy tính
Để đáp ứng nhu cầu ngày càng khắt khe về độ chính xác và tốc độ xử lý thời gian thực trên các thiết bị di động, cộng đồng nghiên cứu học sâu đã phát triển nhiều biến thể tích chập tiên tiến:
Thứ nhất là Phép tích chập Giãn nở Dilated Convolution (còn gọi là Atrous Convolution). Trong các bài toán phân đoạn ảnh ngữ nghĩa (Semantic Segmentation), mô hình cần mở rộng vùng thụ cảm (Receptive Field) để nắm bắt bối cảnh toàn cục của bức ảnh mà không làm giảm độ phân giải không gian của bản đồ đặc trưng. Thay vì dùng các lớp Pooling làm mất chi tiết điểm ảnh, Dilated Convolution chèn các khoảng trống có kích số bước giãn nở (Dilation Rate) vào giữa các trọng số của bộ lọc. Nhờ đó, một bộ lọc kích thước nhỏ có thể bao quát một vùng không gian rộng lớn mà không làm tăng thêm bất kỳ một tham số trọng số nào.
Thứ hai là Phép tích chập Tách rời theo Chiều sâu Depthwise Separable Convolution. Đây là bí quyết công nghệ cốt lõi giúp kiến trúc MobileNet của Google đạt hiệu năng thị giác vượt trội trên điện thoại thông minh. Thay vì thực hiện phép tích chập 3D thông thường vừa quét không gian vừa kết hợp các kênh màu cùng lúc, phương pháp này chia nhỏ thành hai bước riêng biệt: bước thứ nhất Depthwise Convolution áp dụng một bộ lọc 2D độc lập cho từng kênh màu riêng lẻ để trích xuất đặc trưng không gian; bước thứ hai Pointwise Convolution sử dụng các bộ lọc 1 nhân 1 để kết hợp tuyến tính thông tin giữa các kênh. Phép tách rời này giúp giảm khối lượng tính toán và số lượng tham số từ 8 đến 9 lần mà độ chính xác gần như không suy giảm.
Thứ ba là Phép tích chập Chuyển vị Transposed Convolution (thường bị gọi nhầm là Deconvolution). Trong các kiến trúc mạng tạo sinh đối nghịch GAN hoặc mạng U-Net dùng trong phân tích ảnh y tế, mô hình cần thực hiện quá trình phóng đại kích thước bản đồ đặc trưng từ độ phân giải thấp lên độ phân giải cao ban đầu. Transposed Convolution thực hiện quá trình này bằng cách ánh xạ ngược từng giá trị điểm ảnh sang một vùng không gian lớn hơn thông qua ma trận trọng số có thể tự học.
10. Cuộc Cách mạng Kiến trúc: Từ LeNet, AlexNet đến ResNet
Lịch sử phát triển của mạng nơ-ron tích chập CNN là một biên niên sử hào hùng ghi dấu sự bùng nổ của kỷ nguyên Deep Learning hiện đại:
- Năm 1998, Yann LeCun công bố kiến trúc LeNet-5 tiên phong sử dụng các lớp tích chập kết hợp lấy mẫu con để nhận diện chữ số viết tay trên các tấm séc ngân hàng.
- Năm 2012, Alex Krizhevsky và Geoffrey Hinton giới thiệu AlexNet, sử dụng GPU để huấn luyện mạng CNN 8 tầng trên tập dữ liệu ImageNet khổng lồ, nghiền nát hoàn toàn mọi phương pháp thị giác máy tính truyền thống và chính thức châm ngòi cho cuộc cách mạng AI toàn cầu.
- Năm 2014, nhóm nghiên cứu tại Đại học Oxford công bố kiến trúc VGG-16, chứng minh nguyên lý thiết kế thanh lịch: việc xếp chồng liên tiếp các bộ lọc kích thước nhỏ 3 nhân 3 hiệu quả và tiết kiệm tham số hơn nhiều so với việc dùng các bộ lọc lớn 7 nhân 7 hay 11 nhân 11.
- Năm 2015, Kaiming He tạo nên một cơn địa chấn khoa học với kiến trúc ResNet. Bằng việc giới thiệu Kết nối Tắt (Residual Skip Connection) cho phép dòng tín hiệu truyền tắt qua các tầng mạng, ResNet đã đập tan rào cản suy biến gradient, cho phép huấn luyện thành công các mạng nơ-ron sâu tới 152 tầng và thậm chí 1.000 tầng, vượt qua cả độ chính xác nhận diện hình ảnh của mắt người thật.
Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.


