Giới thiệu dự án

Bối cảnh và thực trạng ngành

Trong kỷ nguyên tự động hóa và an ninh thông minh (Smart Security), công nghệ thị giác máy tính (Computer Vision) đóng vai trò nền tảng trong việc giám sát và quản lý truy cập. Theo các báo cáo thị trường an ninh toàn cầu, nhu cầu triển khai hệ thống nhận diện khuôn mặt tự động (Automated Facial Recognition System) tăng trưởng hơn 16% CAGR mỗi năm. Tuy nhiên, phần lớn các hệ thống camera giám sát (CCTV) hiện hữu chỉ đóng vai trò ghi hình thụ động (passive recording) hoặc chỉ đạt độ chính xác cao trong môi trường lý tưởng (chụp trực diện, đủ sáng, khoảng cách gần).

                      +-----------------------------+
                      |   RTSP Video Stream (CCTV)  |
                      +--------------+--------------+
                                     |
                                     v
                      +-----------------------------+
                      | Face Detection (YOLOv8-Face)|
                      +--------------+--------------+
                                     |
                                     v
                      +-----------------------------+
                      |  Face Alignment (5 Points)  |
                      +--------------+--------------+
                                     |
                                     v
                      +-----------------------------+
                      | Feature Extraction (AdaFace)|
                      +--------------+--------------+
                                     |
                                     v
                      +-----------------------------+
                      | Vector Search (Faiss Index) |
                      +--------------+--------------+
                                     |
                 +-------------------+-------------------+
                 |                                       |
                 v (Match ID / Known)                    v (Unknown / Intruder)
    +--------------------------+            +--------------------------+
    | Auto Door Unlock Trigger |            | Intrusion Alert System   |
    | (GPIO/Relay Signal)      |            | (WebSocket/Telegram API) |
    +--------------------------+            +--------------------------+

Vấn đề kỹ thuật cụ thể (Problem Statement)

Khi áp dụng các mô hình học sâu (Deep Learning) vào hệ thống camera an ninh thực tế, độ chính xác sụt giảm nghiêm trọng do các rào cản kỹ thuật đặc thù:

  • Độ phân giải cực thấp (Low Resolution): Khuôn mặt trong khung hình giám sát thường có kích thước rất nhỏ (từ $16 \times 16$ pixel đến $32 \times 32$ pixel) do khoảng cách lắp đặt camera xa mục tiêu.
  • Hiện tượng mờ do chuyển động (Motion Blur): Đối tượng liên tục di chuyển khiến chi tiết nhận dạng bị biến dạng.
  • Biến đổi góc nhìn và che khuất (Pose Variation & Occlusion): Góc quay từ trên cao (pitch angle) cùng với khẩu trang, mũ hoặc góc nghiêng khuôn mặt làm mất các đặc trưng hình học cơ bản.
  • Ánh sáng phức tạp (Illumination Shifts): Chênh lệch lớn giữa môi trường ngược sáng ban ngày và thiếu sáng ban đêm.

Mục tiêu dự án

  1. Nghiên cứu toàn diện các kiến trúc Deep Learning hiện đại cho hai giai đoạn cốt lõi: Phát hiện khuôn mặt (Face Detection) và Nhận dạng khuôn mặt (Face Recognition).
  2. Huấn luyện và đánh giá thực nghiệm các mô hình tiên tiến (MTCNN, RetinaFace, YOLOv8 cho Detection; ArcFace, AdaFace cho Recognition) trên các tập dữ liệu chuẩn mực và tập dữ liệu camera an ninh thực tế.
  3. Tích hợp giải pháp tìm kiếm vector đặc trưng tốc độ cao phục vụ bài toán 1:N (Face Identification) với thư viện Faiss.
  4. Xây dựng ứng dụng web hoàn chỉnh kết nối camera an ninh thời gian thực (Real-time RTSP Stream), hỗ trợ tự động mở khóa cửa khi nhận diện người hợp lệ và kích hoạt cảnh báo xâm nhập khi phát hiện đối tượng lạ.

Hướng tiếp cận và cơ sở lựa chọn giải pháp

Hệ thống áp dụng kiến trúc pipeline hai giai đoạn phân tách rõ rệt:

  • Face Detection: Lựa chọn YOLOv8-face nhờ cơ chế One-Stage Detector không neo (Anchor-free), tối ưu hóa kiến trúc Backbone C2f kết hợp FPN/PAN Neck, cho phép bắt khuôn mặt đa tỷ lệ với tốc độ frame cao.
  • Face Recognition: Sử dụng AdaFace (Adaptive Margin Loss) thay vì ArcFace truyền thống. AdaFace điều chỉnh margin thích ứng dựa trên chuẩn vector đặc trưng $|z_i|$, giúp mô hình phân bổ trọng số phù hợp cho ảnh chất lượng kém từ camera an ninh mà không làm phân kỳ quá trình học.
  • Vector Matching: Ứng dụng Faiss (Facebook AI Similarity Search) để tối ưu hóa việc so khớp độ tương đồng Cosine (Cosine Similarity) cho không gian 512 chiều.

Kết quả kỳ vọng và chỉ số đo lường

  • Tỷ lệ phát hiện mAP@0.5 cho Face Detection đạt trên 95% trên tập kiểm thử WiderFace.
  • Độ chính xác nhận dạng nhận diện khuôn mặt kích thước nhỏ đạt trên 80% trên tập TinyFace.
  • Thời gian trễ xử lý toàn chu trình (End-to-End Latency) dưới 200ms/frame, đảm bảo khả năng xử lý Real-time từ 15 - 25 FPS trên GPU thông dụng.

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

  • Hệ thống tập trung xử lý luồng video IP Camera chuẩn giao thức RTSP độ phân giải 1080p.
  • Bộ dữ liệu thực nghiệm gồm các tập mở rộng (WiderFace, TinyFace, LFW) kết hợp tập dữ liệu 300 ảnh tự thu thập từ camera giám sát thực tế tại Trường ĐH Công nghệ Thông tin - ĐHQG TP.HCM.
  • Không tập trung vào bài toán nhận diện qua vật liệu ngụy trang chuyên dụng mức độ cao (Silicon Mask Anti-spoofing).

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

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

Hiện nay, các giải pháp nhận diện khuôn mặt thương mại và mã nguồn mở phân hóa thành hai nhóm chính với các ưu nhược điểm sau:

Giải pháp Công nghệ cốt lõi Ưu điểm Nhược điểm
Hệ thống truyền thống (Haar-Cascade + LBPH / SVM) Xử lý ảnh cổ điển, Local Binary Patterns Tiêu tốn cực ít tài nguyên, chạy được trên MCU/Raspberry Pi Tỷ lệ nhận diện sai rất cao khi góc quay nghiêng, ánh sáng yếu hoặc ảnh mờ ($Acc < 60%$)
Deep Learning thế hệ 1 (MTCNN + FaceNet/Triplet Loss) Multi-task CNN 3 giai đoạn (P-Net, R-Net, O-Net) Khá chính xác trên ảnh trực diện chất lượng cao Tốc độ chậm (cascaded pipeline), suy giảm độ chính xác nghiêm trọng trên khuôn mặt $< 32\times32$ px
Deep Learning tối ưu (YOLOv8-Face + AdaFace - Đề xuất) Anchor-free CNN + Adaptive Margin Loss + Faiss Độ chính xác vượt trội trên ảnh chất lượng thấp, tối ưu xử lý thời gian thực Yêu cầu tài nguyên GPU để duy trì FPS cao khi đồng thời xử lý nhiều luồng camera

Phân loại yêu cầu người dùng theo mô hình MoSCoW

  • Must have (Bắt buộc): Phát hiện khuôn mặt thời gian thực; Trích xuất vector đặc trưng 512D; So khớp danh tính trong cơ sở dữ liệu; Điều khiển tín hiệu mở cửa; Ghi log lịch sử nhận diện.
  • Should have (Nên có): Cảnh báo tức thời qua giao diện web/Telegram khi có người lạ lảng vãng (Strangers/Intruders); Bộ lọc giảm nhiễu khung hình (Motion Deblur Preprocessing).
  • Could have (Có thể có): Giao diện quản lý phân quyền thành viên theo phòng ban; Đăng ký khuôn mặt tự động qua camera.
  • Won't have (Chưa hỗ trợ): Nhận diện khuôn mặt 3D bằng cảm biến Structured Light chuyên dụng.

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

+-----------------------------------------------------------------------------------+
|                                 CLIENT TIER                                       |
|  +-------------------------------------+  +------------------------------------+  |
|  | Web Browser (React/Dashboard View)  |  | Push Notification (Telegram/Socket)|  |
|  +-------------------------------------+  +------------------------------------+  |
+------------------------------------------^----------------------------------------+
                                           | HTTP / WebSocket
+------------------------------------------v----------------------------------------+
|                            APPLICATION & LOGIC TIER                               |
|  +-----------------------------------------------------------------------------+  |
|  | FastAPI Backend Controller (Routing, Auth, Door Relay Command, Log Service) |  |
|  +-----------------------------------------------------------------------------+  |
|                                          | Inter-process Memory Transfer          |
|  +---------------------------------------v-------------------------------------+  |
|  | AI Inference Engine                                                         |  |
|  |   - Stream Ingestion: OpenCV VideoCapture (RTSP Buffer Control)             |  |
|  |   - Stage 1: YOLOv8-Face Detection (Anchor-Free Pyramidal Inference)        |  |
|  |   - Stage 2: 5-Point Affine Transformation & Alignment                      |  |
|  |   - Stage 3: AdaFace Feature Extractor (ResNet-50 Backbone -> 512D Float32) |  |
|  |   - Stage 4: Faiss Vector Index (FlatIP / Cosine Metric Search)             |  |
|  +-----------------------------------------------------------------------------+  |
+------------------------------------------^----------------------------------------+
                                           | Database Query / Sync
+------------------------------------------v----------------------------------------+
|                                  DATA TIER                                        |
|  +-------------------------------------+  +------------------------------------+  |
|  | PostgreSQL (User Meta, Access Logs) |  | Vector Gallery (Faiss Binary Index)|  |
|  +-------------------------------------+  +------------------------------------+  |
+-----------------------------------------------------------------------------------+

Chi tiết Technology Stack

  • Ngôn ngữ lập trình: Python 3.10
  • Deep Learning Framework: PyTorch 2.0.1 + CUDA 11.8
  • Vision & Detection: Ultralytics YOLOv8 (v8.0.196), OpenCV 4.8.0
  • Face Feature Extraction: AdaFace (ResNet-50 Pretrained on WebFace4M)
  • Vector Search Engine: Faiss-cpu / Faiss-gpu 1.7.4
  • Backend API & Web Server: FastAPI 0.100.0, Uvicorn, WebSockets
  • Cơ sở dữ liệu: PostgreSQL 15 (Metadata & Events), File System (Face Crop Archives)

Thiết kế Database Schema

-- Bảng quản lý người dùng được cấp phép
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    full_name VARCHAR(100) NOT NULL,
    employee_code VARCHAR(20) UNIQUE NOT NULL,
    department VARCHAR(50),
    is_active BOOLEAN DEFAULT TRUE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Bảng lưu trữ vector đặc trưng khuôn mặt (512 chiều)
CREATE TABLE face_embeddings (
    id SERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id) ON DELETE CASCADE,
    embedding_vector BYTEA NOT NULL, -- Serialized float32[512]
    image_path VARCHAR(255),
    quality_score FLOAT,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Bảng ghi nhận nhật ký ra vào và cảnh báo an ninh
CREATE TABLE access_logs (
    id BIGSERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id) ON DELETE SET NULL,
    event_type VARCHAR(20) NOT NULL, -- 'AUTHORIZED_ACCESS', 'UNKNOWN_INTRUSION'
    similarity_score FLOAT,
    captured_image_path VARCHAR(255),
    camera_id VARCHAR(50) NOT NULL,
    door_status VARCHAR(20), -- 'UNLOCKED', 'LOCKED'
    timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

Thiết kế RESTful & WebSocket API

Endpoint Method / Protocol Mô tả chức năng Request / Response Payload
/api/v1/faces/register POST (Multipart) Đăng ký khuôn mặt mới vào Faiss Gallery user_id, image_file $\rightarrow$ {status: "SUCCESS", embedding_id: 12}
/api/v1/faces/verify POST So khớp 1:1 hoặc 1:N từ ảnh đơn {image_base64: "..."} $\rightarrow$ {user_id: 1, name: "Hoang", score: 0.86}
/api/v1/camera/live-feed WebSocket Stream video bounding box & kết quả nhận diện Binary MJPEG Frame + JSON Metadata
/api/v1/door/control POST Gửi xung kích hoạt Relay mở khóa cửa {door_id: "D1", action: "OPEN", duration_sec: 5}

Implementation và kết quả

Chi tiết các thuật toán cốt lõi

1. Thuật toán phát hiện khuôn mặt với YOLOv8-Face

Khác với MTCNN phải qua 3 mạng độc lập (P-Net $12\times12$, R-Net $24\times24$, O-Net $48\times48$), YOLOv8-Face sử dụng cấu trúc Single-shot Anchor-free. Mô hình phân tách đầu ra thành hai nhánh riêng biệt: Classification Head và Regression Head (dự đoán trực tiếp khoảng cách từ tâm cell tới 4 cạnh của Bounding Box và 5 điểm Landmark).

Hàm mất mát bounding box sử dụng kết hợp Task-Aligned Assigner cùng CIoU (Complete Intersection over Union) và DFL (Distribution Focal Loss):

$$\mathcal{L}{det} = \lambda_1 \mathcal{L}{cls} + \lambda_2 \mathcal{L}{CIoU} + \lambda_3 \mathcal{L}{DFL}$$

2. Hàm mất mát AdaFace (Adaptive Margin Loss)

AdaFace giải quyết triệt để vấn đề của ArcFace khi xử lý ảnh chất lượng thấp. Trong ArcFace, hàm mất mát gán một giá trị margin góc cố định $m$:

$$\mathcal{L}{ArcFace} = -\log \frac{e^{s \cdot \cos(\theta{y_i} + m)}}{e^{s \cdot \cos(\theta_{y_i} + m)} + \sum_{j \neq y_i} e^{s \cdot \cos\theta_j}}$$

Khi gặp ảnh mờ hoặc quá nhỏ, việc áp đặt margin cố định khiến mô hình cố gắng ép các đặc trưng không rõ ràng vào không gian phân tách quá hẹp, dẫn đến bùng nổ gradient. AdaFace sử dụng chuẩn của vector đặc trưng $|z_i|$ làm đại diện cho chất lượng hình ảnh (Image Quality Indicator), tự động điều chỉnh hàm margin $g_{angle}$ và $g_{add}$:

$$\mathcal{L}{AdaFace} = -\log \frac{e^{s \cdot \cos(\theta{y_i} + g_{angle}(|z_i|)) - g_{add}(|z_i|)}}{e^{s \cdot \cos(\theta_{y_i} + g_{angle}(|z_i|)) - g_{add}(|z_i|)} + \sum_{j \neq y_i} e^{s \cdot \cos\theta_j}}$$

Trong đó: $$g_{angle}(|z_i|) = -\hat{z}i \cdot m, \quad g{add}(|z_i|) = \hat{z}_i \cdot m + m_0$$ Với $\hat{z}_i$ là giá trị $|z_i|$ đã được chuẩn hóa qua Batch Normalization cắt ngưỡng $[-1, 1]$.

3. Triển khai trích xuất và so khớp vector đặc trưng (Inference Pipeline)

import cv2
import numpy as np
import torch
import faiss
from ultralytics import YOLO

class SecurityFaceRecognitionPipeline:
    def __init__(self, yolo_weights: str, adaface_model_path: str, gallery_dim: int = 512):
        # Khởi tạo mô hình YOLOv8-Face
        self.detector = YOLO(yolo_weights)
        
        # Khởi tạo mô hình AdaFace (ResNet-50)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.recognizer = torch.load(adaface_model_path, map_location=self.device)
        self.recognizer.eval()
        
        # Khởi tạo chỉ mục Faiss (IndexFlatIP tương ứng Cosine Similarity khi vector chuẩn hóa L2)
        self.index = faiss.IndexFlatIP(gallery_dim)
        self.user_mapping = {}

    def extract_embedding(self, face_chip: np.ndarray) -> np.ndarray:
        """Tiền xử lý ảnh khuôn mặt 112x112 và trích xuất vector đặc trưng 512D"""
        img = cv2.resize(face_chip, (112, 112))
        img = ((img / 255.0) - 0.5) / 0.5  # Chuẩn hóa [-1, 1]
        img = np.transpose(img, (2, 0, 1)).astype(np.float32)
        tensor = torch.from_numpy(img).unsqueeze(0).to(self.device)
        
        with torch.no_grad():
            embedding, norm = self.recognizer(tensor)
            embedding_np = embedding.cpu().numpy().flatten()
            # Chuẩn hóa L2 cho cosine metric
            embedding_np /= np.linalg.norm(embedding_np)
        return embedding_np

    def process_frame(self, frame: np.ndarray, similarity_thresh: float = 0.65):
        """Pipeline xử lý từng khung hình video: Detect -> Extract -> Search -> Trigger"""
        results = self.detector(frame, verbose=False)[0]
        detected_events = []
        
        for box in results.boxes:
            x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
            conf = float(box.conf[0])
            if conf < 0.5:
                continue
            
            # Cắt bounding box khuôn mặt an toàn
            h, w, _ = frame.shape
            face_chip = frame[max(0, y1):min(h, y2), max(0, x1):min(w, x2)]
            if face_chip.size == 0 or face_chip.shape[0] < 16 or face_chip.shape[1] < 16:
                continue
                
            # Trích xuất vector AdaFace
            emb = self.extract_embedding(face_chip)
            
            # So khớp trong Faiss Gallery
            query = np.expand_dims(emb, axis=0)
            scores, indices = self.index.search(query, k=1)
            
            best_score = scores[0][0]
            best_idx = indices[0][0]
            
            if best_score >= similarity_thresh and best_idx in self.user_mapping:
                user_info = self.user_mapping[best_idx]
                status = "AUTHORIZED"
            else:
                user_info = {"id": "UNKNOWN", "name": "Stranger"}
                status = "INTRUDER"
                
            detected_events.append({
                "bbox": (x1, y1, x2, y2),
                "status": status,
                "user": user_info,
                "score": float(best_score)
            })
            
        return detected_events

Kết quả thực nghiệm và đánh giá định lượng

1. Đánh giá giai đoạn Face Detection trên tập WiderFace

Thực nghiệm so sánh trên 3 mô hình đại diện: MTCNN, RetinaFace và YOLOv8.

Mô hình Input Size mAP@0.5 Easy (%) mAP@0.5 Medium (%) mAP@0.5 Hard (Small faces) (%) Tốc độ xử lý (FPS / GPU T4)
MTCNN Pyramid 85.10 82.30 62.30 18.2
RetinaFace (ResNet-50) $640 \times 640$ 95.30 93.80 82.50 24.5
YOLOv8-Face (Đề xuất) $640 \times 640$ 98.49 96.20 89.10 45.8

Nhận xét: YOLOv8 vượt trội hoàn toàn về mAP tổng thể (98.49% trên Easy subset) và duy trì khả năng bắt các khuôn mặt kích thước nhỏ/bị che khuất (Hard subset) ở mức 89.10%, đồng thời đạt tốc độ xử lý 45.8 FPS, đáp ứng hoàn hảo yêu cầu thời gian thực.

2. Đánh giá giai đoạn Face Recognition trên tập TinyFace và Dữ liệu tự xây dựng

Mô hình Hàm mất mát (Loss) Độ chính xác LFW (HQ) (%) Độ chính xác TinyFace (LQ) (%) Độ chính xác CCTV Dataset (300 ảnh) (%) Thời gian Embedding (ms/chip)
ArcFace Additive Angular Margin 99.53 72.40 76.20 122 ms
AdaFace (Đề xuất) Adaptive Margin 99.65 81.80 84.50 180 ms

Nhận xét: Trên tập dữ liệu khuôn mặt chất lượng thấp (TinyFace), AdaFace cải thiện độ chính xác tới +9.4% so với ArcFace. Trên tập dữ liệu camera an ninh thực tế thu thập từ khuôn viên trường, AdaFace đạt độ chính xác 84.50%. Dù thời gian tạo embedding chậm hơn 58ms do các phép toán tính chuẩn thích ứng, tốc độ này vẫn nằm trong ngưỡng trễ cho phép ($<200$ms) của toàn hệ thống.

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

Các điểm cải tiến kỹ thuật nổi bật

  1. Pipeline lai tối ưu cho ảnh camera độ phân giải thấp: Khắc phục triệt để hạn chế của các giải pháp truyền thống khi tích hợp YOLOv8 (Anchor-free detection) và AdaFace (Quality-adaptive margin), giúp hệ thống hoạt động ổn định ở khoảng cách quan sát từ 3 - 7 mét.
  2. Cơ chế lập chỉ mục và tìm kiếm vector Faiss cận thời gian thực: Giảm độ phức tạp thời gian tìm kiếm từ $\mathcal{O}(N \times D)$ xuống mức cận $\mathcal{O}(1)$ khi sử dụng Faiss IndexIVFFlat kết hợp chuẩn hóa $L_2$, cho phép hệ thống tra cứu cơ sở dữ liệu hàng chục nghìn nhân viên trong thời gian $< 5$ms.
  3. Cơ chế điều khiển và cảnh báo đa luồng (Asynchronous Multi-threading): Tách biệt luồng đọc camera (I/O Bound), luồng suy luận mô hình AI (GPU Bound) và luồng xử lý WebSocket/Relay mở cửa (Network Bound), loại bỏ hoàn toàn hiện tượng nghẽn bộ đệm hình ảnh (Frame Buffer Lag).
                      SO SÁNH ĐỘ CHÍNH XÁC TRÊN ẢNH CHẤT LƯỢNG THẤP (TINYFACE)
   100 % +
         |
    80 % +                                                    [ 81.80% ]
         |                                                    +--------+
    60 % +                         [ 72.40% ]                 |        |
         |                         +--------+                 |        |
    40 % +                         |        |                 |        |
         |                         |        |                 |        |
    20 % +                         |        |                 |        |
         +-------------------------+--------+-----------------+--------+
                                    ArcFace                    AdaFace

Đóng góp thực tiễn cho cộng đồng và ngành

  • Đóng góp bộ dữ liệu gồm 300 ảnh khuôn mặt chụp từ các góc quay và điều kiện ánh sáng thực tế của camera giám sát trường học, có gán nhãn Bounding Box và Identity chi tiết.
  • Cung cấp kiến trúc tham chiếu hoàn chỉnh từ lý thuyết Deep Learning đến sản phẩm phần mềm có khả năng ứng dụng trực tiếp tại các tòa nhà, văn phòng và khu dân cư thông minh.

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

Các kịch bản sử dụng trong đời sống

           +-------------------------------------------------------------+
           |                 CCTV Security Camera Stream                 |
           +------------------------------+------------------------------+
                                          |
                        +-----------------+-----------------+
                        |                                   |
                        v                                   v
          [ Kịch bản 1: Mở cửa tự động ]      [ Kịch bản 2: Cảnh báo xâm nhập ]
          - Nhân viên đi vào vùng nhận diện   - Người lạ xuất hiện ngoài giờ
          - Khớp danh tính (Score >= 0.65)    - Score < 0.65 hoặc Blacklist
          - Gửi xung kích hoạt khóa Relay     - Chụp snapshot khuôn mặt
          - Ghi log ra vào hệ thống           - Bắn cảnh báo Telegram/Web UI
  1. Kiểm soát ra vào thông minh (Access Control & Smart Door Lock): Khi nhân viên hoặc cư dân bước vào vùng quét của camera, hệ thống phát hiện và xác thực danh tính tức thì. Ngay khi độ tương đồng $\ge 0.65$, bộ điều khiển gửi tín hiệu đóng ngắt Relay để mở khóa từ tử, loại bỏ hoàn toàn nhu cầu dùng thẻ từ hay vân tay.
  2. Cảnh báo an ninh và phòng chống xâm nhập (Intrusion Detection): Đối với các khu vực cấm hoặc ngoài giờ làm việc, nếu phát hiện khuôn mặt không tồn tại trong cơ sở dữ liệu (Unknown) hoặc thuộc danh sách đen (Blacklist), hệ thống tự động chụp ảnh vi phạm, lưu trữ tọa độ và phát thông báo khẩn cấp tới quản trị viên qua Web Dashboard và Bot Telegram.

Yêu cầu phần cứng và triển khai (System Requirements)

+-------------------+---------------------------------------------------------+
| Thành phần        | Cấu hình khuyến nghị (Production Server)                |
+-------------------+---------------------------------------------------------+
| Vi xử lý (CPU)    | Intel Core i7-11700 / AMD Ryzen 7 5800X (8 Cores/16 Th) |
| Card đồ họa (GPU) | NVIDIA GeForce RTX 3060 (12GB VRAM) hoặc chuyên dụng T4 |
| Bộ nhớ (RAM)      | 16GB DDR4 3200MHz                                       |
| Camera giám sát   | IP Camera 2.0 MP (1080p), hỗ trợ chuẩn ONVIF / RTSP     |
| Bộ điều khiển cửa | Module Relay 5V/12V kết nối qua ESP32 / Raspberry Pi GPIO|
+-------------------+---------------------------------------------------------+

Phân tích hiệu quả kinh tế (Cost-Benefit Analysis)

  • Tối ưu chi phí vận hành: Giảm thiểu chi phí in ấn thẻ từ (khoảng 30.000 - 50.000 VNĐ/thẻ) và bảo trì đầu đọc vân tay thường xuyên hỏng hóc do bụi bẩn, thời tiết.
  • Thời gian hoàn vốn (ROI): Doanh nghiệp quy mô 100 - 200 nhân sự có thể thu hồi vốn đầu tư hệ thống máy chủ và camera AI trong vòng 8 - 12 tháng thông qua việc tự động hóa chấm công và cắt giảm chi phí nhân sự bảo vệ gác cổng.

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

Các hạn chế kỹ thuật hiện tại

  • Phụ thuộc vào góc quay cực đoan: Khi khuôn mặt quay ngang quá lớn (Yaw angle $> 60^\circ$) hoặc cúi quá sâu, số lượng điểm mốc khuôn mặt trích xuất không đủ để căn chỉnh chính xác, dẫn đến giảm độ tin cậy của vector AdaFace.
  • Tài nguyên tính toán của AdaFace: Thời gian trích xuất đặc trưng (180ms) tương đối cao đối với các thiết bị biên phần cứng thấp (Edge Devices như Jetson Nano).
  • Hiện tượng giả mạo 2D: Phiên bản hiện tại chưa tích hợp mô hình phát hiện giả mạo khuôn mặt (Anti-spoofing) để chống lại việc sử dụng ảnh in hoặc màn hình điện thoại để đánh lừa camera.

Hướng nghiên cứu và phát triển tiếp theo

  1. Tích hợp mô hình Silent Face Anti-Spoofing (dựa trên cấu trúc MiniFASNet) để ngăn chặn tấn công giả mạo 2D Print/Replay Attack.
  2. Tối ưu hóa lượng tử hóa mô hình (Model Quantization INT8/FP16) bằng NVIDIA TensorRT, giúp giảm thời gian embedding của AdaFace từ 180ms xuống dưới 35ms trên GPU.
  3. Mở rộng cơ chế Tracking đa đối tượng (Multi-object Tracking) sử dụng ByteTrack để duy trì ID liên tục cho từng người trong khung hình, tránh việc phải chạy mô hình nhận diện liên tục ở mọi frame.

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

  • Sinh viên & Người học ngành Khoa học máy tính: Tài liệu tham khảo thực tế về cách kết hợp các kiến trúc State-of-the-Art (YOLOv8, AdaFace, Faiss) để giải quyết bài toán thị giác máy tính từ lý thuyết đến triển khai.
  • Kỹ sư AI & Lập trình viên: Cung cấp pattern thiết kế pipeline AI tối ưu đa luồng, cách giải quyết bài toán suy giảm độ chính xác trên dữ liệu ảnh chất lượng thấp và mã nguồn mẫu dễ tích hợp.
  • Doanh nghiệp & Đơn vị an ninh: Mô hình giải pháp chi phí thấp, tận dụng hệ thống camera giám sát có sẵn để nâng cấp thành hệ thống kiểm soát an ninh thông minh.
  • Nhà nghiên cứu: Bằng chứng thực nghiệm định lượng rõ ràng về sự vượt trội của Adaptive Loss (AdaFace) so với Fixed Angular Loss (ArcFace) trong môi trường giám sát thực tế.

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

1. Hệ thống yêu cầu cấu hình phần cứng tối thiểu như thế nào để triển khai?

Để hệ thống xử lý mượt mà luồng camera 1080p ở tốc độ 20 - 25 FPS, máy chủ cần trang bị tối thiểu CPU 4 nhân, 8GB RAM và một GPU NVIDIA có tối thiểu 4GB VRAM (như GTX 1650 hoặc GTX 1060). Nếu chỉ chạy trên CPU, hệ thống vẫn hoạt động nhưng tốc độ sẽ giảm xuống khoảng 3 - 5 FPS.

2. Làm thế nào để mở rộng hệ thống khi số lượng người dùng lên đến hàng trăm nghìn người?

Khi cơ sở dữ liệu đạt quy mô lớn, thư viện Faiss hỗ trợ cấu trúc chỉ mục IndexIVFPQ (Inverted File with Product Quantization). Cơ chế này nén vector đặc trưng và phân cụm không gian tìm kiếm, cho phép so khớp 1:N với hàng triệu người dùng trong thời gian dưới 10ms mà không làm tăng dung lượng RAM.

3. Hệ thống có thể tích hợp với các loại khóa cửa từ và cổng tự động hiện nay không?

Có. Backend FastAPI cung cấp các API webhook hoặc tín hiệu điều khiển trực tiếp qua cổng COM/Serial, GPIO (trên vi điều khiển ESP32/Raspberry Pi) để đóng ngắt mạch Relay kết nối trực tiếp với khóa từ (Magnetic Lock) hoặc cổng xoay Flap Barrier phổ biến trên thị trường.

4. Chi phí triển khai và bảo trì hệ thống ước tính là bao nhiêu?

Chi phí ban đầu chủ yếu bao gồm máy chủ GPU (khoảng 15 - 25 triệu VNĐ) và các module relay điều khiển (dưới 500.000 VNĐ), trong khi tận dụng được toàn bộ hạ tầng camera IP sẵn có. Chi phí bảo trì định kỳ rất thấp do hệ thống mã nguồn mở không mất phí bản quyền license hàng năm.

5. Hệ thống xử lý thế nào khi camera bị rung lắc hoặc đối tượng chuyển động nhanh gây mờ ảnh?

Nhờ cơ chế Adaptive Margin của AdaFace, mô hình tự động gán trọng số thấp cho các đặc trưng bị mờ không chắc chắn, giảm thiểu rủi ro nhận diện sai danh tính (False Positive). Đồng thời, hệ thống sử dụng thuật toán tích lũy điểm số qua nhiều frame liên tiếp trước khi ra quyết định mở cửa.

Kết luận

Đồ án tốt nghiệp "Xây dựng hệ thống nhận diện khuôn mặt cho camera an ninh hỗ trợ cảnh báo xâm nhập và mở khóa cửa tự động" đã giải quyết triệt để bài toán khó khăn của thị giác máy tính trong môi trường giám sát thực tế. Bằng việc kết hợp sáng tạo giữa mô hình phát hiện YOLOv8-Face (đạt mAP 98.49%) và mô hình nhận diện AdaFace (đạt độ chính xác 81.8% trên dữ liệu khuôn mặt chất lượng thấp), hệ thống đã chứng minh tính khả thi, hiệu năng vượt trội và độ ổn định cao.

Giải pháp không chỉ đóng góp tài liệu nghiên cứu sâu sắc cho cộng đồng học thuật mà còn sẵn sàng ứng dụng thực tế vào các bài toán chuyển đổi số, xây dựng tòa nhà thông minh và bảo vệ an ninh công cộng. Việc tiếp tục tối ưu hóa TensorRT và tích hợp cơ chế chống giả mạo sẽ là bước hoàn thiện cuối cùng để thương mại hóa toàn diện sản phẩm trong tương lai.