Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và tự động hóa, thị giác máy tính (Computer Vision) đóng vai trò nền tảng trong việc tương tác giữa con người và máy móc. Theo các báo cáo công nghệ thị trường, hơn 80% hệ thống giám sát an ninh thông minh, xác thực sinh trắc học và quản lý nhân sự hiện đại đều yêu cầu module phát hiện khuôn mặt (Face Detection) như một bước tiền xử lý bắt buộc trước khi thực hiện nhận diện (Face Recognition).

Tuy nhiên, bài toán phát hiện khuôn mặt trong môi trường thực tế gặp nhiều thách thức lớn: sự biến đổi về cường độ ánh sáng, góc chụp, biểu cảm khuôn mặt, các chi tiết phụ (kính mắt, râu, khẩu trang) và đặc biệt là yêu cầu xử lý thời gian thực (Real-time Processing) trên các thiết bị phần cứng có tài nguyên giới hạn. Nếu sử dụng các mạng nơ-ron sâu phức tạp mà không có sự tối ưu hóa, chi phí tính toán phần cứng sẽ tăng cao, khó triển khai trên diện rộng.

Đồ án tốt nghiệp "Xây dựng ứng dụng phát hiện khuôn mặt trong ảnh sử dụng OpenCV" của tác giả Cao Tiến Đạt (Ngành Công nghệ Thông tin, Trường Đại học Dân lập Hải Phòng, dưới sự hướng dẫn của TS. Ngô Trường Giang) tập trung giải quyết bài toán cốt lõi này. Dự án thiết lập một giải pháp phát hiện khuôn mặt tối ưu dựa trên kỹ thuật trích xuất đặc trưng Haar-like kết hợp thuật toán học máy AdaBoost và cấu trúc phân tầng (Cascade of Classifiers), được hiện thực hóa thông qua thư viện thị giác máy tính nguồn mở OpenCV.

+-----------------------------------------------------------------------------+
|                            MỤC TIÊU DỰ ÁN CỤ THỂ                            |
+-----------------------------------------------------------------------------+
|  [1] Tổng quan hóa các hướng tiếp cận phát hiện khuôn mặt trong xử lý ảnh.  |
|  [2] Làm chủ cơ chế trích chọn đặc trưng Haar-like và ảnh tích phân        |
|      (Integral Image) với độ phức tạp tính toán O(1).                       |
|  [3] Phân tích và cài đặt thuật toán tăng cường AdaBoost cùng mô hình        |
|      bộ phân loại phân tầng Cascade để lọc nhanh nền nhiễu.                 |
|  [4] Xây dựng ứng dụng hoàn chỉnh bằng OpenCV có khả năng phát hiện đa       |
|      khuôn mặt trên ảnh tĩnh với độ chính xác trên 90% và tốc độ xử lý      |
|      thời gian thực đạt 15-20 FPS.                                          |
+-----------------------------------------------------------------------------+

Phạm vi và giới hạn

  • Phạm vi: Phát hiện các khuôn mặt người nhìn thẳng (frontal faces) hoặc có góc nghiêng nhỏ ($\pm 10^\circ$ đến $\pm 20^\circ$) trên ảnh đơn sắc, ảnh xám và ảnh màu tĩnh.
  • Giới hạn: Chưa xử lý triệt để các góc quay nghiêng lớn (profile faces $\ge 45^\circ$), khuôn mặt bị che khuất diện rộng hoặc điều kiện ánh sáng cực đoan (quá tối hoặc ngược sáng mạnh).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Nghiên cứu đối sánh bốn hướng tiếp cận kinh điển trong bài toán phát hiện khuôn mặt:

Hướng tiếp cận Phương pháp tiêu biểu Ưu điểm Nhược điểm / Hạn chế
Dựa trên tri thức (Knowledge-based) Quy tắc hình học tỉ lệ mắt-mũi-miệng, phương pháp chiếu (Yang & Huang, Kotropoulos) Dễ hiểu, mô hình hóa trực quan quan hệ không gian giữa các bộ phận. Khó chuyển hóa tri thức thành luật định lượng; tỷ lệ nhận diện sai cao khi nền phức tạp.
Đặc trưng không đổi (Invariant Features) Phân đoạn màu da (HSV, CIE-XYZ), trích xuất biên Canny, Snake/Blob Tốc độ trích xuất nhanh; giảm đáng kể không gian tìm kiếm ứng viên. Cực kỳ nhạy cảm với sự thay đổi của ánh sáng và màu nền; dễ nhầm lẫn vùng da tay/cổ.
So khớp mẫu (Template Matching) Mẫu chuẩn định dạng 23 quan hệ độ sáng (Sinha), Mẫu biến dạng (Yuille) Cài đặt đơn giản cho ảnh chụp thẳng chuẩn hóa. Không hiệu quả khi tỷ lệ xích, góc quay hoặc hình dạng khuôn mặt thay đổi.
Học máy / Diện mạo (Machine Learning) Eigenfaces (PCA), Support Vector Machine (SVM), Viola-Jones (Haar + AdaBoost) Tự động học từ dữ liệu lớn; độ chính xác cao; khả năng tổng quát hóa tốt. Chi phí huấn luyện ban đầu cao; cần tối ưu hóa cấu trúc để đạt tốc độ thời gian thực.

Ma trận ưu tiên yêu cầu hệ thống (Mô hình MoSCoW)

  • Must have (Bắt buộc): Chuyển đổi ảnh đầu vào sang ảnh xám; tính toán ma trận ảnh tích phân (Integral Image); áp dụng bộ phân loại Cascade nhận diện khuôn mặt nhìn thẳng; vẽ khung bao (Bounding Box) định vị tọa độ.
  • Should have (Nên có): Xử lý đa tỷ lệ khuôn mặt (Multiscale Detection) bằng kỹ thuật tháp ảnh (Image Pyramid); giao diện người dùng (GUI) cho phép tải ảnh và hiển thị trực quan.
  • Could have (Có thể có): Hỗ trợ xử lý trực tiếp từ luồng video webcam; lưu trữ kết quả phát hiện ra file ảnh độc lập.
  • Won't have (Chưa thực hiện): Nhận diện danh tính cá nhân (Face Identification); phân tích cảm xúc (Emotion Recognition); nhận diện góc nghiêng 90 độ.

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm 5 khối chức năng chính:

[Ảnh đầu vào (RGB)] 
       │
       ▼
[Tiền xử lý (Grayscale & Normalization)]
       │
       ▼
[Bộ tính toán Ảnh tích phân (Integral Image Engine)]
       │
       ▼
[Bộ phân loại phân tầng Cascade (Haar-like Features + AdaBoost Stages)]
       │
       ├── (Bị loại bỏ sớm tại Tầng 1-3 nếu không phải khuôn mặt)
       │
       ▼ (Vượt qua tất cả các tầng)
[Hậu xử lý (Non-Maximum Suppression - Gộp nhóm vùng phát hiện)]
       │
       ▼
[Xuất ảnh kết quả với Bounding Box]

Technology Stack & System Requirements

  • Ngôn ngữ lập trình: C++ / Python 3.8+
  • Thư viện thị giác máy tính: OpenCV 3.4.x / OpenCV 4.5.x (Sử dụng module objdetect, imgproc, highgui)
  • Cấu trúc tệp dữ liệu mô hình: File XML định dạng cấu hình cây phân lớp Haar Cascade (haarcascade_frontalface_default.xml hoặc haarcascade_frontalface_alt2.xml)
  • Yêu cầu tài nguyên phần cứng:
    • CPU: Intel Core i3 / AMD Ryzen 3 trở lên (xung nhịp $\ge 2.0\text{ GHz}$)
    • RAM: Tối thiểu 2GB (Khuyến nghị 4GB)
    • Dung lượng lưu trữ: $< 100\text{ MB}$ cho runtime và mô hình.

Methodology

Dự án áp dụng quy trình phát triển lặp kết hợp kiểm thử thực nghiệm từng giai đoạn (Iterative Prototyping):

Tuần 1-3: Nghiên cứu lý thuyết (Haar-like, Integral Image, AdaBoost, Cascade)
Tuần 4-6: Thiết kế kiến trúc giải thuật và phân tích cấu trúc hàm OpenCV
Tuần 7-9: Cài đặt module tiền xử lý, cấu hình tham số CascadeClassifier
Tuần 10-11: Thực nghiệm trên tập dữ liệu ảnh đơn/ảnh nhóm, tinh chỉnh tham số
Tuần 12: Đánh giá độ chính xác, phân tích lỗi và tổng hợp báo cáo đồ án

Bảng đánh giá rủi ro và giải pháp xử lý

Rủi ro kỹ thuật Mức độ Biện pháp giảm thiểu / Xử lý
Số lượng cửa sổ con quét qua ảnh quá lớn làm suy giảm FPS Cao Tích hợp thuật toán tháp ảnh với hệ số co dãn (scaleFactor = 1.2 hoặc 1.1), loại bỏ sớm vùng nền qua tầng Cascade ban đầu.
Báo động giả (False Positives) tại các vùng nền có kết cấu tương đồng Trung bình Tinh chỉnh tham số minNeighbors (ngưỡng số lượng hình chữ nhật lân cận tối thiểu từ 3 đến 6).
Ảnh đầu vào có độ tương phản quá kém hoặc chênh lệch sáng lớn Trung bình Tích hợp cân bằng biểu đồ mức xám (Histogram Equalization) trước khi đưa vào bộ phân loại.

Implementation và kết quả

Development process

1. Nguyên lý đặc trưng Haar-like và Tính toán Ảnh tích phân (Integral Image)

Đặc trưng Haar-like là sự chênh lệch giữa tổng giá trị cường độ mức xám của các vùng hình chữ nhật liền kề (vùng đen và vùng trắng):

$$\text{Giá trị đặc trưng} = \sum \text{Pixels}{\text{Vùng đen}} - \sum \text{Pixels}{\text{Vùng trắng}}$$

Để tính toán giá trị này trong thời gian hằng số $O(1)$ tại bất kỳ cửa sổ con nào, ma trận ảnh tích phân $P(x, y)$ được khởi tạo:

$$P(x, y) = \sum_{x' \le x, y' \le y} i(x', y')$$

Khi cần tính tổng mức xám của một vùng chữ nhật $D$ được định vị bởi 4 đỉnh $P_1(x_1, y_1), P_2(x_2, y_1), P_3(x_1, y_2), P_4(x_2, y_2)$, giải thuật thực hiện phép tính 4 điểm cực nhanh:

$$\text{Tổng mức xám}(D) = P_4 - P_2 - P_3 + P_1$$

(0,0)──────────────(x2,0)
  │                  │
  │    P1┌────────┐P2│
  │      │   D    │  │
  │    P3└────────┘P4│
  │                  │
(0,y2)─────────────(x2,y2)

2. Thuật toán AdaBoost và Bộ phân lớp phân tầng (Cascade Classifier)

Thuật toán AdaBoost kết hợp $M$ bộ phân loại yếu $h_m(x)$ thành một bộ phân loại mạnh $H(x)$:

$$H(x) = \text{sign}\left(\sum_{m=1}^{M} \alpha_m h_m(x)\right)$$

Trong đó trọng số mẫu được cập nhật động sau mỗi vòng lặp để tập trung vào các mẫu bị phân lớp sai:

$$w_i^{(m+1)} = w_i^{(m)} \exp\left(-y_i H_m(x_i)\right)$$

Cấu trúc Cascade tổ chức các bộ phân loại theo chuỗi liên tiếp. Tỷ lệ phát hiện đúng tổng thể ($D$) và tỷ lệ nhận sai tổng thể ($F$) qua $K$ tầng phân loại được xác định bằng tích chuỗi:

$$D = \prod_{k=1}^{K} d_k, \quad F = \prod_{k=1}^{K} f_k$$

3. Cài đặt mã nguồn với thư viện OpenCV

Đoạn mã sau minh họa quy trình nạp bộ phân loại Cascade đã huấn luyện, tiền xử lý và phát hiện khuôn mặt đa tỷ lệ:

import cv2
import sys

def detect_faces(image_path: str, cascade_path: str):
    # 1. Khởi tạo bộ phân loại Cascade từ tệp XML cấu hình sẵn
    face_cascade = cv2.CascadeClassifier(cascade_path)
    if face_cascade.empty():
        raise IOError(f"Không thể tải tệp mô hình Cascade tại: {cascade_path}")

    # 2. Đọc ảnh nguồn và chuyển đổi sang không gian mức xám
    img = cv2.imread(image_path)
    if img is None:
        raise ValueError(f"Không thể đọc tệp ảnh tại: {image_path}")
    
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 3. Thực hiện phát hiện khuôn mặt đa kích thước (Multiscale Search)
    # scaleFactor: Tỷ lệ thu nhỏ kích thước ảnh ở mỗi bước quét (1.2 tương ứng giảm 20%)
    # minNeighbors: Số lượng cửa sổ bao quanh tối thiểu để giữ lại ứng viên
    # minSize: Kích thước khuôn mặt nhỏ nhất có thể phát hiện (pixels)
    faces = face_cascade.detectMultiScale(
        gray,
        scaleFactor=1.2,
        minNeighbors=5,
        minSize=(30, 30),
        flags=cv2.CASCADE_SCALE_IMAGE
    )

    print(f"[INFO] Đã phát hiện thành công: {len(faces)} khuôn mặt.")

    # 4. Trực quan hóa kết quả: Vẽ bounding box hình chữ nhật lên ảnh gốc
    for (x, y, w, h) in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
        # Tùy chọn: Định vị vùng quan tâm (ROI) để tìm mắt hoặc nụ cười
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]

    return img, faces

if __name__ == "__main__":
    cascade_file = "haarcascade_frontalface_default.xml"
    input_image = "test_group.jpg"
    try:
        result_img, detected = detect_faces(input_image, cascade_file)
        cv2.imshow("Ket qua Phat hien Khuon mat - OpenCV", result_img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    except Exception as e:
        print(f"[ERROR] {e}", file=sys.stderr)

Testing và validation

Hệ thống được kiểm thử thực nghiệm trên nhiều bộ dữ liệu ảnh kiểm tra với các kịch bản thực tế:

Kịch bản kiểm thử Số lượng mẫu kiểm tra Phát hiện đúng (True Positive) Báo sai (False Positive) Bỏ sót (False Negative) Tỷ lệ chính xác (%)
Ảnh chân dung đơn (Nhìn thẳng, đủ sáng) 50 48 1 2 96.0%
Ảnh chân dung có phụ kiện (Kính mắt, mũ) 30 26 2 4 86.7%
Ảnh tập thể (Nhiều khuôn mặt, cự ly khác nhau) 25 118 / 130 mặt 7 12 90.8%
Ảnh góc nghiêng nhẹ ($\pm 15^\circ$) 30 23 3 7 76.7%
Ảnh điều kiện thiếu sáng / Nhiễu hạt 25 18 4 7 72.0% 
+-----------------------------------------------------------------------------+
|                     BENCHMARK HIỆU NĂNG THỜI GIAN THỰC                      |
+-----------------------------------------------------------------------------+
|  * Độ phân giải đầu vào: 640 x 480 pixels                                    |
|  * Thời gian xử lý trung bình: 42ms - 58ms / khung hình                     |
|  * Tốc độ xử lý thực tế: 18 - 23 FPS (trên CPU Intel Core i5 không dùng GPU) |
|  * Mức tiêu thụ bộ nhớ RAM: ~85MB                                           |
+-----------------------------------------------------------------------------+

Kết quả đạt được

  1. Về mặt lý thuyết: Hệ thống hóa toàn diện cơ sở toán học của kỹ thuật xử lý ảnh dựa trên đặc trưng diện mạo, phương pháp xấp xỉ phân phối xác suất và cơ chế tối ưu hàm mục tiêu theo cấp số nhân trong AdaBoost.
  2. Về mặt thực nghiệm: Xây dựng ứng dụng hoàn chỉnh, giao diện tương tác ổn định, phát hiện chính xác đa khuôn mặt nhìn thẳng trên các bức ảnh có cấu trúc nền từ đơn giản đến phức tạp.

Đổi mới và đóng góp

Điểm nhấn kỹ thuật và cải tiến giải thuật

  • Đột phá về tốc độ tính toán nhờ Integral Image: Thay vì phải duyệt qua toàn bộ $W \times H$ điểm ảnh trong từng cửa sổ con để tính tổng mức xám (độ phức tạp $O(K)$ với $K$ là diện tích cửa sổ), kỹ thuật mảng tích phân giảm chi phí tính toán xuống $O(1)$ chỉ với 4 phép truy xuất bộ nhớ và 3 phép cộng trừ.
  • Cơ chế loại bỏ nền phân tầng Cascade: Hơn 95% các cửa sổ con không chứa khuôn mặt bị loại bỏ ngay từ 2 tầng phân loại đầu tiên (chỉ sử dụng từ 2-5 đặc trưng cơ bản nhất như vùng mắt tối hơn trán/má). Điều này giúp tiết kiệm tới 80% tài nguyên CPU so với việc duyệt toàn bộ đặc trưng.

So sánh với các giải pháp khác

Tiêu chí kỹ thuật Đồ án (Haar-like + Cascade OpenCV) Eigenfaces (PCA truyền thống) Deep Learning (MTCNN / CNN)
Độ phức tạp tính toán Thấp ($O(1)$ per feature check) Trung bình ($O(N^2)$ ma trận) Rất cao ($O(N^4)$ phép tích chập)
Tốc độ xử lý (FPS trên CPU) 18 - 24 FPS (Real-time CPU) 5 - 8 FPS 1 - 4 FPS (Cần GPU để chạy mượt)
Độ chính xác mặt nhìn thẳng > 90% ~ 75 - 80% > 98%
Khả năng chịu góc nghiêng Kém ($\le 20^\circ$) Kém Rất tốt (Lên tới $90^\circ$)
Yêu cầu phần cứng Rất thấp (PC văn phòng, Chip nhúng) Thấp Cao (GPU chuyên dụng, VRAM lớn)

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng thực tế

  1. Hệ thống chấm công và điểm danh tự động: Định vị chính xác khuôn mặt nhân viên/sinh viên khi bước vào vùng quét của camera hành lang trước khi thực hiện bước nhận diện mã định danh.
  2. Giám sát an ninh nơi công cộng: Lọc nhanh các khung hình có xuất hiện đối tượng người trong luồng dữ liệu camera tại siêu thị, nhà ga, sân bay để phục vụ trích xuất dữ liệu điều tra.
  3. Tự động lấy nét trong máy ảnh số: Hỗ trợ chip xử lý hình ảnh xác định tọa độ trọng tâm khuôn mặt để tự động điều chỉnh tiêu cự (Auto-focus) và độ phơi sáng (Auto-exposure).

Hướng dẫn triển khai và phân tích chi phí

# Hướng dẫn thiết lập môi trường triển khai trên hệ điều hành Linux/Ubuntu
sudo apt update && sudo apt install -y python3-pip python3-opencv
pip3 install numpy matplotlib

# Chạy kiểm thử ứng dụng phát hiện khuôn mặt
python3 detect_faces.py --input test.jpg --cascade haarcascade_frontalface_default.xml

Phân tích hiệu quả kinh tế (ROI)

  • Chi phí phần cứng: Giảm 70% chi phí đầu tư thiết bị do thuật toán có thể vận hành ổn định trên các vi xử lý giá rẻ (như Raspberry Pi 4, Intel Celeron/Core i3) mà không bắt buộc trang bị card đồ họa rời đắt tiền.
  • Khả năng mở rộng: Dễ dàng đóng gói thành các dịch vụ microservice hoặc triển khai cục bộ (Edge AI) tại hàng trăm camera mà không làm nghẽn băng thông đường truyền về máy chủ trung tâm.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  • Mô hình Haar Cascade nhạy cảm với sự quay của khuôn mặt ngoài mặt phẳng ảnh (out-of-plane rotation $> 20^\circ$).
  • Tỷ lệ dương tính giả (False Positive) còn xuất hiện tại các vùng nền có hoa văn caro hoặc độ tương phản sáng tối đan xen tương tự hình thái mắt - mũi.
  • Hiệu năng suy giảm khi đối tượng bị che khuất một phần (đeo khẩu trang y tế, kính râm to bản).

Hướng phát triển trong tương lai

  • Mở rộng tập đặc trưng: Tích hợp các đặc trưng mở rộng xoay nghiêng $45^\circ$ (Tilted Haar Features) hoặc đặc trưng cục bộ LBP (Local Binary Patterns) để tăng tốc độ xử lý thêm 20-30%.
  • Kết hợp mô hình lai (Hybrid Approach): Sử dụng phân đoạn màu da người trong không gian màu YCbCr/HSV làm bước tiền xử lý nhằm thu hẹp 60% diện tích quét trước khi chạy Cascade.
  • Nâng cấp mô hình nhận diện: Nghiên cứu tích hợp các mạng nơ-ron tích chập nhẹ (Lightweight CNNs như MobileNet-SSD, Ultra-Light Fast Generic Face Detector) để nâng cao độ chính xác trên các góc nghiêng phức tạp.

Đối tượng hưởng lợi

+─────────────────────────────────────────────────────────────────────────────+
|                         GIÁ TRỊ CHO TỪNG ĐỐI TƯỢNG                          |
+─────────────────────────────────────────────────────────────────────────────+
|  [SINH VIÊN & NGHIÊN CỨU SINH]                                              |
|  * Tài liệu tham khảo toàn diện về xử lý ảnh và thị giác máy tính cổ điển.  |
|  * Nắm vững bản chất toán học của giải thuật boosting và ảnh tích phân.     |
+─────────────────────────────────────────────────────────────────────────────+
|  [KỸ SƯ PHẦN MỀM & LẬP TRÌNH VIÊN EMBEDDED]                                 |
|  * Nắm bắt kỹ thuật tối ưu hóa mã nguồn xử lý ảnh thời gian thực.           |
|  * Sử dụng thành thạo cấu trúc API của thư viện OpenCV C++/Python.          |
+─────────────────────────────────────────────────────────────────────────────+
|  [DOANH NGHIỆP TÍCH HỢP HỆ THỐNG]                                           |
|  * Giải pháp phát hiện khuôn mặt chi phí thấp cho hệ thống IoT/Edge.        |
|  * Tối ưu hóa chi phí phần cứng và vận hành trên quy mô lớn.                |
+─────────────────────────────────────────────────────────────────────────────+

Câu hỏi thường gặp

1. Cấu hình phần cứng tối thiểu để ứng dụng chạy đạt chuẩn thời gian thực?

Hệ thống chỉ yêu cầu CPU lõi kép x86 hoặc vi xử lý ARM (tương đương Raspberry Pi 3B+ trở lên), 1GB RAM và webcam chuẩn USB 720p là có thể đạt tốc độ xử lý từ 15 đến 20 FPS mà không cần GPU.

2. Làm thế nào để giảm thiểu hiện tượng nhận diện nhầm các vật thể nền thành khuôn mặt?

Cần tinh chỉnh hai tham số quan trọng trong hàm detectMultiScale:

  • Tăng giá trị minNeighbors từ 3 lên 5 hoặc 6 (yêu cầu số lượng khung chữ nhật đồng thuận cao hơn).
  • Thiết lập minSize hợp lý (ví dụ: (40, 40)) để loại bỏ các cửa sổ nhiễu kích thước quá nhỏ.

3. Thuật toán có thể phát hiện khuôn mặt khi người dùng đeo khẩu trang không?

Đặc trưng Haar cơ bản dựa nhiều vào mối tương quan giữa mắt, sống mũi và miệng. Khi đeo khẩu trang, vùng miệng và cằm bị che khuất khiến tổng mức xám thay đổi, làm giảm tỷ lệ phát hiện khoảng 30-40%. Giải pháp khắc phục là sử dụng bộ lọc chuyên biệt chỉ quét vùng mắt (Haar Cascade Eye Detector).

4. Tại sao cần chuyển ảnh sang không gian mức xám trước khi xử lý?

Các đặc trưng Haar-like hoạt động dựa trên sự chênh lệch cường độ sáng tương đối giữa các vùng hình chữ nhật chứ không phụ thuộc vào giá trị màu sắc. Việc chuyển sang ảnh xám (1 kênh màu duy nhất thay vì 3 kênh RGB) giúp giảm dung lượng dữ liệu cần tính toán đi 3 lần, tăng tốc độ xử lý tổng thể.

5. Sự khác nhau giữa phát hiện khuôn mặt (Face Detection) và nhận dạng khuôn mặt (Face Recognition)?

  • Phát hiện khuôn mặt (Face Detection): Chỉ trả lời câu hỏi "Có khuôn mặt trong ảnh hay không và vị trí ở đâu?" (định vị tọa độ bounding box).
  • Nhận dạng khuôn mặt (Face Recognition): Bước tiếp theo, trả lời câu hỏi "Khuôn mặt đó là của ai cụ thể?" bằng cách so khớp vector đặc trưng với cơ sở dữ liệu đã gán nhãn.

Kết luận

Đồ án "Xây dựng ứng dụng phát hiện khuôn mặt trong ảnh sử dụng OpenCV" của sinh viên Cao Tiến Đạt đã giải quyết trọn vẹn bài toán phát hiện khuôn mặt người nhìn thẳng với độ chính xác cao ($>90%$) và hiệu năng xử lý đạt chuẩn thời gian thực trên các dòng máy tính phổ thông.

Bằng việc kết hợp nhuần nhuyễn giữa nền tảng lý thuyết thị giác máy tính vững chắc (đặc trưng Haar-like, cấu trúc ảnh tích phân $O(1)$, giải thuật AdaBoost) với các công cụ tối ưu hóa của thư viện OpenCV, công trình không chỉ mang giá trị học thuật xuất sắc cho sinh viên ngành Công nghệ Thông tin mà còn cung cấp một giải pháp kỹ thuật có tính ứng dụng thực tiễn cao, sẵn sàng tích hợp vào các hệ sinh thái chấm công, an ninh thông minh và tương tác người - máy hiện đại.