- Thị giác Máy tính (Computer Vision - CV): Lĩnh vực AI nghiên cứu cách trao cho máy tính khả năng "nhìn" và trích xuất tri thức từ hình ảnh số và video tương tự hệ thị giác của con người.
- Ba bài toán thị giác nền tảng: Phân loại ảnh (Image Classification), Phát hiện vật thể (Object Detection) và Phân vùng ảnh (Semantic / Instance Segmentation).
- Thư viện OpenCV tiêu chuẩn: Nền tảng xử lý ảnh cổ điển số 1 thế giới, quản lý dữ liệu pixel dưới dạng ma trận đa chiều, chuyển đổi không gian màu BGR sang RGB và lọc nhiễu.
- Cuộc cách mạng của YOLO (You Only Look Once): Kiến trúc phát hiện vật thể một giai đoạn (Single-shot Detector) tái định nghĩa bài toán phát hiện vật thể thành bài toán hồi quy trực tiếp, đạt tốc độ từ 45 đến 155 khung hình/giây (FPS).
- Thuật toán IoU và Non-Maximum Suppression (NMS): Cơ chế bắt buộc ở bước hậu xử lý để loại bỏ các hộp bao (Bounding Boxes) trùng lặp, giữ lại duy nhất vị trí nhận diện tối ưu nhất cho từng đối tượng.
Thị giác máy tính (Computer Vision - CV) là một trong những nhánh ứng dụng sôi động và có tầm ảnh hưởng sâu rộng nhất của Trí tuệ Nhân tạo hiện đại. Từ hệ thống lái xe tự hành của Tesla nhận diện làn đường và người đi bộ trong tích tắc, hệ thống FaceID mở khóa điện thoại thông minh, đến các camera giám sát an ninh thông minh tại sân bay và robot kiểm tra khuyết tật sản phẩm trong dây chuyền công nghiệp - tất cả đều vận hành dựa trên các giải thuật thị giác máy tính.
Để làm chủ thị giác máy tính từ con số 0, lập trình viên cần nắm vững cả hai trụ cột: kỹ thuật xử lý ảnh số nền tảng với thư viện OpenCV, và kiến trúc học sâu phát hiện vật thể thời gian thực mang tính biểu tượng YOLO (You Only Look Once). Bài viết này sẽ hướng dẫn bạn toàn bộ quy trình: từ bản chất biểu diễn điểm ảnh, cách OpenCV thao tác ma trận, cơ chế chia lưới dự đoán của YOLO, đến việc tự tay cài đặt thuật toán lọc trùng lặp Non-Maximum Suppression (NMS).
1. Ba bài toán cốt lõi trong thị giác máy tính
Để xây dựng một giải pháp thị giác máy tính, bước đầu tiên là phải xác định chính xác bài toán cần giải quyết thuộc cấp độ nào trong thang đo độ phức tạp:
1. Phân loại ảnh (Image Classification)
- Mục tiêu: Trả lời câu hỏi "Bức ảnh này chứa cái gì?". Mô hình nhận vào toàn bộ bức ảnh và xuất ra một nhãn phân loại duy nhất kèm điểm xác suất tin cậy (ví dụ: ảnh con chó, ảnh con mèo, ảnh biển báo giao thông).
- Đặc điểm: Giả định bức ảnh chỉ có một đối tượng chính chiếm ưu thế. Không cung cấp thông tin về vị trí hay kích thước của đối tượng trong khung hình.
- Mô hình kinh điển: ResNet, EfficientNet, Vision Transformer (ViT).
2. Phát hiện vật thể (Object Detection)
- Mục tiêu: Trả lời câu hỏi "Có những vật thể gì trong ảnh và chúng nằm ở vị trí nào?".
- Đặc điểm: Mô hình phải đồng thời thực hiện hai nhiệm vụ: định vị (Localization) bằng cách vẽ các khung chữ nhật bao quanh vật thể (Bounding Box) gồm 4 tham số tọa độ \([x_1, y_1, x_2, y_2]\) (hoặc \([x_{\text{center}}, y_{\text{center}}, w, h]\)), và phân loại (Classification) nhãn của vật thể nằm trong từng khung đó.
- Mô hình kinh điển: YOLO, SSD, Faster R-CNN.
3. Phân vùng ảnh (Image Segmentation)
- Mục tiêu: Trả lời câu hỏi "Từng điểm ảnh (pixel) trong bức ảnh này thuộc về vật thể nào?".
- Phân loại:
- Semantic Segmentation (Phân vùng ngữ nghĩa): Gán nhãn cho từng pixel theo loại đối tượng (ví dụ: tất cả pixel thuộc về xe cộ tô màu đỏ, mặt đường tô màu xám). Không phân biệt giữa hai chiếc xe đậu cạnh nhau.
- Instance Segmentation (Phân vùng cá thể): Không chỉ nhận diện loại đối tượng mà còn tách biệt từng cá thể riêng lẻ (ví dụ: xe số 1 màu đỏ, xe số 2 màu xanh).
- Mô hình kinh điển: U-Net, Mask R-CNN, Segment Anything Model (SAM).
2. Tiền xử lý ảnh số với thư viện OpenCV
Trước khi đưa hình ảnh vào các mạng nơ-ron sâu, hình ảnh thực tế từ camera thường bị mờ, rung lắc, thiếu sáng hoặc có tỷ lệ khung hình không đồng nhất. OpenCV (Open Source Computer Vision Library) là bộ công cụ tối thượng bằng C++ và Python chịu trách nhiệm toàn bộ chuỗi tiền xử lý này.
Bản chất số học của ảnh số và không gian màu BGR
Trong máy tính, một bức ảnh màu kỹ thuật số được lưu trữ dưới dạng một ma trận 3 chiều (3D Tensor) kích thước \((H, W, C)\) với \(H\) là chiều cao (số hàng pixel), \(W\) là chiều rộng (số cột pixel), và \(C\) là số kênh màu (Color Channels). Mỗi phần tử trong ma trận là một số nguyên không âm 8-bit (uint8) có giá trị từ \(0\) (tối hoàn toàn) đến \(255\) (sáng tối đa).
Bẫy kinh điển về hệ màu của OpenCV:
Hầu hết các thư viện hiển thị ảnh chuẩn trên thế giới (như Matplotlib, PIL, Web Browsers) đều sắp xếp 3 kênh màu theo thứ tự chuẩn RGB (Red - Green - Blue). Tuy nhiên, do lý do lịch sử tương thích với các chip camera thời kỳ đầu, OpenCV mặc định đọc và lưu ảnh theo thứ tự BGR (Blue - Green - Red)!
Nếu bạn đọc ảnh bằng cv2.imread() rồi hiển thị trực tiếp bằng plt.imshow() của Matplotlib, khuôn mặt người sẽ bị chuyển sang màu xanh dương ma quái. Đoạn mã chuẩn để khắc phục luôn là:
import cv2
# Đọc ảnh từ đĩa (hệ BGR)
img_bgr = cv2.imread("traffic.jpg")
# Chuyển đổi sang hệ màu chuẩn RGB
img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
Các thao tác biến đổi ảnh quan trọng
- Thay đổi kích thước (Resize) và Padding: Mạng nơ-ron sâu yêu cầu kích thước tensor đầu vào cố định (ví dụ YOLO thường yêu cầu ảnh vuông \(640 \times 640\)). Nếu kéo dãn ảnh thông thường, tỷ lệ khung hình (Aspect Ratio) bị méo, khiến vật thể bị biến dạng. Kỹ thuật chuyên nghiệp là dùng Letterboxing: thu nhỏ ảnh giữ nguyên tỷ lệ và thêm các dải màu xám đệm vào hai cạnh thiếu.
- Lọc nhiễu Gaussian Blur:
Làm mịn ảnh bằng cách tính tích chập với ma trận nhân Gauss (Gaussian Kernel), loại bỏ các hạt nhiễu tần số cao của cảm biến trước khi phát hiện cạnh:
blurred = cv2.GaussianBlur(img_gray, (5, 5), sigmaX=1.5) - Phát hiện cạnh Canny (Canny Edge Detection):
Thuật toán nhiều giai đoạn trích xuất đường viền sắc nét của vật thể dựa trên gradient độ sáng:
edges = cv2.Canny(blurred, threshold1=50, threshold2=150)
3. Kiến trúc YOLO: Cuộc cách mạng phát hiện vật thể một giai đoạn
Hạn chế của các mô hình hai giai đoạn (Two-Stage Detectors)
Trước khi YOLO ra đời năm 2015, các mô hình phát hiện vật thể hàng đầu như R-CNN hay Faster R-CNN hoạt động theo cơ chế hai giai đoạn (Two-stage):
- Giai đoạn 1: Mạng đề xuất vùng (Region Proposal Network - RPN) quét qua ảnh và đưa ra hàng nghìn vùng hình chữ nhật có khả năng chứa vật thể.
- Giai đoạn 2: Cắt từng vùng đó ra, đưa qua một mạng nơ-ron tích chập khác để phân loại xem bên trong là gì và tinh chỉnh lại tọa độ khung.
Quy trình này cho độ chính xác cao nhưng tốc độ vô cùng chậm chạp (chỉ đạt 2 đến 7 khung hình/giây), hoàn toàn không thể triển khai trên xe tự hành hay camera giám sát thời gian thực.
Ý tưởng cốt lõi của YOLO (You Only Look Once)
Tác giả Joseph Redmon đã đưa ra một góc nhìn mang tính đột phá: tại sao phải đề xuất vùng rồi mới phân loại? Tại sao không coi toàn bộ bài toán phát hiện vật thể là một bài toán hồi quy (Regression Problem) duy nhất, ánh xạ trực tiếp từ các pixel của ảnh sang tọa độ hộp bao và xác suất lớp chỉ trong một lần lan truyền xuôi (Single Forward Pass)?
Nguyên lý hoạt động của mạng YOLO gốc:
- Chia lưới không gian (Grid Division): Bức ảnh đầu vào kích thước \(448 \times 448\) được chia thành một lưới gồm \(S \times S\) ô vuông bằng nhau (thường \(S = 7\) hoặc \(S = 13, 20\)).
- Gán trách nhiệm (Object Assignment): Nếu tâm (center point) của một vật thể rơi vào ô lưới nào, thì ô lưới đó chịu trách nhiệm dự đoán và phát hiện vật thể đó.
- Dự đoán đồng thời: Mỗi ô lưới dự đoán:
- \(B\) hộp bao (Bounding Boxes), mỗi hộp gồm 5 tham số: tọa độ tâm \((x, y)\), chiều rộng \(w\), chiều cao \(h\), và điểm tin cậy (Confidence Score). \[\text{Confidence} = P(\text{Object}) \times \text{IoU}_{\text{pred}}^{\text{truth}}\]
- Phân phối xác suất có điều kiện của \(C\) lớp đối tượng \(P(\text{Class}_i | \text{Object})\).
- Đầu ra hợp nhất: Mạng xuất ra một tensor kích thước duy nhất \(S \times S \times (B \times 5 + C)\). Toàn bộ quá trình tính toán diễn ra đồng thời trên GPU, đạt tốc độ từ 45 FPS đến 155 FPS, mở ra kỷ nguyên phát hiện vật thể thời gian thực cho nhân loại.
Qua các thế hệ phát triển từ YOLOv1 đến YOLOv8, YOLO11 và mới nhất là YOLO26 (ba bản sau cùng do Ultralytics phát triển), kiến trúc đã được nâng cấp với Anchor-free detection, Feature Pyramid Network (PAN-FPN), và các hàm mất mát tiên tiến như CIoU/GIoU, giúp mô hình phát hiện cực tốt cả các vật thể kích thước siêu nhỏ.
4. Độ đo IoU và Thuật toán lọc trùng lặp Non-Maximum Suppression (NMS)
Khái niệm Intersection over Union (IoU)
Trong quá trình huấn luyện và đánh giá, làm thế nào để đo lường mức độ trùng khớp giữa một hộp bao dự đoán (\(B_{\text{pred}}\)) và hộp bao chuẩn của nhãn thực tế (\(B_{\text{truth}}\))? Chúng ta sử dụng độ đo Intersection over Union (IoU), hay còn gọi là chỉ số Jaccard: \[\text{IoU} = \frac{\text{Diện tích phần giao nhau (Intersection)}}{\text{Diện tích phần hợp nhau (Union)}} = \frac{\text{Area}(B_1 \cap B_2)}{\text{Area}(B_1 \cup B_2)}\]
Trong đó: \[\text{Area}(B_1 \cup B_2) = \text{Area}(B_1) + \text{Area}(B_2) - \text{Area}(B_1 \cap B_2)\]
- Giá trị IoU luôn nằm trong đoạn \([0, 1]\).
- Nếu hai hộp không chạm nhau, \(\text{IoU} = 0\).
- Nếu hai hộp trùng khít hoàn hảo, \(\text{IoU} = 1\).
- Trong thực tế, một dự đoán thường được coi là phát hiện đúng (True Positive) nếu \(\text{IoU} \ge 0,5\) (hoặc \(\text{IoU} \ge 0,75\) trong các tiêu chuẩn đánh giá khắt khe của COCO).
Tại sao cần thuật toán Non-Maximum Suppression (NMS)?
Vì mạng YOLO chia ảnh thành hàng trăm ô lưới, và mỗi ô lưới lại dự đoán nhiều hộp bao, nên khi một vật thể lớn xuất hiện trong ảnh (ví dụ một chiếc ô tô chiếm diện tích 10 ô lưới), cả 10 ô lưới này đều nhận thấy tâm xe gần mình và cùng dự đoán ra các hộp bao bao quanh chiếc xe đó. Kết quả thô xuất ra sẽ là hàng chục hộp bao màu sắc chằng chịt đè lên cùng một chiếc ô tô.
Thuật toán Non-Maximum Suppression (NMS - Triệt tiêu cực đại cục bộ) là giải thuật hậu xử lý bắt buộc để giải quyết vấn đề này. Nguyên lý của NMS gồm 4 bước tuần tự:
- Lọc theo ngưỡng tin cậy (Confidence Thresholding): Loại bỏ ngay lập tức tất cả các hộp bao có điểm tin cậy nhỏ hơn một ngưỡng tối thiểu (ví dụ
conf_thresh = 0.25). - Sắp xếp ưu tiên (Sorting): Sắp xếp các hộp bao còn lại theo điểm số tin cậy giảm dần. Hộp có điểm cao nhất được đặt lên đầu hàng đợi.
- Lựa chọn và triệt tiêu (Select & Suppress):
- Lấy hộp có điểm cao nhất ra, đưa vào danh sách kết quả cuối cùng (
keep). - Tính toán chỉ số IoU giữa hộp này với tất cả các hộp còn lại trong danh sách.
- Nếu bất kỳ hộp nào có \(\text{IoU} \gt \text{iou\_threshold}\) (thường chọn \(0,45\) đến \(0,5\)), chứng tỏ hộp đó đang dự đoán đè lên cùng một vật thể với hộp vừa chọn. Ta lập tức loại bỏ (suppress) hộp trùng lặp đó.
- Lấy hộp có điểm cao nhất ra, đưa vào danh sách kết quả cuối cùng (
- Lặp lại: Lặp lại bước 3 với các hộp còn lại trong hàng đợi cho đến khi không còn hộp nào chưa được xét.
Kết quả cuối cùng là mỗi vật thể thực tế trong ảnh chỉ còn lại duy nhất một hộp bao có điểm số tin cậy cao nhất và vị trí căn chỉnh chuẩn xác nhất.
Chủ đề này nằm trong Lecture 14 - Neural Networks của Khóa AI. Xem đề cương
5. Bảng so sánh các kiến trúc phát hiện vật thể tiêu biểu
| Kiến trúc | Kiểu phân loại | Tốc độ (FPS trên GPU) | mAP (COCO) | Ưu điểm chính | Nhược điểm chính |
|---|---|---|---|---|---|
| Faster R-CNN | Two-stage | 5 - 15 FPS | Rất cao | Độ chính xác cao, ít bỏ sót vật thể nhỏ | Quá chậm, không phù hợp cho video thời gian thực |
| SSD (Single Shot MultiBox) | One-stage | 30 - 60 FPS | Trung bình | Tốc độ nhanh, đa tỷ lệ đặc trưng | Khả năng phát hiện vật thể nhỏ kém |
| YOLOv8 / YOLO11 | One-stage (Anchor-free) | 80 - 160 FPS | Cực cao | Tốc độ siêu nhanh, hỗ trợ cả detect và segment | Đòi hỏi dữ liệu huấn luyện lớn và đa dạng |
| DETR (DEtection TRansformer) | Transformer-based | 15 - 30 FPS | Cực cao | Bỏ hoàn toàn thuật toán NMS nhờ bipartite matching | Huấn luyện cực kỳ lâu hội tụ (500 epochs) |
6. Cài đặt thuật toán IoU và Non-Maximum Suppression (NMS)
Dưới đây là mã nguồn cài đặt độc lập đầy đủ thuật toán tính toán Intersection over Union và bộ lọc Non-Maximum Suppression (NMS) chuẩn kỹ thuật, được triển khai song song bằng Python và C++17.
#include <vector>
#include <algorithm>
#include <cmath>
struct BoundingBox {
double x1, y1, x2, y2, score;
};
inline double compute_iou(const BoundingBox& b1, const BoundingBox& b2) {
double x1 = std::max(b1.x1, b2.x1);
double y1 = std::max(b1.y1, b2.y1);
double x2 = std::min(b1.x2, b2.x2);
double y2 = std::min(b1.y2, b2.y2);
double inter_w = std::max(0.0, x2 - x1);
double inter_h = std::max(0.0, y2 - y1);
double inter_area = inter_w * inter_h;
double area1 = std::max(0.0, b1.x2 - b1.x1) * std::max(0.0, b1.y2 - b1.y1);
double area2 = std::max(0.0, b2.x2 - b2.x1) * std::max(0.0, b2.y2 - b2.y1);
double union_area = area1 + area2 - inter_area;
if (union_area <= 1e-9) return 0.0;
return inter_area / union_area;
}
std::vector<int> non_maximum_suppression(const std::vector<BoundingBox>& boxes, double iou_threshold) {
if (boxes.empty()) return {};
int n = boxes.size();
std::vector<int> indices(n);
for (int i = 0; i < n; ++i) indices[i] = i;
std::sort(indices.begin(), indices.end(), [&](int a, int b) {
return boxes[a].score > boxes[b].score;
});
std::vector<int> keep;
while (!indices.empty()) {
int current = indices[0];
keep.push_back(current);
std::vector<int> remaining;
for (size_t i = 1; i < indices.size(); ++i) {
double iou = compute_iou(boxes[current], boxes[indices[i]]);
if (iou <= iou_threshold) {
remaining.push_back(indices[i]);
}
}
indices = remaining;
}
std::sort(keep.begin(), keep.end());
return keep;
}
def compute_iou(box1, box2):
x1 = max(box1[0], box2[0])
y1 = max(box1[1], box2[1])
x2 = min(box1[2], box2[2])
y2 = min(box1[3], box2[3])
inter_w = max(0.0, x2 - x1)
inter_h = max(0.0, y2 - y1)
inter_area = inter_w * inter_h
area1 = max(0.0, box1[2] - box1[0]) * max(0.0, box1[3] - box1[1])
area2 = max(0.0, box2[2] - box2[0]) * max(0.0, box2[3] - box2[1])
union_area = area1 + area2 - inter_area
if union_area <= 1e-9:
return 0.0
return inter_area / union_area
def non_maximum_suppression(boxes, iou_threshold):
"""
boxes: Danh sách các box [x1, y1, x2, y2, score]
iou_threshold: Ngưỡng IoU để loại bỏ box trùng lặp
Trả về danh sách chỉ số các box được giữ lại
"""
if not boxes:
return []
# Sắp xếp các chỉ số theo score giảm dần
indices = sorted(range(len(boxes)), key=lambda i: boxes[i][4], reverse=True)
keep = []
while indices:
current = indices[0]
keep.append(current)
remaining = []
for idx in indices[1:]:
iou = compute_iou(boxes[current][:4], boxes[idx][:4])
if iou <= iou_threshold:
remaining.append(idx)
indices = remaining
return sorted(keep)
7. Các lỗi hay gặp khi làm dự án Computer Vision thực tế
- Nhầm lẫn giữa các định dạng tọa độ Bounding Box:
Trong cộng đồng thị giác máy tính tồn tại ba định dạng tọa độ hộp bao thông dụng:
xyxy: \([x_{\min}, y_{\min}, x_{\max}, y_{\max}]\) (thường dùng trong OpenCV và Pascal VOC).xywh(chuẩn COCO): \([x_{\min}, y_{\min}, \text{width}, \text{height}]\).cxcywhchuẩn hóa (chuẩn YOLO): \([x_{\text{center}} / W, y_{\text{center}} / H, \text{width} / W, \text{height} / H]\) với các giá trị nằm trong đoạn \([0, 1]\). Việc đưa nhầm định dạng này vào hàm tính toán của định dạng khác sẽ khiến hộp bao bị tính sai lệch kích thước hoàn toàn hoặc nhận diện tọa độ âm.
- Chọn ngưỡng IoU trong NMS không phù hợp:
- Nếu đặt
iou_thresholdquá thấp (ví dụ \(0,2\)): Các vật thể đứng san sát nhau trong thực tế (như hai người đi bộ đi cạnh nhau hoặc xe cộ kẹt xe trên đường) sẽ bị thuật toán NMS xóa nhầm mất một người vì tưởng là hộp trùng lặp. - Nếu đặt
iou_thresholdquá cao (ví dụ \(0,8\)): Các hộp bao trùng lặp không bị triệt tiêu hết, khiến bức ảnh xuất ra vẫn bị rối mắt bởi nhiều khung bao quanh cùng một vật thể.
- Nếu đặt
- Quên giải phóng tài nguyên Camera VideoCapture:
Khi đọc luồng video từ webcam hoặc camera RTSP bằng
cap = cv2.VideoCapture(0), nếu chương trình bị dừng đột ngột mà không gọi lệnhcap.release()vàcv2.destroyAllWindows(), tiến trình camera sẽ bị hệ điều hành khóa (device busy), khiến các lần chạy code sau không thể truy cập được phần cứng. - Không tối ưu hóa tốc độ chuyển đổi GPU sang CPU:
Khi mô hình YOLO chạy xong trên GPU, kết quả đầu ra là một Tensor CUDA. Nếu bạn liên tục chuyển đổi từng hộp bao từ GPU về CPU bằng
.cpu().numpy()trong vòng lặp lồng nhau, thời gian truyền tải dữ liệu qua bus PCIe sẽ trở thành nút thắt cổ chai (bottleneck), kéo tụt tốc độ từ 60 FPS xuống chỉ còn 10 FPS. Toàn bộ thao tác NMS nên được thực hiện trực tiếp trên GPU thông quatorchvision.ops.nms.
8. Câu hỏi thường gặp về OpenCV và YOLO (FAQ)
YOLO có thể chạy mượt mà trên các thiết bị nhúng như Raspberry Pi không?
Các phiên bản YOLO kích thước đầy đủ (như YOLOv8x với 68M tham số) đòi hỏi GPU mạnh và không thể chạy thời gian thực trên vi xử lý nhúng. Tuy nhiên, các nhà phát triển cung cấp các biến thể siêu nhẹ như YOLOv8n (Nano, chỉ 3.2M tham số). Khi kết hợp xuất mô hình sang định dạng ONNX hoặc TensorRT / OpenVINO kèm lượng tử hóa số nguyên 8-bit (INT8 Quantization), tốc độ suy luận trên thiết bị nhúng tăng đáng kể. Ví dụ, theo bảng đo của Ultralytics trên Raspberry Pi 5 (độ chính xác FP32, ảnh 640 px), bản nano YOLO26n xuất sang NCNN suy luận khoảng 67 ms mỗi ảnh, tức khoảng 15 FPS chưa tính tiền xử lý và hậu xử lý; TensorRT chỉ dùng được trên thiết bị NVIDIA như Jetson.
Sự khác nhau giữa mAP@0.5 và mAP@0.5:0.95 là gì?
mAP@0.5: Mean Average Precision được tính tại ngưỡng cố định \(\text{IoU} = 0,5\). Đây là chuẩn đo lường của kỳ thi PASCAL VOC cũ, chỉ cần hộp bao đoán trúng khoảng \(50\%\) diện tích là được tính điểm tối đa.mAP@0.5:0.95: Chuẩn đo lường khắt khe hiện đại của bộ dữ liệu COCO Benchmark. Điểm số được tính bằng trung bình cộng của 10 mức ngưỡng IoU khác nhau: từ \(0,50\) tăng dần từng bước \(0,05\) tới \(0,95\) (\(\text{IoU} \in \{0.50, 0.55, 0.60, \dots, 0.95\}\)). Chỉ số này đòi hỏi mô hình không chỉ phát hiện đúng vật thể mà còn phải vẽ hộp bao cực kỳ sít sao và chuẩn xác đến từng pixel.
Khi nào nên dùng giải thuật xử lý ảnh OpenCV cổ điển thay vì Deep Learning?
Mặc dù Deep Learning rất mạnh mẽ, nhưng trong các bài toán công nghiệp có điều kiện ánh sáng kiểm soát tốt (như đếm số lượng viên thuốc trên băng chuyền, đo khoảng cách đường kính ống thép, đọc mã vạch QR code), các thuật toán xử lý ảnh cổ điển của OpenCV (như ngưỡng màu HSV, biến đổi hình thái học Morphology, tìm đường bao Contours) có ưu thế vượt trội: tốc độ chạy chỉ mất 1-2 mili-giây trên CPU yếu, không cần GPU đắt đỏ, và không cần tốn hàng tháng trời thu thập dán nhãn dữ liệu huấn luyện.
9. Bài tập tự luyện kèm lời giải chi tiết
Bài tập 1: Tính toán thủ công chỉ số IoU giữa hai hộp bao
Cho hai hộp bao trong mặt phẳng tọa độ pixel:
- Hộp \(A\): \([x_1=20, y_1=20, x_2=80, y_2=80]\)
- Hộp \(B\): \([x_1=50, y_1=50, x_2=110, y_2=110]\) Hãy tính diện tích phần giao nhau, diện tích phần hợp nhau và chỉ số IoU giữa hai hộp bao này.
Lời giải chi tiết:
- Tính diện tích từng hộp:
- \(\text{Area}(A) = (80 - 20) \times (80 - 20) = 60 \times 60 = 3600\).
- \(\text{Area}(B) = (110 - 50) \times (110 - 50) = 60 \times 60 = 3600\).
- Tìm tọa độ vùng giao nhau:
- \(x_{\text{inter1}} = \max(20, 50) = 50\).
- \(y_{\text{inter1}} = \max(20, 50) = 50\).
- \(x_{\text{inter2}} = \min(80, 110) = 80\).
- \(y_{\text{inter2}} = \min(80, 110) = 80\).
- Chiều rộng giao nhau: \(w_{\text{inter}} = 80 - 50 = 30\).
- Chiều cao giao nhau: \(h_{\text{inter}} = 80 - 50 = 30\).
- Diện tích phần giao nhau: \(\text{Area}(A \cap B) = 30 \times 30 = 900\).
- Tính diện tích phần hợp nhau: \[\text{Area}(A \cup B) = \text{Area}(A) + \text{Area}(B) - \text{Area}(A \cap B) = 3600 + 3600 - 900 = 6300\]
- Tính chỉ số IoU: \[\text{IoU} = \frac{900}{6300} = \frac{1}{7} \approx 0,1429 \quad (14,29\%)\] Vì \(\text{IoU} \approx 0,143 \lt 0,5\), hai hộp bao này không bị coi là trùng lặp ở ngưỡng NMS thông thường.
Bài tập 2: Mô phỏng từng bước giải thuật Non-Maximum Suppression
Cho danh sách 3 hộp bao dự đoán của lớp "Người":
- Hộp 0: \([10, 10, 60, 60]\), score = \(0,85\)
- Hộp 1: \([15, 15, 62, 62]\), score = \(0,92\)
- Hộp 2: \([100, 100, 140, 140]\), score = \(0,70\)
Biết rằng IoU giữa Hộp 0 và Hộp 1 là \(0,75\) (= 2025/2684). IoU giữa Hộp 2 với Hộp 0 và Hộp 1 đều bằng \(0,0\). Ngưỡng
iou_threshold = 0.5. Hãy chạy từng bước thuật toán NMS và cho biết những hộp nào được giữ lại.
Lời giải chi tiết:
- Bước 1: Sắp xếp theo score giảm dần:
Thứ tự ưu tiên: Hộp 1 (score \(0,92\)), Hộp 0 (score \(0,85\)), Hộp 2 (score \(0,70\)).
Danh sách xét:
[1, 0, 2]. - Bước 2: Vòng lặp thứ nhất:
- Chọn Hộp 1 (điểm cao nhất \(0,92\)). Đưa
1vào danh sáchkeep = [1]. - Tính IoU với các hộp còn lại:
- Với Hộp 0: \(\text{IoU}(1, 0) \approx 0,75 \gt 0,5 \implies\) Bị loại bỏ (Suppressed).
- Với Hộp 2: \(\text{IoU}(1, 2) = 0,0 \le 0,5 \implies\) Giữ lại trong danh sách chờ.
- Danh sách chờ còn lại:
[2].
- Chọn Hộp 1 (điểm cao nhất \(0,92\)). Đưa
- Bước 3: Vòng lặp thứ hai:
- Chọn Hộp 2 (điểm cao nhất hiện tại \(0,70\)). Đưa
2vàokeep = [1, 2]. - Không còn hộp nào khác trong danh sách chờ.
- Chọn Hộp 2 (điểm cao nhất hiện tại \(0,70\)). Đưa
- Kết quả cuối cùng: Thuật toán giữ lại Hộp 1 và Hộp 2 (
keep = [1, 2]), Hộp 0 bị loại bỏ thành công.
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í.


