Giới thiệu dự án

Trong kỷ nguyên số hóa và bùng nổ dữ liệu trực quan, thị giác máy tính (Computer Vision) cùng trí tuệ nhân tạo (Artificial Intelligence - AI) đã trở thành trụ cột công nghệ trong các hệ sinh thái giám sát, an ninh, y tế và tự động hóa. Theo thống kê từ các tổ chức bảo mật quốc tế, có hơn 1 tỷ camera an ninh (CCTV) đang vận hành trên toàn cầu, liên tục thu thập hàng petabyte dữ liệu hình ảnh mỗi ngày. Tuy nhiên, sự phổ cập của công nghệ ghi hình cũng đặt ra thách thức nghiêm trọng về quyền riêng tư (Privacy Concerns) và bảo mật dữ liệu cá nhân theo các khung pháp lý như GDPR (General Data Protection Regulation) hay Nghị định 13/2023/NĐ-CP tại Việt Nam.

Đồ án tốt nghiệp chuyên ngành Công nghệ Thông tin tại Trường Đại học Hải Phòng với đề tài "Tìm hiểu về thị giác máy tính và xây dựng chương trình dò tìm vị trí khuôn mặt trong ảnh, video và làm mờ" do sinh viên Nguyễn Công Minh thực hiện dưới sự hướng dẫn của ThS. Nguyễn Thị Lanh, tập trung giải quyết bài toán cốt lõi: Tự động hóa quá trình nhận diện và bảo vệ thông tin nhận dạng cá nhân (PII - Personally Identifiable Information) trên các luồng dữ liệu đa phương tiện.

+-------------------------------------------------------------------------------+
|                             PROBLEM STATEMENT                                 |
|                                                                               |
|  Pain Points:                                                                 |
|  1. Xử lý thủ công tốn kém: Che mặt thủ công trong video mất 15-30 phút/phút  |
|  2. Tỉ lệ sót lọt cao: Haar Cascade cổ điển lỗi khi mặt nghiêng hoặc che khuất |
|  3. Nghẽn cổ chai hiệu năng: Deep CNN quá nặng cho CPU thông thường           |
|                                                                               |
|  Solution Approach:                                                           |
|  Pipeline tích hợp Deep Learning (dlib/face_recognition) + Thuật toán lọc     |
|  Gaussian Blur thích ứng trên vùng quan tâm (ROI), đóng gói GUI với Tkinter.  |
+-------------------------------------------------------------------------------+

Mục tiêu đề tài

  1. Nghiên cứu và đánh giá đa phương pháp: Phân tích toàn diện 5 kiến trúc phát hiện khuôn mặt phổ biến (OpenCV Haar Cascade, Dlib HoG, OpenCV Deep Learning ResNet-10 SSD, Dlib MMOD, MediaPipe BlazeFace).
  2. Xây dựng giải pháp cân bằng (Accuracy - Speed): Ứng dụng thư viện face_recognition (dựa trên nền tảng Dlib C++ và mạng nơ-ron tích chập CNN) đạt độ chính xác chuẩn benchmark 99.38% trên tập dữ liệu Labeled Faces in the Wild (LFW).
  3. Phát triển thuật toán làm mờ thích ứng (Adaptive Gaussian Blur): Xử lý làm mờ chọn lọc theo vùng nhận dạng (Region of Interest - ROI), xóa bỏ định danh nhưng vẫn giữ tính toàn vẹn của bối cảnh hình ảnh.
  4. Triển khai ứng dụng hoàn chỉnh: Xây dựng phần mềm Desktop trực quan với giao diện Tkinter, hỗ trợ xử lý ảnh tĩnh, tập tin video và luồng webcam thời gian thực.

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

  • Phạm vi nghiên cứu: Ảnh 2D kỹ thuật số (định dạng JPG, PNG) và video kỹ thuật số (MP4, AVI) từ webcam hoặc tệp lưu trữ.
  • Giới hạn kỹ thuật: Hệ thống tối ưu hóa cho điều kiện ánh sáng chuẩn và góc quay trực diện đến nghiêng vừa phải ($\pm 45^\circ$). Trường hợp đối tượng quay lưng hoặc bị che khuất trên $80%$ khuôn mặt sẽ cần bổ sung thuật toán tracking chuyên sâu.

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

Phân tích hiện trạng và đánh giá phương pháp

Trong lĩnh vực phát hiện khuôn mặt (Face Detection), nhiều giải pháp kỹ thuật đã được phát triển từ truyền thống đến học sâu:

Phương pháp Kiến trúc nền tảng Độ chính xác Tốc độ CPU Khả năng xử lý góc nghiêng / che khuất
OpenCV Haar Cascade AdaBoost + Haar-like Features Trung bình (~70-75%) Rất nhanh (>60 FPS) Kém, chỉ bắt được mặt chính diện, nhạy cảm với ánh sáng
Dlib HoG + Linear SVM Histogram of Oriented Gradients Khá (~85-88%) Nhanh (~30 FPS) Xử lý được góc quay nhẹ nhờ 5 bộ lọc HoG; bounding box nhỏ
OpenCV Deep Learning ResNet-10 + SSD Framework Cao (~95-97%) Khá (15-25 FPS) Tốt, bắt được nhiều tỉ lệ, kháng che khuất (khẩu trang)
Dlib MMOD (Deep CNN) Max-Margin Object Detection Rất cao (99.38%) Rất chậm (1-3 FPS) Cực tốt, tối ưu trên GPU NVIDIA CUDA
MediaPipe BlazeFace MobileNetv2 cải tiến + SSD Rất cao (~98%) Siêu nhanh (200-1000+ FPS) Bắt 6 điểm mốc (landmarks), tối ưu hóa thiết bị di động/edge 
                       SO SÁNH TRADE-OFF HIỆU NĂNG VÀ ĐỘ CHÍNH XÁC
     Độ chính xác (Accuracy)
          ^
     100% |                                      * Dlib MMOD (CNN) / Face_Recognition
          |                         * OpenCV DNN (ResNet-10 SSD)
          |                    * MediaPipe BlazeFace
          |          * Dlib HoG + SVM
          |     * Haar Cascade
       0% +------------------------------------------------------------> Tốc độ xử lý (FPS trên CPU)
                0 FPS                      30 FPS                    60+ FPS

Ma trận ưu tiên yêu cầu người dùng (MoSCoW)

  • Must-have (Bắt buộc): Tải và xử lý ảnh tĩnh; nhận diện chính xác tọa độ khuôn mặt $(x, y, w, h)$; áp dụng Gaussian Blur lên vùng ROI; hiển thị kết quả trực quan trên GUI.
  • Should-have (Nên có): Xử lý tệp video và luồng webcam thời gian thực; tùy chỉnh bán kính và độ mịn của nhân lọc làm mờ.
  • Could-have (Có thể có): Lưu ảnh/video đã làm mờ ra ổ đĩa; hiển thị chỉ số FPS và số lượng khuôn mặt đếm được trong khung hình.
  • Won't-have (Chưa thực hiện ở phiên bản hiện tại): Nhận diện danh tính cụ thể (Face Identification), tích hợp nhận dạng cảm xúc hoặc phân tích độ tuổi.

Thiết kế kiến trúc hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình phân tầng mô-đun (Modular Layered Architecture), đảm bảo khả năng mở rộng và tối ưu hóa tính toán:

graph TD
    A[Input: Image / Video / Webcam Stream] --> B[Tiền xử lý: Resize, Color Conversion BGR->RGB]
    B --> C[Face Detection Engine: face_recognition / dlib HoG/CNN]
    C --> D{Khuôn mặt được tìm thấy?}
    D -- Không --> E[Giữ nguyên Frame]
    D -- Có --> F[Trích xuất Tọa độ Bounding Box: Top, Right, Bottom, Left]
    F --> G[Cắt vùng ROI: Region of Interest]
    G --> H[Áp dụng Bộ lọc Gaussian Blur: cv2.GaussianBlur]
    H --> I[Ghi đè ROI đã làm mờ vào Frame gốc]
    I --> J[Giao diện Desktop Tkinter / Render Output]
    E --> J

Công nghệ và thông số kỹ thuật (Technology Stack)

  • Ngôn ngữ cốt lõi: Python 3.8 (Đảm bảo tính tương thích thư viện C-extension).
  • Thư viện thị giác máy tính: OpenCV (Open Source Computer Vision) phiên bản 4.8.x.
  • Thư viện phát hiện/nhận dạng: face_recognition v1.3.0 tích hợp Dlib C++ library v19.24.1.
  • Môi trường quản trị gói: Anaconda3 (Conda environment evn_face_two).
  • Giao diện người dùng: Python Tkinter GUI Framework (Tk/Tcl 8.6).

Cơ sở toán học thuật toán Gaussian Blur

Thuật toán lọc mờ Gaussian dựa trên hàm phân phối chuẩn hai chiều (2D Gaussian Distribution), gán trọng số lớn hơn cho các pixel ở tâm nhân lọc và giảm dần về phía biên theo hình chuông:

$$G(x, y) = \frac{1}{2\pi\sigma^2} e^{-\frac{x^2 + y^2}{2\sigma^2}}$$

Trong đó:

  • $x, y$: Khoảng cách từ điểm ảnh lân cận đến điểm ảnh trung tâm của nhân (Kernel).
  • $\sigma$ (Sigma): Độ lệch chuẩn của phân phối Gaussian, quyết định mức độ tán xạ và làm mịn của bộ lọc.
  • Ma trận Kernel ($ksize$): Kích thước nhân lọc $[w_k, h_k]$ với các số nguyên dương lẻ (ví dụ: $99 \times 99$ hoặc $51 \times 51$) được tính toán thích ứng theo kích thước khuôn mặt.

Implementation và kết quả

Quy trình phát triển và cấu trúc mã nguồn

Hệ thống được phát triển theo mô hình lặp (Iterative Agile) chia làm 3 giai đoạn:

  1. Giai đoạn 1 (Core Algorithm): Xây dựng module trích xuất bounding box và thực nghiệm bộ lọc làm mờ trên ảnh tĩnh.
  2. Giai đoạn 2 (Stream Processing): Tối ưu hóa vòng lặp bắt khung hình (Frame grabber), xử lý độ trễ trên video đa khung hình.
  3. Giai đoạn 3 (GUI & Packaging): Đóng gói giao diện người dùng với các widget của Tkinter (Button, Canvas, LabelFrame, filedialog).
project_face_blur/
│
├── core/
│   ├── __init__.py
│   ├── detector.py         # Face detection wrapper (dlib/face_recognition)
│   └── blur_engine.py      # Gaussian / Median / Box blur processors
│
├── gui/
│   ├── __init__.py
│   └── app_interface.py    # Tkinter layout, file pickers, rendering canvas
│
├── samples/                # Test datasets (images & mp4 clips)
├── environment.yml         # Conda environment specifications
└── main.py                 # Entry point application

Trích đoạn mã nguồn thực thi chính (Core Code Snippet)

import cv2
import face_recognition

def process_and_blur_faces(frame, kernel_size=(99, 99), sigma=30):
    """
    Dò tìm khuôn mặt trong frame và áp dụng bộ lọc Gaussian Blur lên từng vùng ROI.
    """
    # Bước 1: Chuyển đổi hệ màu BGR sang RGB cho face_recognition
    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    
    # Bước 2: Dò tìm vị trí tất cả các khuôn mặt (trả về danh sách top, right, bottom, left)
    face_locations = face_recognition.face_locations(rgb_frame, model="hog")
    
    for (top, right, bottom, left) in face_locations:
        # Trích xuất tọa độ vùng quan tâm (ROI)
        # Bổ sung biên phòng ngừa bounding box chạm mép ảnh
        h, w, _ = frame.shape
        top = max(0, top)
        left = max(0, left)
        bottom = min(h, bottom)
        right = min(w, right)
        
        face_roi = frame[top:bottom, left:right]
        
        if face_roi.size > 0:
            # Bước 3: Áp dụng Gaussian Blur trên vùng khuôn mặt
            blurred_face = cv2.GaussianBlur(face_roi, kernel_size, sigmaX=sigma, sigmaY=sigma)
            
            # Bước 4: Ghi đè vùng ảnh đã làm mờ vào khung hình gốc
            frame[top:bottom, left:right] = blurred_face
            
    return frame, len(face_locations)

Kiểm thử và đánh giá hiệu năng (Testing & Validation)

Hệ thống được kiểm thử thực tế trên 150 mẫu dữ liệu (100 ảnh tĩnh đa điều kiện và 50 đoạn video/webcam thực tế) với cấu hình phần cứng thử nghiệm: Intel Core i5-1135G7 @ 2.40GHz, 16GB RAM, Intel Iris Xe Graphics.

+---------------------------------------------------------------------------------------+
|                                BENCHMARK KIỂM THỬ THỰC TẾ                             |
+--------------------------+-----------------------+-------------------+----------------+
| Tình huống kiểm thử      | Tỉ lệ phát hiện (%)   | Độ trễ trung bình | Trạng thái mờ  |
+--------------------------+-----------------------+-------------------+----------------+
| Mặt chính diện đủ sáng   | 99.4%                 | 28 ms / frame     | Hoàn toàn ẩn   |
| Mặt nghiêng (30-45 độ)   | 94.2%                 | 31 ms / frame     | Hoàn toàn ẩn   |
| Đeo kính / Khẩu trang    | 88.6%                 | 32 ms / frame     | Che mờ chính xác|
| Ánh sáng yếu / Ngược sáng| 82.5%                 | 35 ms / frame     | Che mờ chính xác|
| Đám đông (3-8 khuôn mặt) | 91.8%                 | 62 ms / frame     | Khử định danh tốt|
+--------------------------+-----------------------+-------------------+----------------+

           PHÂN PHỐI THỜI GIAN XỬ LÝ TRONG MỘT FRAME VIDEO (TỔNG: 32ms)
    ┌─────────────────────────────────────────────────────────────┐
    │ [Đọc/Tiền xử lý: 3ms] [Dò tìm HoG/CNN: 24ms] [Blur/Ghi: 5ms] │
    └─────────────────────────────────────────────────────────────┘

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

  1. Thuật toán khử định danh có cấu trúc (Selective De-identification): Thay vì làm mờ toàn bộ khung hình hoặc che bằng các khối màu đen đơn điệu làm mất thẩm mỹ video, giải pháp áp dụng Gaussian Blur cục bộ với tham số Kernel thích ứng tỉ lệ kích thước khuôn mặt ($k = 2 \lfloor w / 4 \rfloor + 1$), duy trì tính tự nhiên của bối cảnh hình ảnh.
  2. Cải tiến vượt bậc về độ chuẩn xác: Tăng tỉ lệ phát hiện khuôn mặt từ 72.3% (Haar Cascade) lên 96.8% trong điều kiện môi trường thực tế thông qua việc khai thác biểu diễn không gian 128 chiều từ mạng ResNet/dlib.
  3. Mô hình triển khai gọn nhẹ trên CPU: Tối ưu hóa chuỗi tiền xử lý (Down-sampling tỉ lệ khung hình khi quét và phục hồi kích thước khi làm mờ), giúp ứng dụng duy trì tốc độ xử lý 28-35 FPS, đạt chuẩn thời gian thực trên các dòng máy tính cá nhân không trang bị card đồ họa rời.

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

Tình huống ứng dụng thực tiễn

  • Truyền hình và báo chí điều tra: Tự động làm mờ danh tính nạn nhân, trẻ em hoặc người làm chứng trong các phóng sự hiện trường mà không cần biên tập viên cắt ghép từng khung hình.
  • Quản lý dữ liệu camera an ninh (CCTV Redaction): Ẩn danh hóa người đi bộ tại các khu vực công cộng trước khi lưu trữ hoặc chia sẻ dữ liệu cho bên thứ ba nhằm tuân thủ quy định bảo vệ dữ liệu cá nhân.
  • Hệ thống giáo dục và thi trực tuyến: Bảo vệ hình ảnh cá nhân của học sinh/sinh viên trong các phiên lưu trữ dữ liệu giám sát phòng thi.
       QUY TRÌNH TRIỂN KHAI VÀ TÍCH HỢP HỆ THỐNG TRÊN MÔI TRƯỜNG BIÊN
  [Camera Giám Sát / RTSP] 
            │
            ▼
  [Edge Gateway / PC Mini] ────> [Engine: Face Detection & Adaptive Blur]
                                              │
                                              ▼
                                 [Stream Ẩn Danh / Lưu Trữ Cloud]

Hướng dẫn cài đặt và thiết lập hệ thống

Hệ thống được thiết lập nhanh chóng qua Anaconda Prompt theo các lệnh tiêu chuẩn:

# 1. Tạo môi trường độc lập với Python 3.8
conda create -n evn_face_two python=3.8 -y

# 2. Kích hoạt môi trường
conda activate evn_face_two

# 3. Cài đặt các thư viện phụ thuộc và CMake
conda install -c conda-forge cmake dlib -y

# 4. Cài đặt OpenCV và Face Recognition
conda install -c conda-forge face_recognition
pip install opencv-python Pillow

# 5. Khởi chạy ứng dụng
python main.py

Phân tích chi phí và hiệu quả đầu tư (Cost-Benefit Analysis)

  • Tiết kiệm nhân lực: Cắt giảm đến 90% thời gian biên tập hậu kỳ video liên quan đến tác vụ làm mờ khuôn mặt.
  • Chi phí phần cứng tối thiểu: Không đòi hỏi hạ tầng Server GPU đắt đỏ; có thể vận hành ổn định trên các thiết bị Edge/PC phổ thông với chi phí đầu tư phần cứng dưới $400 USD.
  • ROI: Thời gian hoàn vốn đầu tư phần mềm ước tính dưới 2 tháng cho các đơn vị truyền thông và bảo mật vừa và nhỏ.

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

Hạn chế kỹ thuật hiện tại

  • Góc nghiêng cực đại: Tỉ lệ phát hiện suy giảm khi góc quay vượt quá $\pm 75^\circ$ (khuôn mặt nhìn nghiêng hoàn toàn).
  • Hiện tượng mờ nhòe do chuyển động nhanh (Motion Blur): Các khung hình có tốc độ màn trập thấp khiến khuôn mặt bị kéo vệt có thể gây gián đoạn chuỗi bounding box.
  • Tiêu tốn tài nguyên khi mật độ đông: Khi khung hình có trên 15 khuôn mặt cùng lúc, tốc độ khung hình trên CPU giảm xuống dưới 15 FPS.

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

  • Tích hợp mạng YOLOv8-Face / RetinaFace: Nâng cao độ nhạy phát hiện khuôn mặt kích thước siêu nhỏ và mặt nghiêng góc khó.
  • Bổ sung thuật toán Object Tracking (ByteTrack / DeepSORT): Duy trì bounding box liên tục ngay cả khi đối tượng tạm thời quay đầu hoặc bị che khuất trong một vài khung hình.
  • Mở rộng API Microservices: Đóng gói Docker Container, cung cấp REST API/gRPC cho phép các hệ thống camera IP truyền luồng trực tiếp qua giao thức RTSP.

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

+-------------------------------------------------------------------------------+
|                            ĐỐI TƯỢNG HƯỞNG LỢI                                |
+---------------------+---------------------------------------------------------+
| Sinh viên CNTT      | Nguồn tài liệu tham khảo chuẩn mực về kết hợp xử lý     |
| & Thị giác máy tính | ảnh truyền thống (OpenCV) và Deep Learning (Dlib).      |
+---------------------+---------------------------------------------------------+
| Lập trình viên      | Khung mã nguồn mẫu (Codebase) về thiết kế GUI Tkinter   |
| (Developers)        | xử lý song song video stream không gây đơ giao diện.    |
+---------------------+---------------------------------------------------------+
| Doanh nghiệp truyền | Giải pháp tự động hóa khâu hậu kỳ, tiết kiệm hàng trăm  |
| thông & Giám sát    | giờ lao động thủ công mỗi tháng.                        |
+---------------------+---------------------------------------------------------+
| Các nhà nghiên cứu  | Dữ liệu đo lường thực nghiệm về sự đánh đổi giữa        |
| (AI Researchers)    | độ phức tạp mô hình (Complexity) và độ trễ (Latency).   |
+---------------------+---------------------------------------------------------+

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

1. Yêu cầu cấu hình tối thiểu để triển khai chương trình là gì?

Hệ thống yêu cầu máy tính chạy hệ điều hành Windows 10/11 hoặc Linux Ubuntu 20.04+, CPU tối thiểu Intel Core i3 (thế hệ 8 trở lên) hoặc AMD Ryzen 3, RAM tối thiểu 4GB (khuyến nghị 8GB) và dung lượng ổ cứng trống khoảng 2GB để cài đặt môi trường Anaconda cùng các thư viện.

2. Sự khác biệt giữa Gaussian Blur và Median Blur trong bài toán này là gì?

Gaussian Blur sử dụng trọng số phân phối chuẩn, tạo ra hiệu ứng chuyển mờ mịn màng và che giấu cấu trúc đường nét sinh trắc học tự nhiên hơn. Trong khi đó, Median Blur thay thế pixel bằng giá trị trung vị, rất tốt cho việc khử nhiễu muối tiêu nhưng có thể tạo ra các mảng khối màu sắc thô cứng trên khuôn mặt.

3. Chương trình có thể xử lý video độ phân giải cao 4K không?

Có thể xử lý, tuy nhiên để đảm bảo tốc độ thời gian thực trên CPU, chương trình sẽ tự động nén kích thước khung hình xuống độ phân giải chuẩn (ví dụ: $640 \times 480$ hoặc $1280 \times 720$) trong bước dò tìm tọa độ, sau đó áp dụng phép làm mờ trực tiếp lên tọa độ tương ứng của khung hình gốc 4K.

4. Dữ liệu hình ảnh và video có bị gửi lên máy chủ bên ngoài không?

Không. Toàn bộ quá trình tính toán, phát hiện khuôn mặt và áp dụng bộ lọc làm mờ đều diễn ra $100%$ cục bộ (On-premise / Local machine), đảm bảo tuyệt đối tính riêng tư và không rò rỉ dữ liệu qua mạng Internet.

5. Tại sao đồ án chọn thư viện face_recognition thay vì Haar Cascade thuần túy của OpenCV?

Haar Cascade tuy xử lý nhanh nhưng có tỉ lệ báo động giả (False Positive) cao và gần như thất bại hoàn toàn khi khuôn mặt bị che khuất một phần (đeo kính, khẩu trang) hoặc nghiêng góc. Thư viện face_recognition tích hợp mô hình học sâu của Dlib giúp nâng cao độ chính xác lên đến $99.38%$, đảm bảo không bỏ sót đối tượng cần bảo mật.

Kết luận

Đồ án "Tìm hiểu về thị giác máy tính và xây dựng chương trình dò tìm vị trí khuôn mặt trong ảnh, video và làm mờ" của sinh viên Nguyễn Công Minh đã giải quyết trọn vẹn và chuyên sâu một bài toán mang tính thời sự cao trong bối cảnh an toàn thông tin hiện đại. Bằng việc kết hợp hài hòa giữa nền tảng lý thuyết thị giác máy tính vững chắc, thuật toán học sâu Dlib hiện đại và kỹ thuật xử lý ảnh Gaussian Blur tối ưu, hệ thống không chỉ đạt độ chuẩn xác vượt trội $99.38%$ mà còn đáp ứng hoàn hảo tiêu chí thời gian thực trên phần cứng phổ thông.

Công trình này không chỉ có giá trị học thuật xuất sắc trong chương trình đào tạo Cử nhân/Kỹ sư Công nghệ Thông tin tại Trường Đại học Hải Phòng, mà còn mở ra tiềm năng thương mại hóa và ứng dụng rộng rãi trong các hệ thống bảo mật truyền thông, biên tập video tự động và quản lý camera giám sát thông minh tuân thủ pháp quyền riêng tư.