Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và tự động hóa công nghiệp, các hệ thống giám sát an ninh thông minh (Smart Video Surveillance) đóng vai trò nòng cốt trong quản lý đô thị thông minh, giao thông công cộng và an ninh doanh nghiệp. Theo các báo cáo phân tích thị trường từ MarketsandMarkets, thị trường phân tích video thông minh toàn cầu dự kiến vượt mốc 20 tỷ USD với tốc độ tăng trưởng kép hàng năm (CAGR) trên 23.5%. Tuy nhiên, các giải pháp giám sát truyền thống phụ thuộc hoàn toàn vào nhân lực giám sát thủ công trên màn hình hoặc đẩy toàn bộ dữ liệu video thô (raw video streams) về máy chủ đám mây (Cloud Computing) đang bộc lộ những điểm nghẽn nghiêm trọng: độ trễ cao, tiêu tốn băng thông mạng viễn thông, nguy cơ rò rỉ dữ liệu riêng tư và chi phí hạ tầng máy chủ GPU đắt đỏ.

Vấn đề kỹ thuật cốt lõi (Problem Statement) mà các hệ thống an ninh hiện đại phải đối mặt là: Làm thế nào để xử lý đồng thời nhiều luồng video thời gian thực từ các camera IP với độ chính xác cao trong điều kiện ánh sáng biến thiên, góc quay phức tạp và mật độ người đông đúc, nhưng vẫn đảm bảo mức tiêu thụ năng lượng thấp và kích thước phần cứng nhỏ gọn tại biên (Edge Computing)? Việc triển khai các mạng nơ-ron tích chập (Convolutional Neural Networks - CNNs) trên các bộ xử lý đồ họa (GPU) truyền thống tiêu tốn từ 150W đến 300W công suất, tỏa nhiệt lớn và không tối ưu cho các trạm giám sát phân tán.

Khóa luận tốt nghiệp "Hệ thống phát hiện và theo dõi người trên SoC-FPGA" do sinh viên Lê Ngọc Long và Phan Mạnh Khương thực hiện dưới sự hướng dẫn của ThS. Ngô Hiếu Trường tại Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM đã giải quyết bài toán này thông qua việc nghiên cứu, tối ưu hóa và thực thi mô hình Deep Learning trên nền tảng phần cứng tái cấu trúc AMD Xilinx Kria KV260 Vision AI Starter Kit.

+-----------------------------------------------------------------------------------+
|                            HỆ THỐNG GIÁM SÁT THÔNG MINH                           |
+-----------------------------------------------------------------------------------+
| [ IP Cameras (RTSP) ] ---> [ Kria KV260 SoC-FPGA ] ---> [ Central Server / GUI ]  |
|   - 1080p H.264 Stream       - VCU Hardware Decode        - Feature Extraction    |
|   - Multi-angle capture      - Multiscaler Preprocess     - Siamese Network Re-ID |
|                              - DPU (YOLOv3-Tiny INT8)     - Database Tracking     |
+-----------------------------------------------------------------------------------+

Dự án đặt ra 3 mục tiêu cụ thể:

  1. Nghiên cứu, huấn luyện và lượng tử hóa mô hình Deep Learning: Lựa chọn và tùy biến kiến trúc mạng nơ-ron gọn nhẹ YOLOv3-Tiny trên tập dữ liệu người đi bộ đa dạng, đạt độ chính xác mAP $\ge 90%$; áp dụng kỹ thuật lượng tử hóa Post-Training Quantization (PTQ) INT8 tương thích kiến trúc phần cứng.
  2. Hiện thực hóa và tăng tốc phần cứng trên SoC-FPGA: Biên dịch mô hình sang định dạng phần cứng (.xmodel), nhúng trên lõi tăng tốc chuyên dụng AMD Deep Learning Processing Unit (DPU - DPUCZDX8G), kết hợp bộ giải mã phần cứng VCU (Video Codec Unit) và bộ tiền xử lý Multiscaler IP để đạt tốc độ xử lý thời gian thực $\ge 30\text{ FPS}$.
  3. Xây dựng giải pháp định danh và theo dõi liên tục (Re-Identification): Thiết lập cơ chế truyền nhận siêu dữ liệu (metadata/bounding boxes) qua giao thức TCP Socket về máy chủ quản lý, tích hợp mạng Siamese Network nhằm tính toán độ tương đồng để định danh và theo dõi trạng thái đối tượng trên giao diện điều khiển trực quan.

Phạm vi và giới hạn của đề tài: Hệ thống xử lý trực tiếp 2 luồng camera IP chuẩn RTSP độ phân giải Full HD (1080p), tập trung chuyên sâu vào lớp đối tượng người (pedestrian detection), tối ưu hóa hiệu năng tính toán tại biên trên bo mạch Kria KV260 và thực hiện định danh Re-ID tập trung trên Server nội bộ.

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

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

Để đưa ra giải pháp tối ưu cho bài toán phát hiện và theo dõi người tại biên, khóa luận đã tiến hành đánh giá so sánh đa chiều giữa các nền tảng tính toán phổ biến:

Tiêu chí đánh giá CPU Edge (VD: Raspberry Pi 4) Embedded GPU (VD: NVIDIA Jetson Nano) Cloud Server (VD: AWS/GPU Server) Nền tảng SoC-FPGA (AMD Kria KV260)
Tốc độ suy luận (FPS) Kém (< 5 FPS với CNN) Trung bình (15 - 22 FPS) Rất cao (> 60 FPS) Cao (30 - 45 FPS ổn định)
Công suất tiêu thụ Thấp (~5W) Trung bình (10W - 15W) Rất cao (> 250W) Thấp - Tối ưu (~7.5W)
Băng thông mạng yêu cầu Thấp (xử lý tại biên) Thấp (xử lý tại biên) Cực lớn (stream video liên tục) Rất thấp (chỉ gửi Metadata)
Độ trễ xử lý (Latency) Rất cao (> 200ms) Trung bình (45 - 70ms) Phụ thuộc đường truyền mạng Cực thấp (< 25ms, Deterministic)
Khả năng tùy biến phần cứng Không có (Fixed HW) Không có (Fixed HW) Cố định theo GPU vendor Rất cao (Tái cấu trúc Logic PL)

Phân tích yêu cầu hệ thống theo mô hình MoSCoW:

  • Must Have (Bắt buộc): Giải mã video H.264 thời gian thực từ camera IP; phát hiện người chính xác bằng YOLOv3-Tiny trên DPU với độ trễ thấp; gửi tọa độ Bounding Box về Server qua giao thức TCP.
  • Should Have (Nên có): Định danh đối tượng qua mạng Siamese Network; cập nhật cơ sở dữ liệu mẫu người liên tục theo thời gian thực; hiển thị Bounding Box và ID trực tiếp trên Web GUI.
  • Could Have (Có thể mở rộng): Tự động phát cảnh báo khi đối tượng đi vào vùng cấm; tích hợp xử lý nhiều hơn 4 luồng camera đồng thời.
  • Won't Have (Chưa thực hiện trong giai đoạn này): Nhận diện khuôn mặt 3D sinh trắc học và tích hợp phân tích hành vi phức tạp (Action Recognition).

Thiết kế hệ thống

Kiến trúc hệ thống được thiết kế theo mô hình lai (Hybrid Edge-Server Architecture), phân tách rõ ràng giữa tầng thu nhận/suy luận biên (Edge Inference) và tầng quản lý/định danh tập trung (Server-side Analytics).

+-----------------------------------------------------------------------------------------------+
|                            KIẾN TRÚC TỔNG QUAN HỆ THỐNG (HARDWARE/SOFTWARE)                   |
+-----------------------------------------------------------------------------------------------+
| [ IP Camera 1 ] --(RTSP H.264)--> [ AMD Xilinx Kria KV260 System-on-Module ]                 |
| [ IP Camera 2 ] --(RTSP H.264)--> +---------------------------------------------------------+ |
|                                   |  Processing System (PS) - ARM Cortex-A53 (Linux OS)     | |
|                                   |  +---------------------------------------------------+  | |
|                                   |  | GStreamer Pipeline & VVAS Framework (v2.0)        |  | |
|                                   |  |  [rtspsrc] -> [vvas_xvideodec] (VCU Hard IP)      |  | |
|                                   |  |            -> [vvas_xmultisrc] (Multiscaler PL)   |  | |
|                                   |  |            -> [vvas_xfilter]   (DPUCZDX8G IP)     |  | |
|                                   |  |            -> [ImaBbox Sender] (TCP Socket Client)|  | |
|                                   |  +---------------------------------------------------+  | |
|                                   +---------------------------------------------------------+ |
|                                                                | (TCP Protocol: Metadata & Frame)
|                                                                v                              |
|                                   +---------------------------------------------------------+ |
|                                   | Central Management Server (Python / Flask / PostgreSQL) | |
|                                   |  +---------------------------------------------------+  | |
|                                   |  | [Receiver Engine] -> [Crop & Normalize Worker]    |  | |
|                                   |  |                   -> [Siamese Network Engine]     |  | |
|                                   |  |                   -> [Database & ID Manager]      |  | |
|                                   |  |                   -> [HTML5 / WebSocket Web GUI]  |  | |
|                                   |  +---------------------------------------------------+  | |
|                                   +---------------------------------------------------------+ |
+-----------------------------------------------------------------------------------------------+

Technology Stack và phiên bản công nghệ:

  • Phần cứng: AMD Kria KV260 Vision AI Starter Kit (Zynq UltraScale+ MPSoC XCK26, lõi CPU Quad-core ARM Cortex-A53 @ 1.3GHz, GPU Mali-400 MP2, 4GB 64-bit DDR4).
  • Phần cứng tăng tốc AI: DPU IP Core DPUCZDX8G (Cấu hình B4096, hoạt động ở tần số 300MHz trên Programmable Logic - PL).
  • Hệ điều hành biên: Kria Ubuntu Desktop 22.04 LTS (Kernel Linux 5.15), Xilinx Runtime (XRT v2022.2).
  • Môi trường & SDK: AMD Vitis AI SDK v3.0, Vitis Video Analytics SDK (VVAS) v2.0, GStreamer Framework v1.18.5.
  • Framework học máy: Darknet Framework, TensorFlow v2.11.0, Python v3.10, PyTorch v1.13 (huấn luyện Siamese Network).
  • Hạ tầng máy chủ & Web: Python Socket Server, Flask Microframework, SQLAlchemy ORM, SQLite/PostgreSQL Database.

Thiết kế cơ sở dữ liệu và giao thức giao tiếp: Hệ thống sử dụng cấu trúc giao thức truyền tin nhị phân/JSON đóng gói qua TCP Socket để gửi metadata từ Kria KV260 lên máy chủ:

{
  "camera_id": "CAM_01_GATE",
  "timestamp": 1724398590.125,
  "frame_id": 10482,
  "detections_count": 2,
  "objects": [
    {
      "class_id": 0,
      "class_name": "person",
      "confidence": 0.942,
      "bbox": [120, 85, 340, 620]
    },
    {
      "class_id": 0,
      "class_name": "person",
      "confidence": 0.887,
      "bbox": [450, 110, 210, 580]
    }
  ]
}

Mô hình dữ liệu quan hệ quản lý định danh đối tượng:

  • Table Cameras: id (PK), name, rtsp_url, location, status.
  • Table Persons: id (PK), person_id (Unique ID), first_seen_timestamp, last_seen_timestamp, status (Active/Lost).
  • Table PersonEmbeddings: id (PK), person_id (FK), feature_vector (BLOB/128-d Float Array), crop_image_path, confidence_score.

Methodology

Quy trình nghiên cứu và phát triển được thực hiện theo phương pháp luận đồng thiết kế phần cứng - phần mềm (Hardware-Software Co-Design), chia làm 4 giai đoạn chính:

[ Giai đoạn 1: Chuẩn bị dữ liệu & Huấn luyện ]
   └── Thu thập Dataset (COCO, VOC, Pedestrian) -> Augmentation (Roboflow) -> Train Darknet YOLOv3-Tiny
[ Giai đoạn 2: Tối ưu hóa & Lượng tử hóa ]
   └── Convert to TensorFlow (.pb) -> Vitis AI Quantizer (PTQ INT8 + CLE + AdaQuant) -> Vitis AI Compiler (.xmodel)
[ Giai đoạn 3: Hiện thực hóa trên SoC-FPGA ]
   └── Cấu hình DPUCZDX8G -> Xây dựng GStreamer VVAS Pipeline -> Kiểm thử giải mã VCU & Suy luận DPU
[ Giai đoạn 4: Tích hợp Server & Triển khai thực tế ]
   └── Mạng Siamese Re-ID -> Thiết kế TCP Socket -> Quản trị CSDL & Web Dashboard -> Đánh giá End-to-End

Đánh giá và giảm thiểu rủi ro (Risk Assessment & Mitigation):

  • Rủi ro 1: Suy giảm độ chính xác nhận diện sau khi lượng tử hóa từ FP32 xuống INT8. Giải pháp: Áp dụng phối hợp hai thuật toán tiên tiến là Cân bằng chéo lớp (Cross-Layer Equalization - CLE) và lượng tử hóa thích ứng (AdaQuant) với tập hiệu chuẩn (Calibration Dataset) gồm 1,000 ảnh đặc trưng.
  • Rủi ro 2: Nghẽn cổ chai băng thông truyền dữ liệu giữa bộ nhớ DDR và nhân tính toán DPU. Giải pháp: Tận dụng cơ chế cấp phát bộ nhớ Zero-Copy (DMA-BUF) của VVAS SDK và giao thức bus AXI-MM / AXI-Stream băng thông cao kết nối trực tiếp VCU, Multiscaler và DPU trong phần cứng PL.

Implementation và kết quả

Development process

1. Quy trình lượng tử hóa mô hình với Vitis AI Quantizer

Quá trình chuyển đổi mô hình từ dấu chấm động 32-bit (FP32) sang số nguyên 8-bit (INT8) đóng vai trò quyết định để mô hình có thể thực thi trên nhân tính toán chuyên dụng DPUCZDX8G:

  • Thuật toán Cross-Layer Equalization (CLE): Cân bằng phạm vi trọng số giữa hai lớp tích chập liên tiếp (lớp $i$ và $i+1$) bằng ma trận chuyển đổi tỷ lệ $S = \text{diag}(s_1, s_2, \dots, s_c)$: $$W_{i}' = S^{-1} W_i, \quad W_{i+1}' = W_{i+1} S$$ Kỹ thuật này giúp loại bỏ hiện tượng lệch dải giá trị (outliers) ở các kênh kích hoạt, giảm thiểu đáng kể sai số khi làm tròn số nguyên.

  • Thuật toán AdaQuant: Tối ưu hóa hàm mất mát lượng tử hóa thông qua việc tối thiểu sai số đầu ra của từng Layer: $$\min_{\hat{W}} | f(X; W) - f(X; \hat{W}) |_F^2$$ trong đó $\hat{W}$ là tập trọng số lượng tử hóa INT8 và $|\cdot|_F$ là chuẩn Frobenius.

# Script thực hiện lượng tử hóa mô hình YOLOv3-Tiny bằng Vitis AI Quantizer
import tensorflow as tf
from tensorflow_model_optimization.quantization.keras import vitis_quantize

# 1. Load pre-trained frozen graph TensorFlow model
input_model_path = "./model/yolov3_tiny_pedestrian.pb"
calib_dataset_dir = "./dataset/calibration_images/"

# 2. Khởi tạo Data Generator phục vụ quá trình Calibration (1000 images)
def calib_input_fn():
    # Tiền xử lý chuẩn hóa ảnh về kích thước chuẩn của DPU (416x416)
    dataset = tf.data.Dataset.list_files(calib_dataset_dir + "*.jpg")
    for file_path in dataset.take(1000):
        img = tf.io.read_file(file_path)
        img = tf.image.decode_jpeg(img, channels=3)
        img = tf.image.resize(img, [416, 416])
        img = img / 255.0  # Normalize to [0, 1]
        yield [img]

# 3. Thực thi Vitis AI Quantization với thuật toán CLE và AdaQuant
quantizer = vitis_quantize.VitisQuantizer(
    input_model_path, 
    quantize_strategy='CLE_AdaQuant'
)
quantized_model = quantizer.quantize_model(
    calib_dataset=calib_input_fn(),
    weight_bit=8,
    activation_bit=8
)
quantized_model.save("./quantized/quantized_yolov3_tiny.xmodel")
print("[INFO] Lượng tử hóa INT8 hoàn tất thành công.")

2. Xây dựng Pipeline tăng tốc đa phương tiện trên Kria KV260

Hệ thống sử dụng framework GStreamer kết hợp các plugin chuyên biệt của VVAS để tạo đường ống xử lý tối ưu phần cứng (Hardware Acceleration Pipeline):

# GStreamer Pipeline chạy trực tiếp trên Kria KV260
gst-launch-1.0 \
  rtspsrc location=rtsp://192.168.1.100:554/stream1 latency=100 ! \
  rtph264depay ! h264parse ! \
  vvas_xvideodec ! \
  vvas_xmultisrc config-file=/etc/vvas/multiscaler_config.json ! \
  video/x-raw, width=416, height=416, format=BGR ! \
  vvas_xfilter kernels-config=/etc/vvas/yolov3_tiny_dpu_config.json ! \
  vvas_xoverlay ! \
  kmssink bus-id=fd4a0000.display

Cơ chế hoạt động của Pipeline:

  • rtspsrc thu nhận luồng video RTSP qua giao diện mạng Ethernet Gigabit.
  • vvas_xvideodec định tuyến luồng H.264 vào bộ giải mã cứng VCU trên chip Zynq UltraScale+, xuất định dạng màu NV12 mà không làm tiêu tốn tài nguyên của CPU ARM.
  • vvas_xmultisrc (IP Multiscaler trên PL) thực hiện resize kích thước ảnh về chuẩn $416\times416$ và chuyển đổi không gian màu từ NV12 sang BGR.
  • vvas_xfilter nạp file mô hình .xmodel vào nhân DPU để thực thi quá trình suy luận nhận diện người.

3. Thuật toán định danh và theo dõi đối tượng bằng Siamese Network

Sau khi nhân DPU phát hiện và trích xuất tọa độ Bounding Box, ảnh đối tượng được gửi về máy chủ để xử lý định danh qua mạng Siamese Network với hàm mất mát tương phản (Contrastive Loss):

$$\mathcal{L}(d, y) = \frac{1}{2} (1 - y) d^2 + \frac{1}{2} y \max(0, m - d)^2$$

Trong đó:

  • $d = | f(x_1) - f(x_2) |_2$ là khoảng cách Euclid giữa 2 vector đặc trưng 128 chiều trích xuất từ hai ảnh người.
  • $y \in {0, 1}$ là nhãn tương đồng ($y=0$ nếu cùng một người, $y=1$ nếu là hai người khác nhau).
  • $m$ là ngưỡng biên (margin threshold, cấu hình $m = 1.0$).
# Server-side: So khớp đặc trưng và gán định danh (Person Re-Identification)
import numpy as np
import torch

class PersonTrackerManager:
    def __init__(self, similarity_threshold=0.65):
        self.database = {} # Lưu trữ {person_id: feature_vector}
        self.threshold = similarity_threshold
        self.current_id_counter = 1

    def match_and_update(self, new_feature_vector):
        """
        So sánh vector đặc trưng mới với cơ sở dữ liệu đối tượng đã lưu
        """
        best_match_id = None
        min_distance = float('inf')

        for person_id, stored_vector in self.database.items():
            # Tính khoảng cách Euclid giữa 2 vector nhúng
            distance = np.linalg.norm(new_feature_vector - stored_vector)
            if distance < min_distance:
                min_distance = distance
                best_match_id = person_id

        # Kiểm tra ngưỡng tương đồng
        if min_distance < self.threshold:
            # Cập nhật Moving Average cho vector mẫu để thích nghi ánh sáng
            self.database[best_match_id] = 0.8 * self.database[best_match_id] + 0.2 * new_feature_vector
            return best_match_id, min_distance, "MATCHED"
        else:
            # Khởi tạo định danh mới cho người mới xuất hiện
            new_id = f"ID_{self.current_id_counter:04d}"
            self.database[new_id] = new_feature_vector
            self.current_id_counter += 1
            return new_id, min_distance, "NEW_PERSON"

Testing và validation

Quá trình kiểm thử được triển khai toàn diện trên tập dữ liệu tổng hợp gồm 28,608 hình ảnh (sau quá trình tăng cường dữ liệu Augmentation qua Roboflow từ 9,536 ảnh gốc thuộc các tập dữ liệu chuẩn COCO, Pascal VOC và Pedestrian Dataset).

Kết quả đánh giá hiệu năng mô hình:

+-----------------------------------------------------------------------------------------+
|                SO SÁNH ĐỘ CHÍNH XÁC VÀ HIỆU NĂNG TÍNH TOÁN (BENCHMARK)                  |
+--------------------------+-------------------+-------------------+----------------------+
| Thông số đánh giá        | Google Colab GPU  | Kria KV260 (FP32) | Kria KV260 (INT8 DPU)|
|                          | (NVIDIA Tesla T4) | (ARM Cortex-A53)  | (DPUCZDX8G B4096)    |
+--------------------------+-------------------+-------------------+----------------------+
| Mean Average Prec. (mAP) | 93.0%             | 93.0%             | 91.2%                |
| Inference Time (ms)      | 14.2 ms           | 385.0 ms          | 22.4 ms              |
| Frame Rate (FPS)         | 70.4 FPS          | 2.6 FPS           | 44.6 FPS             |
| Công suất tiêu thụ       | ~70W (TDP)        | ~4.5W             | ~7.5W                |
| Hiệu năng/Công suất      | 1.00 FPS/W        | 0.57 FPS/W        | 5.94 FPS/W           |
+--------------------------+-------------------+-------------------+----------------------+

       Biểu đồ so sánh Hiệu năng trên Công suất (FPS / Watt)
       -----------------------------------------------------
       Colab GPU (T4)  : [====] 1.00 FPS/W
       KV260 CPU Only  : [==] 0.57 FPS/W
       KV260 INT8 DPU  : [========================] 5.94 FPS/W  (Vượt trội ~5.9x)

Đánh giá thực nghiệm phần cứng Kria KV260 khi chạy liên tục:

  • Tốc độ khung hình thực tế: Duy trì ổn định từ $30 - 32\text{ FPS}$ cho mỗi luồng camera Full HD (1080p).
  • Mức sử dụng tài nguyên FPGA (PL Resource Utilization): LUTs: 58.4%, BRAM: 62.1%, DSP Slices: 54.7%.
  • Nhiệt độ bo mạch: Dao động trong khoảng $48^{\circ}\text{C} - 53^{\circ}\text{C}$ dưới tải tối đa (hoạt động với quạt tản nhiệt tích hợp của SOM, không xảy ra hiện tượng quá nhiệt hay giảm xung nhịp).

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

Đối chiếu với các mục tiêu ban đầu đặt ra trong khóa luận:

Mục tiêu đề ra ban đầu Kết quả thực tế đạt được Tình trạng
Huấn luyện mô hình phát hiện người đạt mAP $\ge 90%$ Đạt mAP 93.0% trên tập dữ liệu tùy chỉnh, sau lượng tử hóa INT8 duy trì mAP 91.2% Vượt chỉ tiêu (+1.2%)
Triển khai thành công trên DPU Kria KV260 Mô hình .xmodel nạp thành công trên lõi DPUCZDX8G B4096, tốc độ đạt 44.6 FPS (chỉ tính suy luận) Hoàn thành xuất sắc
Xử lý video thời gian thực từ 2 Camera IP Pipeline GStreamer VVAS xử lý ổn định 2 luồng RTSP 1080p ở mức $30\text{ FPS/stream}$ Đạt chỉ tiêu
Định danh và phân loại đối tượng trên máy chủ Tích hợp thành công Siamese Network, tỷ lệ định danh chính xác Re-ID đạt 88.6% trong điều kiện thực tế Đạt chỉ tiêu
Giao diện Web GUI quản trị Thiết kế hoàn chỉnh Dashboard HTML5 hiển thị luồng video, Bounding Box và bảng ID đối tượng Đạt chỉ tiêu

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

  1. Ứng dụng thành công phương pháp Hardware-Software Co-Design trên nền tảng SoC-FPGA thế hệ mới: Khóa luận là một trong những công trình tiên phong trong nước ứng dụng sâu dòng vi mạch AMD Kria KV260 kết hợp Vitis Video Analytics SDK (VVAS) để tăng tốc trọn vẹn toàn bộ chuỗi pipeline thị giác máy tính từ phần cứng (Hardware Decode -> Hardware Resize -> DPU Inference).
  2. Khai thác hiệu quả kỹ thuật lượng tử hóa tiên tiến (CLE & AdaQuant): Giải quyết triệt để bài toán suy giảm độ chính xác khi ép kiểu mô hình từ FP32 xuống INT8, giữ mức suy giảm mAP ở mức cực thấp (chỉ giảm 1.8% so với mức sụt giảm thông thường từ 4-6% của các phương pháp PTQ cơ bản).
  3. Hiệu suất năng lượng vượt trội (Energy-Efficiency Innovation): Đạt tỷ suất xử lý $5.94\text{ FPS/Watt}$, tiết kiệm hơn $65%$ năng lượng tiêu thụ so với các dòng máy tính nhúng GPU cùng phân khúc (như NVIDIA Jetson Nano/TX2), chứng minh tính khả thi vượt bậc của SoC-FPGA cho các trạm giám sát xanh (Green Edge Computing).
  4. Giải pháp Re-Identification kết hợp phân tán: Đề xuất mô hình phân tán hợp lý: Tác vụ nặng về tính toán không gian (Object Detection) được đẩy hoàn toàn về biên phần cứng DPU, trong khi tác vụ so khớp dữ liệu lớn (Siamese Re-ID Database) được quản lý tập trung trên Server, tối ưu hóa triệt để tài nguyên mạng và năng lượng.

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

Kịch bản ứng dụng thực tế (Real-world Use Cases)

  • Tòa nhà và khu đô thị thông minh (Smart Buildings & Smart Cities): Kiểm soát lưu lượng người ra vào các khu vực sảnh, thang máy, hành lang công cộng mà không cần đầu tư hệ thống máy chủ GPU cồng kềnh tại chỗ.
  • Nhà máy sản xuất và khu công nghiệp (Industrial Safety Monitoring): Giám sát công nhân di chuyển vào các khu vực nguy hiểm, cảnh báo xâm nhập vùng cấm với độ trễ phản hồi dưới $30\text{ ms}$.
  • Chuỗi bán lẻ và trung tâm thương mại (Smart Retail Analytics): Theo dõi hành trình khách hàng (Customer Journey Tracking), đếm mật độ người (Footfall Counting) phục vụ tối ưu hóa bố trí gian hàng.
[ IP Camera 1 ] \
[ IP Camera 2 ]  ==> [ Kria KV260 Edge Node ] ==(TCP/LAN)==> [ Local Server / Web GUI ]
[ IP Camera N ] /      (Xử lý tại chỗ: ~7.5W)                 (Quản lý tập trung)

Chiến lược và hướng dẫn triển khai hệ thống (Deployment Guide)

Yêu cầu môi trường phần cứng và phần mềm:

  • Bo mạch AMD Xilinx Kria KV260 Vision AI Starter Kit kèm nguồn 12V/3A, thẻ nhớ MicroSD tối thiểu 32GB (UHS-I Class 10).
  • Hệ điều hành Kria Ubuntu 22.04 LTS, nạp Firmware BOOT.BIN mới nhất qua tiện ích xmutil.
  • Máy chủ quản lý: CPU 4 cores, 8GB RAM, hệ điều hành Ubuntu 20.04/22.04 LTS hoặc Windows Server.

Các bước cài đặt và nạp ứng dụng:

# Bước 1: Tải và nạp gói Overlay phần cứng DPU cho Kria KV260
sudo xmutil listapps
sudo xmutil loadapp kv260-smartcam

# Bước 2: Clone repository mã nguồn dự án và cài đặt dependencies
git clone https://github.com/project-repo/soc-fpga-person-tracking.git
cd soc-fpga-person-tracking/edge_app
sudo apt-get install -y libvvas-core-dev xrt-dkms
pip3 install -r requirements.txt

# Bước 3: Khởi chạy pipeline thu nhận video và suy luận DPU
python3 main_edge_stream.py \
  --rtsp_src1 "rtsp://admin:pass@192.168.1.101:554/h264" \
  --rtsp_src2 "rtsp://admin:pass@192.168.1.102:554/h264" \
  --model_path "./models/yolov3_tiny.xmodel" \
  --server_ip "192.168.1.200" \
  --server_port 8080

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

  • Chi phí đầu tư phần cứng (CapEx): Bo mạch Kria KV260 có chi phí thương mại khoảng 250 USD, thấp hơn đáng kể so với việc trang bị một máy tính công nghiệp tích hợp GPU rời (từ 1,200 - 2,000 USD).
  • Chi phí vận hành điện năng (OpEx): Với mức công suất tiêu thụ chỉ $\approx 7.5\text{W}$ (so với $250\text{W}$ của máy chủ GPU), hệ thống giúp doanh nghiệp tiết kiệm hơn 85% chi phí tiền điện hàng năm trên mỗi điểm giám sát.
  • Thời gian hoàn vốn (ROI): Ước tính từ 8 đến 12 tháng đối với các dự án triển khai quy mô từ 10 đến 50 camera giám sát.

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

Những hạn chế kỹ thuật hiện tại

  1. Hiện tượng che khuất (Heavy Occlusion): Khi các đối tượng người di chuyển đan xen với mật độ quá dày đặc, mô hình YOLOv3-Tiny có thể gặp hiện tượng nhận diện sót (Missed Detection Rate tăng khoảng 4.5%).
  2. Biến động góc nhìn và trang phục lớn đối với Siamese Network: Khi đối tượng thay đổi góc quay từ chính diện sang nhìn từ phía sau hoặc thay đổi áo khoác, độ tương đồng đặc trưng có thể bị suy giảm dẫn đến gán ID mới.
  3. Giới hạn luồng camera đồng thời trên 1 bo mạch: Phiên bản hiện tại tối ưu hóa tốt nhất cho 2 luồng Full HD 1080p. Khi nâng lên 4 luồng, tốc độ khung hình giảm xuống mức $18 - 20\text{ FPS/stream}$ do giới hạn băng thông bộ nhớ chia sẻ.

Hướng phát triển và mở rộng

  • Nâng cấp kiến trúc mạng nơ-ron: Thử nghiệm và chuyển đổi các kiến trúc hiện đại hơn như YOLOv8-Nano hoặc YOLOv10 lên DPU để nâng cao độ chính xác nhận diện người ở khoảng cách xa.
  • Tăng tốc phần cứng cho thuật toán Re-ID: Thiết kế và đóng gói trực tiếp mạng trích xuất đặc trưng Siamese/DeepSORT thành một nhân IP Custom Accelerator trên phần cứng khả trình (Programmable Logic) của FPGA, biến Kria KV260 thành thiết bị All-in-One Edge Tracker độc lập.
  • Mở rộng nền tảng phần cứng: Chuyển đổi thiết kế sang các dòng vi mạch thế hệ mới như AMD Versal AI Edge Series để khai thác các nhân AI Engine (AIE) với năng lực xử lý INT8 mạnh gấp nhiều lần.

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

+---------------------------------------------------------------------------------------+
|                                  ĐỐI TƯỢNG HƯỞNG LỢI                                  |
+-------------------+-------------------+-----------------------+-----------------------+
| Sinh viên /       | Kỹ sư phần mềm /  | Doanh nghiệp /        | Nhà nghiên cứu /      |
| Thực tập sinh     | Embedded Devs     | Tích hợp hệ thống     | Viện nghiên cứu       |
| - Tài liệu mẫu    | - Kiến trúc mẫu   | - Giải pháp Edge AI   | - Dữ liệu thực nghiệm |
|   Hardware-SW     |   GStreamer/VVAS  |   chi phí thấp (<$300)|   Quantization INT8   |
| - Quy trình Vitis | - Zero-copy DPU   | - Tiết kiệm 85% điện  | - Tài liệu tham khảo  |
|   AI chuẩn hóa    |   optimization    |   vận hành            |   SoC-FPGA AI         |
+-------------------+-------------------+-----------------------+-----------------------+
  1. Sinh viên và người học ngành Kỹ thuật Máy tính / Hệ thống nhúng:
    • Cung cấp tài liệu thực hành hoàn chỉnh từ lý thuyết Deep Learning đến kỹ thuật nạp mô hình thực tế lên vi mạch FPGA.
    • Nắm vững quy trình công nghệ chuẩn công nghiệp: Darknet $\rightarrow$ TensorFlow $\rightarrow$ Vitis AI $\rightarrow$ XIR $\rightarrow$ DPU.
  2. Kỹ sư phát triển hệ thống nhúng và IoT (Developers):
    • Bộ khung mã nguồn mở (Pipeline Template) với GStreamer và VVAS SDK sẵn sàng tái sử dụng cho các bài toán thị giác khác (nhận diện biển số xe, phân loại lỗi sản phẩm).
    • Mẫu thiết kế giao tiếp Socket TCP truyền tải metadata tối ưu độ trễ.
  3. Doanh nghiệp và đơn vị tích hợp hệ thống (System Integrators):
    • Sở hữu giải pháp giám sát an ninh thông minh tiết kiệm điện năng, chi phí phần cứng cạnh tranh, dễ dàng mở rộng theo dạng module tại biên.
  4. Nhà nghiên cứu học thuật (Researchers):
    • Cung cấp dữ liệu đo lường thực nghiệm chính xác về hiệu năng các thuật toán lượng tử hóa CLE, AdaQuant trên nền tảng vi mạch AMD UltraScale+.

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

1. Yêu cầu phần cứng và phần mềm tối thiểu để triển khai lại đề tài này là gì?

Trả lời: Về phần cứng, bạn cần bo mạch AMD Kria KV260 Vision AI Starter Kit, thẻ nhớ microSD tối thiểu 32GB (tốc độ đọc/ghi $\ge 100\text{MB/s}$), nguồn adapter 12V/3A và ít nhất 01 Camera IP hỗ trợ chuẩn RTSP/H.264. Về phần mềm, máy tính trạm cần cài đặt Ubuntu 22.04 LTS, Docker Engine, AMD Vitis AI v3.0 và môi trường Python 3.10.

2. Giới hạn mở rộng số lượng Camera IP trên một bo mạch Kria KV260 là bao nhiêu?

Trả lời: Nhờ bộ giải mã cứng VCU tích hợp có khả năng giải mã tối đa 4 luồng video 4K@30fps hoặc 8 luồng 1080p@30fps, giới hạn mở rộng tối ưu trên 1 kit KV260 là 2 đến 4 luồng camera Full HD 1080p. Với 2 luồng, hệ thống duy trì trọn vẹn $30\text{ FPS/stream}$; với 4 luồng, hệ thống đạt khoảng $18 - 20\text{ FPS/stream}$ (đáp ứng tốt chuẩn giám sát an ninh thông thường).

3. Hệ thống có thể tích hợp vào các hệ thống quản lý video (VMS) hiện có không?

Trả lời: Hoàn toàn có thể. Do phần mềm trên Kria KV260 xuất dữ liệu nhận diện dưới dạng chuẩn RESTful API, WebSocket hoặc gói tin JSON/TCP, hệ thống dễ dàng kết nối trực tiếp vào các phần mềm VMS nổi tiếng như Milestone XProtect, Genetec hoặc các nền tảng IoT Cloud như ThingsBoard và AWS IoT Core.

4. Tại sao nhóm nghiên cứu chọn YOLOv3-Tiny thay vì các phiên bản mới hơn như YOLOv7 hay YOLOv8?

Trả lời: YOLOv3-Tiny có kiến trúc mạng tích chập tiêu chuẩn rất tương thích với tập lệnh của nhân phần cứng DPUCZDX8G (vốn tối ưu tuyệt đối cho các lớp Conv 3x3, MaxPool 2x2, LeakyReLU). Kiến trúc này giúp khai thác $100%$ các phép tính trên FPGA PL mà không cần chuyển ngược dữ liệu về CPU ARM (Fallback layer), đảm bảo độ trễ thấp nhất và tối ưu chi phí năng lượng.

5. Chi phí đầu tư trọn gói cho một điểm giám sát 2 camera sử dụng Kria KV260 là bao nhiêu?

Trả lời: Tổng chi phí ước tính khoảng 450 - 550 USD (bao gồm 01 kit Kria KV260 trị giá ~250 USD, 02 IP Camera 1080p trị giá ~150 USD, phụ kiện nguồn, thẻ nhớ, switch mạng ~50 USD). Chi phí này chỉ bằng khoảng $25 - 35%$ so với giải pháp sử dụng máy tính công nghiệp nhúng GPU truyền thống.

Kết luận

Khóa luận tốt nghiệp "Hệ thống phát hiện và theo dõi người trên SoC-FPGA" của nhóm tác giả Lê Ngọc Long và Phan Mạnh Khương, Khoa Kỹ thuật Máy tính - Trường Đại học Công nghệ Thông tin (ĐHQG TP.HCM) đã giải quyết trọn vẹn bài toán giám sát an ninh thông minh tại biên. Bằng việc kết hợp hài hòa giữa kiến trúc học sâu tối ưu (YOLOv3-Tiny, Siamese Network) và nền tảng phần cứng tăng tốc tiên tiến AMD Xilinx Kria KV260 SoC-FPGA, đề tài đã chứng minh tính ưu việt vượt trội về tốc độ xử lý thời gian thực ($44.6\text{ FPS}$ suy luận), độ chính xác cao ($91.2\text{ mAP}$ INT8) và hiệu quả sử dụng năng lượng xuất sắc ($5.94\text{ FPS/Watt}$).

Công trình mở ra hướng tiếp cận giàu tiềm năng cho việc thương mại hóa các thiết bị giám sát thị giác AI biên (Edge AI Vision) "Make in Vietnam", đáp ứng hoàn hảo các tiêu chuẩn kỹ thuật khắt khe của đô thị thông minh và nhà máy số trong tương lai.