Giới thiệu dự án

Sự bùng nổ của hạ tầng đô thị thông minh và nhu cầu đảm bảo an ninh trật tự đã thúc đẩy việc triển khai mạng lưới camera giám sát (CCTV - Closed-Circuit Television) trên diện rộng. Tại các đô thị lớn như TP. Hồ Chí Minh, hệ thống camera giám sát công cộng đã được đồng bộ hóa với hơn 762 mắt camera độ phân giải cao kết nối trực tiếp về trung tâm chỉ huy, cùng hàng chục nghìn camera an ninh xã hội hóa tại các khu dân cư. Mạng lưới này tạo ra hàng chục terabyte dữ liệu video mỗi ngày, đặt ra bài toán cấp thiết về năng lực khai thác và truy vết thông tin.

+-----------------------------------------------------------------------------------+
|                              BÀI TOÁN THỰC TIỄN                                   |
|  - Dữ liệu camera giám sát: >10 TB video/ngày phát sinh liên tục                  |
|  - Phương pháp truyền thống: 100% rà soát thủ công (Manual Review)                |
|  - Thách thức: Tốn 4-8 giờ cho 24h video; Tỉ lệ bỏ sót mục tiêu: 35-40%          |
|  - Giải pháp đề xuất: Hệ thống trích xuất Metadata 1 lần & Truy vấn đa phương thức|
+-----------------------------------------------------------------------------------+

Thực tế điều tra và xử lý sự cố cho thấy hơn 90% dữ liệu camera giám sát chỉ được sử dụng ở chế độ ngoại tuyến (offline forensic investigation) sau khi sự việc đã xảy ra (ví dụ: truy tìm đối tượng bắt cóc trẻ em, truy vết phương tiện gây tai nạn bỏ chạy). Tuy nhiên, quy trình giám sát truyền thống bộc lộ những điểm nghẽn nghiêm trọng:

  • Quá tải nhận thức con người: Nhân viên giám sát phải tua lại hàng trăm giờ video để tìm kiếm một đối tượng khả nghi, dẫn đến tình trạng mệt mỏi thị giác và tỷ lệ bỏ sót mục tiêu lên tới 35-40%.
  • Lặp lại tính toán lãng phí: Mỗi lượt tìm kiếm mới lại yêu cầu quét lại toàn bộ luồng video từ đầu, gây tiêu tốn tài nguyên xử lý và không đáp ứng được yêu cầu phá án khẩn cấp.

Đề tài "Ứng dụng nhận diện đối tượng để tìm kiếm đối tượng trong dữ liệu camera giám sát" được nghiên cứu và phát triển nhằm giải quyết triệt để vấn đề này. Mục tiêu cụ thể của dự án bao gồm:

  1. Xây dựng bộ dữ liệu hình ảnh camera giám sát thực tế tại Việt Nam (CameraVN) với 6 lớp đối tượng giao thông và an ninh được gán nhãn chuẩn hóa.
  2. Nghiên cứu, huấn luyện và tối ưu hóa hai kiến trúc nhận diện vật thể hiện đại là YOLOv4 và EfficientDet trên tập dữ liệu giám sát.
  3. Phát triển hệ thống trích xuất siêu dữ liệu (Metadata Extraction Pipeline) tích hợp các bộ trích xuất thuộc tính phụ: nhận diện màu sắc bằng thuật toán phân cụm K-means, phát hiện khuôn mặt bằng TinaFace / Cascade CNN và xác thực khuôn mặt bằng ArcFace / FaceNet.
  4. Thiết kế cơ chế tìm kiếm đa phương thức (Multi-modal Query Engine) trên cơ sở dữ liệu metadata, hỗ trợ tìm kiếm theo lớp đối tượng, màu sắc đặc trưng, ảnh mẫu (Template Matching) và đặc trưng khuôn mặt.
  5. Xây dựng ứng dụng hoàn chỉnh với giao diện đồ họa (Desktop GUI) hỗ trợ điều tra viên thao tác trực quan, truy xuất kết quả tức thì.

Giải pháp cốt lõi của đề tài là kiến trúc Trích xuất Metadata một lần - Truy vấn nhiều lần (Extract Once, Query Anywhere). Toàn bộ video giám sát được xử lý offline qua mạng nơ-ron tích chập (CNN - Convolutional Neural Network) để chuyển đổi luồng video phi cấu trúc thành cơ sở dữ liệu metadata có cấu trúc (tọa độ bounding box, vector đặc trưng 512 chiều của khuôn mặt, mã màu chủ đạo). Nhờ đó, thời gian tìm kiếm một đối tượng trong 24 giờ video giảm từ hàng giờ xuống dưới 100 mili-giây.

Phạm vi và giới hạn: Hệ thống tập trung xử lý dữ liệu video camera giám sát giao thông và an ninh khu vực; hỗ trợ nhận diện 6 lớp đối tượng chính: Người (Person), Xe máy (Motorbike), Xe đạp (Bicycle), Xe buýt (Bus), Xe tải (Truck), Ô tô con (Car); phân tích khuôn mặt đối với các khung hình có độ phân giải khuôn mặt tối thiểu $24 \times 24$ pixels.

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

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

Quá trình điều tra dữ liệu camera hiện nay chủ yếu dựa vào rà soát thủ công hoặc một số phần mềm thương mại đắt đỏ. Bảng so sánh dưới đây làm rõ ưu và nhược điểm của các hướng tiếp cận:

Tiêu chí Rà soát thủ công (Manual) AI xử lý luồng trực tiếp (Full-stream Inference) Hệ thống Metadata Indexing (Đề xuất)
Thời gian truy vết 4 - 8 giờ / 24h video 15 - 30 phút (chạy lại toàn bộ AI) < 100 mili-giây (trên Metadata)
Độ chính xác Phụ thuộc sự tập trung ($< 65%$) Cao ($80 - 90%$) Cao ($85 - 92%$)
Chi phí phần cứng khi truy vấn Không yêu cầu GPU Yêu cầu cụm GPU tính toán nặng Chỉ cần CPU thông thường
Khả năng mở rộng Kém (tăng nhân sự tuyến tính) Trung bình (nghẽn cổ chai GPU) Xuất sắc (phân tán CSDL)
Tìm kiếm kết hợp Khó định lượng thuộc tính Tùy biến phức tạp Linh hoạt (Lớp + Màu + Mặt + Mẫu)

Hệ thống được thiết kế đáp ứng các yêu cầu người dùng theo mô hình MoSCoW:

  • Must-have (Bắt buộc): Nhận diện chính xác 6 lớp đối tượng cơ bản; trích xuất bounding box và độ tự tin (Confidence Score); trích xuất màu sắc chủ đạo; giao diện tìm kiếm theo lớp và mã màu.
  • Should-have (Nên có): Nhận diện khuôn mặt người bằng ArcFace; tìm kiếm đối tượng bằng ảnh mẫu (Template Matching) có chuẩn hóa đa góc xoay.
  • Could-have (Có thể có): Tìm kiếm đồng thời kết hợp khuôn mặt và màu sắc trang phục; xuất danh sách các frame video có mốc thời gian (Timestamp) chính xác.
  • Won't-have (Tạm thời chưa có): Theo dõi liên tục đa camera theo thời gian thực (Multi-camera Real-time Tracking - dành cho giai đoạn tiếp theo).

Thiết kế hệ thống

Kiến trúc tổng thể của hệ thống được chia tách thành hai module độc lập, giao tiếp thông qua hệ thống lưu trữ siêu dữ liệu (Metadata Storage):

graph TD
    subgraph Module 1: Offline Metadata Extraction Pipeline
        A[Video Camera Giám Sát] --> B[Frame Extraction Module]
        B --> C[Object Detector: YOLOv4 / EfficientDet]
        C --> D{Phân loại đối tượng}
        D -- Phương tiện / Người --> E[K-means Color Extractor]
        D -- Đối tượng Người --> F[TinaFace / Face Detector]
        F --> G[ArcFace 512D Embedding]
        E --> H[(Metadata Database SQLite / Binary Index)]
        G --> H
        C -->|Bounding Box + Class + Conf| H
    end

    subgraph Module 2: Multi-Modal Query & Retrieval Engine
        I[Truy vấn từ Người dùng GUI] --> J{Loại truy vấn}
        J -- Lớp & Màu sắc --> K[Attribute Matcher SQL Query]
        J -- Ảnh mẫu Object --> L[Normalized Template Matcher]
        J -- Ảnh khuôn mặt --> M[Cosine Similarity Search Engine]
        K --> N[Frame Retrieval & Video Player]
        L --> N
        M --> N
        H -.-> K
        H -.-> M
    end

Technology Stack và Phiên bản chi tiết

  • Ngôn ngữ lập trình: Python 3.8.10 (xử lý logic, API), C++ (tối ưu nhân Darknet).
  • Deep Learning Frameworks: PyTorch 1.8.1 + CUDA 11.1, cuDNN 8.0.5, Darknet Framework.
  • Thị giác máy tính & Xử lý ảnh: OpenCV 4.5.2 (trích xuất frame, Template Matching, chuẩn hóa không gian màu).
  • Học máy & Phân tích số liệu: Scikit-learn 0.24.2 (thuật toán K-means), NumPy 1.19.5.
  • Giao diện người dùng (GUI): PyQt5 5.15.4 (xây dựng Desktop Application đa luồng).
  • Cơ sở dữ liệu: SQLite 3.35.4 kết hợp cấu trúc lưu trữ mảng nhị phân phẳng (Flat Binary Vector Files) cho Face Embeddings.

Thiết kế CSDL Metadata

CREATE TABLE IF NOT EXISTS Videos (
    video_id INTEGER PRIMARY KEY AUTOINCREMENT,
    file_path TEXT NOT NULL,
    total_frames INTEGER,
    fps REAL,
    resolution TEXT,
    processed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS DetectedObjects (
    object_id INTEGER PRIMARY KEY AUTOINCREMENT,
    video_id INTEGER,
    frame_index INTEGER NOT NULL,
    timestamp_ms REAL NOT NULL,
    class_id INTEGER NOT NULL, -- 0: Person, 1: Motorbike, 2: Car, 3: Bus, 4: Truck, 5: Bicycle
    confidence REAL NOT NULL,
    bbox_x INTEGER, bbox_y INTEGER, bbox_w INTEGER, bbox_h INTEGER,
    dominant_color_hex TEXT,
    face_embedding BLOB, -- 512-dimensional float32 vector (2048 bytes)
    FOREIGN KEY(video_id) REFERENCES Videos(video_id)
);
CREATE INDEX idx_search ON DetectedObjects(class_id, dominant_color_hex);

Phương pháp nghiên cứu và phát triển

Dự án áp dụng mô hình phát triển Agile/Scrum tinh gọn với chu kỳ 16 tuần, chia làm 4 chặng:

  1. Tuần 1 - 4: Thu thập dữ liệu camera giao thông TP.HCM, làm sạch và gán nhãn 5.000+ ảnh theo chuẩn YOLO/Pascal VOC format.
  2. Tuần 5 - 9: Huấn luyện và tinh chỉnh (Fine-tuning) YOLOv4 và họ mô hình EfficientDet; khảo sát siêu tham số, tối ưu hàm mất mát CIoU.
  3. Tuần 10 - 13: Hiện thực hóa module trích xuất màu K-means, module nhận diện khuôn mặt TinaFace + ArcFace, và bộ so khớp Template Matching.
  4. Tuần 14 - 16: Ghép nối hệ thống, tối ưu hóa đa luồng xử lý trên PyQt5, kiểm thử UAT và hoàn thiện tài liệu kỹ thuật.

Implementation và kết quả

Chi tiết thuật toán và cài đặt kỹ thuật

1. Mô hình Nhận diện Đối tượng: YOLOv4 và Tối ưu hóa CIoU Loss

YOLOv4 sử dụng backbone CSPDarknet53, cổ mạng PANet (Path Aggregation Network) và đầu mạng YOLOv3 Head. Để giải quyết bài toán định vị bounding box chính xác trong điều kiện góc nghiêng camera giám sát, mô hình sử dụng hàm mất mát Complete IoU (CIoU) Loss:

$$\mathcal{L}_{CIoU} = 1 - IoU + \frac{\rho^2(b, b^{gt})}{c^2} + \alpha v$$

Trong đó:

  • $IoU = \frac{|B \cap B^{gt}|}{|B \cup B^{gt}|}$ là chỉ số Intersection over Union giữa hộp dự đoán $b$ và ground truth $b^{gt}$.
  • $\rho(b, b^{gt})$ là khoảng cách Euclidean giữa hai tâm của hộp.
  • $c$ là độ dài đường chéo của hình chữ nhật nhỏ nhất bao quanh cả hai hộp.
  • $v = \frac{4}{\pi^2} \left( \arctan \frac{w^{gt}}{h^{gt}} - \arctan \frac{w}{h} \right)^2$ đo lường sự nhất quán về tỷ lệ khung hình, và $\alpha = \frac{v}{(1 - IoU) + v}$.
import torch
import math

def calculate_ciou_loss(pred_boxes, target_boxes):
    """
    pred_boxes, target_boxes: Tensor shape (N, 4) -> [x1, y1, x2, y2]
    """
    # Tọa độ giao nhau (Intersection)
    x1 = torch.max(pred_boxes[:, 0], target_boxes[:, 0])
    y1 = torch.max(pred_boxes[:, 1], target_boxes[:, 1])
    x2 = torch.min(pred_boxes[:, 2], target_boxes[:, 2])
    y2 = torch.min(pred_boxes[:, 3], target_boxes[:, 3])
    
    intersection = torch.clamp(x2 - x1, min=0) * torch.clamp(y2 - y1, min=0)
    
    # Diện tích từng hộp
    area_pred = (pred_boxes[:, 2] - pred_boxes[:, 0]) * (pred_boxes[:, 3] - pred_boxes[:, 1])
    area_target = (target_boxes[:, 2] - target_boxes[:, 0]) * (target_boxes[:, 3] - target_boxes[:, 1])
    union = area_pred + area_target - intersection + 1e-7
    iou = intersection / union
    
    # Hộp bao nhỏ nhất (Enclosing Box)
    enc_x1 = torch.min(pred_boxes[:, 0], target_boxes[:, 0])
    enc_y1 = torch.min(pred_boxes[:, 1], target_boxes[:, 1])
    enc_x2 = torch.max(pred_boxes[:, 2], target_boxes[:, 2])
    enc_y2 = torch.max(pred_boxes[:, 3], target_boxes[:, 3])
    c2 = (enc_x2 - enc_x1) ** 2 + (enc_y2 - enc_y1) ** 2 + 1e-7
    
    # Khoảng cách tâm
    center_pred_x = (pred_boxes[:, 0] + pred_boxes[:, 2]) / 2.0
    center_pred_y = (pred_boxes[:, 1] + pred_boxes[:, 3]) / 2.0
    center_target_x = (target_boxes[:, 0] + target_boxes[:, 2]) / 2.0
    center_target_y = (target_boxes[:, 1] + target_boxes[:, 3]) / 2.0
    rho2 = (center_pred_x - center_target_x) ** 2 + (center_pred_y - center_target_y) ** 2
    
    # Yếu tố tỷ lệ khung hình v và alpha
    w_pred, h_pred = pred_boxes[:, 2] - pred_boxes[:, 0], pred_boxes[:, 3] - pred_boxes[:, 1]
    w_gt, h_gt = target_boxes[:, 2] - target_boxes[:, 0], target_boxes[:, 3] - target_boxes[:, 1]
    v = (4.0 / (math.pi ** 2)) * torch.pow(torch.atan(w_gt / (h_gt + 1e-7)) - torch.atan(w_pred / (h_pred + 1e-7)), 2)
    with torch.no_grad():
        alpha = v / ((1.0 - iou) + v + 1e-7)
        
    ciou_loss = 1.0 - iou + (rho2 / c2) + (alpha * v)
    return ciou_loss.mean()

2. Trích xuất màu sắc bằng K-Means Clustering trên không gian RGB/HSV

Sau khi có Bounding Box của vật thể, phân vùng ảnh được cắt ra (crop), loại bỏ 10% viền bao để khử nhiễu nền đường. Thuật toán K-means với $K=3$ phân cụm tập hợp các điểm ảnh $X = {x_1, x_2, \dots, x_N}$ nhằm cực tiểu hóa hàm mục tiêu:

$$J = \sum_{j=1}^K \sum_{x_i \in S_j} ||x_i - \mu_j||^2$$

Cụm có số lượng điểm ảnh lớn nhất (dựa trên histogram phân phối) và không phải màu trung tính nhiễu (đen đậm hoặc trắng nền) được chọn làm màu đại diện của đối tượng.

import cv2
import numpy as np
from sklearn.cluster import KMeans

def extract_dominant_color(image_crop, k=3):
    # Chuyển đổi màu từ BGR sang RGB
    img_rgb = cv2.cvtColor(image_crop, cv2.COLOR_BGR2RGB)
    
    # Thu hẹp vùng trích xuất để giảm thiểu nền đường/ngoại cảnh
    h, w, _ = img_rgb.shape
    crop_inner = img_rgb[int(h*0.1):int(h*0.9), int(w*0.1):int(w*0.9)]
    pixels = crop_inner.reshape(-1, 3)
    
    if len(pixels) == 0:
        return "#000000"
        
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=5)
    labels = kmeans.fit_predict(pixels)
    
    # Tính số lượng pixel trong mỗi cụm
    counts = np.bincount(labels)
    dominant_cluster = np.argmax(counts)
    dominant_rgb = kmeans.cluster_centers_[dominant_cluster].astype(int)
    
    # Chuyển sang định dạng HEX
    hex_color = "#{:02x}{:02x}{:02x}".format(dominant_rgb[0], dominant_rgb[1], dominant_rgb[2])
    return hex_color

3. Nhận diện Khuôn mặt với ArcFace (Additive Angular Margin Loss)

Để phân biệt khuôn mặt đối tượng qua camera độ phân giải trung bình, mô hình sử dụng hàm mất mát ArcFace tối ưu hóa góc $\theta$ trên siêu cầu (hypersphere) bán kính $s=64$, lề góc $m=0.5$:

$$\mathcal{L}{Arc} = -\frac{1}{N}\sum{i=1}^N \log \frac{e^{s(\cos(\theta_{y_i} + m))}}{e^{s(\cos(\theta_{y_i} + m))} + \sum_{j \neq y_i} e^{s \cos \theta_j}}$$

Trích xuất vector đặc trưng $f \in \mathbb{R}^{512}$ chuẩn hóa $L_2$ ($|f|_2 = 1$). Khi người dùng cung cấp ảnh nghi phạm, độ tương đồng được tính toán siêu tốc bằng khoảng cách Cosine:

$$\text{Similarity}(f_1, f_2) = \frac{f_1 \cdot f_2}{|f_1| |f_2|} = f_1 \cdot f_2$$

Ngưỡng tương đồng $\tau = 0.68$ được xác lập qua thực nghiệm để đạt cân bằng tối ưu giữa Precision và Recall.

4. Tìm kiếm ảnh mẫu bằng Normalized Cross-Correlation (NCC)

Để hỗ trợ tìm kiếm phương tiện hoặc đồ vật theo ảnh mẫu mẫu $T$ (kích thước $w \times h$) trên frame $I$ (kích thước $W \times H$), công thức hệ số tương quan chuẩn hóa được áp dụng kết hợp xoay ảnh đa góc ${-15^\circ, 0^\circ, 15^\circ}$:

$$R(x,y) = \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x', y+y'))}{\sqrt{\sum_{x',y'} T(x',y')^2 \cdot \sum_{x',y'} I(x+x', y+y')^2}}$$

Đánh giá thực nghiệm và kết quả Benchmark

Mô hình được huấn luyện trên hệ thống: Intel Core i7-10700K, 32GB RAM, GPU NVIDIA RTX 2080Ti 11GB VRAM.

So sánh hiệu năng mô hình nhận diện đối tượng trên tập CameraVN

Mô hình Input Resolution mAP@0.5 (%) mAP@0.5:0.95 (%) Inference Speed (FPS) Số lượng tham số (Params) FLOPs
YOLOv3 (Darknet-53) $416 \times 416$ 72.4 44.8 48.5 61.9M 65.5B
EfficientDet-D0 $512 \times 512$ 70.8 43.2 52.0 3.9M 2.5B
EfficientDet-D2 $768 \times 768$ 76.5 50.1 31.2 8.1M 11.0B
YOLOv4 (CSPDarknet53) $416 \times 416$ 79.8 54.6 65.0 64.4M 59.6B
YOLOv4 (Tối ưu TensorRT) $416 \times 416$ 79.5 54.3 112.0 64.4M 59.6B 
                BIỂU ĐỒ SO SÁNH ĐỘ CHÍNH XÁC VÀ TỐC ĐỘ (FPS vs mAP@0.5)
    mAP@0.5 (%)
        85 +
           |
        80 +                                   * YOLOv4 (65 FPS, 79.8%)
           |
        75 +                     * EfficientDet-D2 (31.2 FPS, 76.5%)
           |
        70 +        * YOLOv3 (48.5 FPS, 72.4%)
           |        * EfficientDet-D0 (52 FPS, 70.8%)
        65 +
           +--------+--------+--------+--------+--------+--------+--------+
           0        20       40       60       80      100      120     FPS

Kết quả phân loại chi tiết theo từng lớp của YOLOv4 trên tập kiểm thử

Lớp đối tượng (Class) Precision (%) Recall (%) AP@0.5 (%) Số lượng mẫu kiểm thử (Instances)
Người (Person) 84.2 81.5 82.3 2,450
Xe máy (Motorbike) 88.6 86.4 87.9 4,120
Ô tô (Car) 86.1 83.7 85.0 1,830
Xe buýt (Bus) 81.0 79.2 78.4 340
Xe tải (Truck) 78.5 74.0 75.1 510
Xe đạp (Bicycle) 72.3 68.1 70.1 290
Trung bình toàn bộ (mAP) 81.8 78.8 79.8 9,540

Hiệu năng các module thành phần

  • K-means Color Extraction: Thời gian xử lý trung bình $4.2\text{ ms}/\text{vật thể}$, độ chính xác phân định 8 dải màu cơ bản đạt $87.6%$.
  • Face Detection (TinaFace): Đạt $92.1%\text{ AP}$ trên tập kiểm thử mặt nghiêng; tốc độ xử lý $28\text{ FPS}$.
  • Face Verification (ArcFace): Đạt độ chính xác $99.4%\text{ True Acceptance Rate}$ trên tập dữ liệu chuẩn hóa, thời gian tính Cosine distance cho 100.000 vectors là $12\text{ ms}$.
  • Template Matching (NCC đa góc): Xử lý $18\text{ ms}/\text{frame}$, định vị chính xác vật thể khi góc xoay không lệch quá $\pm 20^\circ$.

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

  1. Kiến trúc Trích xuất Metadata Tách rời (Decoupled Indexing Architecture): Khác với các hệ thống AI thông thường chạy toàn bộ mạng nơ-ron nặng nề mỗi khi người dùng tìm kiếm, đề tài đề xuất mô hình phân tầng: Trích xuất siêu dữ liệu ngoại tuyến một lần duy nhất và lưu trữ dưới dạng cấu trúc bảng chỉ mục (Indexed Relational & Vector Schema). Cơ chế này giúp giảm tải 98.5% chi phí điện toán trong các lần truy vấn tiếp theo.

  2. Xây dựng Dataset CameraVN đặc thù giao thông đô thị: Đóng góp bộ dữ liệu hơn 5.000 ảnh trích xuất từ camera giao thông thực tế tại TP. Hồ Chí Minh với đặc trưng: góc nhìn từ trên cao (Overhead perspective), mật độ xe máy dày đặc và tình trạng che khuất (Occlusion) phức tạp. Việc huấn luyện lại trên tập dữ liệu này giúp mô hình tăng 12.4% mAP so với trọng số gốc tiền huấn luyện trên tập MS COCO.

  3. Cơ chế lọc nhiễu nền nâng cao cho thuật toán nhận diện màu sắc: Cải tiến thuật toán K-means bằng kỹ thuật thu hẹp biên 10% kết hợp bộ lọc không gian màu HSV để triệt tiêu ảnh hưởng của mặt đường nhựa (màu xám) và bóng râm cây cối, nâng độ chính xác nhận diện màu áo/màu xe từ $71.2%$ lên $87.6%$.

  4. Công cụ tìm kiếm đa phương thức All-in-One: Tích hợp thành công 4 cơ chế tìm kiếm trong một ứng dụng duy nhất: Tìm kiếm theo bộ lọc thuộc tính số học, tìm kiếm theo dải màu, tìm kiếm bằng vector khuôn mặt 512D và tìm kiếm theo tương quan mẫu hình ảnh, cung cấp trải nghiệm điều tra toàn diện cho người dùng.

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

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

+-----------------------------------------------------------------------------------+
|                        QUY TRÌNH TRUY VẾT THỰC TẾ                                 |
|                                                                                   |
|  [Tiếp nhận vụ việc]                                                              |
|          |                                                                        |
|          v                                                                        |
|  [Nhập thông tin nhận dạng: "Xe máy" + Màu "Đỏ" + Đoạn đường X (08:00 - 09:00)]    |
|          |                                                                        |
|          v                                                                        |
|  [Hệ thống quét CSDL Metadata: Khớp ClassID & Color HEX trong 0.08 giây]          |
|          |                                                                        |
|          v                                                                        |
|  [Trả về 12 Frames nghi vấn -> So khớp khuôn mặt ArcFace -> Xác định đúng đối tượng]
+-----------------------------------------------------------------------------------+
  • Điều tra phá án và an ninh trật tự: Hỗ trợ lực lượng công an, cơ quan điều tra nhanh chóng tìm kiếm trẻ lạc, truy bắt đối tượng cướp giật, trộm cắp thông qua đặc điểm nhận dạng quần áo hoặc hình ảnh chân dung trích xuất từ căn cước/ảnh thẻ.
  • Xử phạt vi phạm giao thông: Truy tìm phương tiện vượt đèn đỏ, đi vào đường cấm hoặc gây tai nạn rồi bỏ trốn dựa trên phân loại phương tiện và màu sơn xe.
  • Quản lý an ninh nội bộ tại tòa nhà/khu đô thị: Kiểm soát lịch sử di chuyển của khách vãng lai, phát hiện đối tượng trong danh sách đen (Blacklist) xuất hiện trong khuôn viên.

Yêu cầu triển khai và Phần cứng

+-----------------------------------------------------------------------------------+
|                       YÊU CẦU HỆ THỐNG TRIỂN KHAI                                 |
|                                                                                   |
|  1. Máy chủ trích xuất Metadata (Batch Processing Node):                          |
|     - CPU: AMD Ryzen 7 5800X / Intel Xeon Silver (8 Cores, 16 Threads)            |
|     - RAM: 32 GB DDR4 ECC                                                         |
|     - GPU: 1x NVIDIA RTX 3060 12GB hoặc RTX 2080Ti (Tối thiểu 8GB VRAM)          |
|     - Lưu trữ: 1TB NVMe SSD (xử lý đệm) + 8TB HDD SATA (lưu video)                |
|                                                                                   |
|  2. Máy trạm truy vấn người dùng (Client Investigation Workstation):               |
|     - CPU: Intel Core i5 thế hệ 8 trở lên                                         |
|     - RAM: 8 GB                                                                   |
|     - GPU: Không yêu cầu GPU rời (sử dụng Intel UHD Graphics)                     |
|     - OS: Ubuntu 20.04 LTS / Windows 10/11 64-bit                                 |
+-----------------------------------------------------------------------------------+

Phân tích chi phí - lợi ích (ROI)

  • Tiết kiệm thời gian: Rút ngắn thời gian rà soát một vụ việc từ 6 giờ xuống còn 15 phút (bao gồm cả thời gian nạp video và xác thực kết quả).
  • Tối ưu hóa nhân lực: Một cán bộ điều tra có thể quản lý và xử lý lượng dữ liệu tương đương với 10 nhân sự rà soát truyền thống.
  • Khả năng hoàn vốn: Giảm thiểu nhu cầu đầu tư hệ sinh thái máy chủ AI thời gian thực đắt đỏ (vốn yêu cầu GPU phân tích $24/7$), chỉ cần hệ thống máy trạm thông thường phục vụ truy vấn.

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

Hạn chế kỹ thuật

  1. Chất lượng ảnh ban đêm và điều kiện thời tiết khắc nghiệt: Trong môi trường thiếu sáng, ánh đèn pha phương tiện gây lóa (flare) làm sai lệch nhận diện màu sắc của thuật toán K-means.
  2. Độ phân giải khuôn mặt ở khoảng cách xa: Các camera gắn ở cột cao trên 5m cho ra khuôn mặt người có kích thước dưới $20 \times 20$ pixels, không đủ số lượng điểm ảnh để ArcFace trích xuất vector đặc trưng tin cậy.
  3. Template Matching nhạy cảm với biến dạng phối cảnh lớn: Khi góc quay thay đổi vượt quá $\pm 30^\circ$, độ tương đồng tương quan giảm mạnh, dẫn đến hiện tượng False Negative.

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

  • Tích hợp mô hình Re-Identification (Re-ID) và DeepSORT: Xây dựng đồ thị đường đi (Trajectory Graph) của đối tượng xuyên suốt nhiều camera giám sát khác nhau mà không phụ thuộc hoàn toàn vào khuôn mặt.
  • Ứng dụng Vision Transformer (ViT): Chuyển đổi backbone sang các kiến trúc hiện đại như YOLOv8, YOLOv10 hoặc Swin Transformer để nâng cao khả năng trích xuất đặc trưng đa quy mô.
  • Nâng cấp Cơ sở dữ liệu Vector chuyên dụng: Tích hợp các hệ quản trị CSDL vector như Milvus hoặc Qdrant sử dụng giải thuật HNSW (Hierarchical Navigable Small World) để hỗ trợ tìm kiếm hàng triệu vector khuôn mặt trong thời gian thực dưới 5ms.

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

+-----------------------------------------------------------------------------------+
|                            ĐỐI TƯỢNG HƯỞNG LỢI                                    |
|                                                                                   |
|  [Sinh viên / Học viên]  -> Bộ mã nguồn mẫu, Dataset CameraVN, Kiến thức YOLO/ArcFace|
|  [Kỹ sư AI / Developers] -> Pipeline trích xuất Metadata module hóa, Tối ưu hóa GPU |
|  [Doanh nghiệp / Đô thị] -> Giải pháp tiết kiệm 70% chi phí phần cứng giám sát    |
|  [Nhà nghiên cứu]        -> Dữ liệu thực nghiệm benchmark YOLOv4 vs EfficientDet  |
+-----------------------------------------------------------------------------------+
  • Sinh viên và Học viên Công nghệ thông tin: Cung cấp tài liệu tham khảo hoàn chỉnh, mã nguồn thực tế về cách tích hợp đa mô hình Deep Learning (Object Detection + Face Verification + Unsupervised Clustering) vào một ứng dụng hoàn chỉnh.
  • Kỹ sư phát triển phần mềm (Developers): Tiếp cận kiến trúc thiết kế tách rời giữa trích xuất dữ liệu nặng và giao diện truy vấn người dùng, áp dụng kỹ thuật tối ưu hóa luồng với PyQt5.
  • Lực lượng An ninh và Cơ quan chức năng: Sở hữu công cụ đắc lực hỗ trợ phá án nhanh chóng, chính xác, giảm thiểu gánh nặng rà soát thủ công.
  • Nhà nghiên cứu Thị giác máy tính: Cung cấp các kết quả thực nghiệm chi tiết, đánh giá so sánh khách quan giữa các hàm loss (CIoU, ArcFace, Triplet Loss) trên dữ liệu thực tế tại Việt Nam.

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

1. Hệ thống có yêu cầu GPU trong quá trình người dùng tìm kiếm dữ liệu không?

Không. Quá trình xử lý nặng yêu cầu GPU chỉ diễn ra một lần duy nhất trong giai đoạn Trích xuất Siêu dữ liệu ngoại tuyến (Offline Metadata Extraction). Sau khi metadata (tọa độ, mã màu, vector đặc trưng 512D) đã được lưu vào cơ sở dữ liệu SQLite, các thao tác tìm kiếm chỉ thực hiện các phép lọc dữ liệu và tính toán đại số vector nhẹ, có thể chạy mượt mà trên CPU thông thường của máy tính văn phòng.

2. Dung lượng cơ sở dữ liệu Metadata chiếm bao nhiêu phần trăm so với video gốc?

Dung lượng metadata cực kỳ nhỏ gọn, chỉ chiếm khoảng 0.1% đến 0.3% so với dung lượng video gốc. Một đoạn video giám sát 24 giờ dung lượng 20GB ở chuẩn H.264 1080p chỉ sinh ra khoảng 20MB đến 50MB dữ liệu metadata trong cơ sở dữ liệu.

3. Làm thế nào để phân biệt chính xác màu sắc khi vật thể có nhiều màu kết hợp (ví dụ: áo đỏ quần xanh)?

Hệ thống hiện tại chia bounding box của người thành 2 phân vùng (nửa trên và nửa dưới) trước khi đưa vào thuật toán K-means. Nửa trên đại diện cho màu áo và nửa dưới đại diện cho màu quần, giúp người dùng có thể lọc chi tiết theo từng thuộc tính trang phục riêng biệt.

4. Hệ thống có tích hợp được với các hệ thống camera giám sát IP hiện có không?

Có. Hệ thống đọc luồng video thông qua giao thức RTSP (Real-Time Streaming Protocol) tiêu chuẩn hoặc nạp trực tiếp các tệp tin video đã ghi hình (MP4, AVI, MKV) từ các đầu ghi NVR/DVR phổ biến trên thị trường như Hikvision, Dahua, Kbvision mà không yêu cầu thay đổi hạ tầng camera hiện hữu.

5. Chi phí đầu tư phần cứng để vận hành hệ thống là bao nhiêu và thời gian hoàn vốn (ROI) thế nào?

Để xử lý dữ liệu cho cụm 10-20 camera giám sát, chỉ cần đầu tư 01 máy trạm xử lý trang bị GPU NVIDIA RTX 3060 12GB với chi phí phần cứng khoảng 20 - 25 triệu VNĐ. Hệ thống giúp giảm 90% thời gian rà soát, tiết kiệm hàng trăm giờ công lao động mỗi tháng, mang lại thời gian hoàn vốn đầu tư chỉ sau 2 đến 3 tháng vận hành.

Kết luận

Đề tài "Ứng dụng nhận diện đối tượng để tìm kiếm đối tượng trong dữ liệu camera giám sát" đã giải quyết thành công bài toán thực tiễn về truy vết thông tin trong khối dữ liệu video khổng lồ. Bằng việc kết hợp sáng tạo giữa các kiến trúc học sâu tiên tiến (YOLOv4, EfficientDet, ArcFace) và các giải thuật xử lý ảnh cổ điển (K-means, Template Matching), đề tài đã chứng minh tính khả thi và hiệu quả vượt trội của mô hình truy vấn dựa trên siêu dữ liệu.

Kết quả đạt được không chỉ dừng lại ở độ chính xác nhận diện mAP 79.8% và tốc độ xử lý nhanh 65 FPS, mà còn tạo ra một ứng dụng hoàn chỉnh có khả năng triển khai ngay vào thực tế phục vụ công tác giám sát an ninh, điều tra đô thị thông minh. Hướng nghiên cứu tiếp theo sẽ tập trung vào việc tích hợp Re-ID đa camera và nâng cấp CSDL vector phân tán để mở rộng quy mô phục vụ hàng nghìn camera trên toàn thành phố.

Để tìm hiểu thêm về mã nguồn, bộ dữ liệu và hướng dẫn tích hợp hệ thống, vui lòng liên hệ nhóm tác giả hoặc Khoa Khoa học Máy tính - Trường Đại học Công nghệ Thông tin, ĐHQG-HCM.