Giới thiệu dự án

Sự bùng nổ của đô thị hóa và tốc độ gia tăng phương tiện giao thông cá nhân tại các đô thị lớn tại Việt Nam đã tạo áp lực khổng lồ lên hạ tầng giao thông tĩnh. Theo các nghiên cứu quy hoạch đô thị, có tới 30% lượng phương tiện lưu thông trong giờ cao điểm bắt nguồn từ việc người lái xe lãng phí thời gian tìm kiếm vị trí đỗ còn trống. Tình trạng này không chỉ gây lãng phí nhiên liệu, tăng phát thải khí nhà kính mà còn làm trầm trọng thêm vấn nạn ùn tắc giao thông.

Đề tài "Thiết kế bộ tăng tốc FPGA hiệu quả cho phát hiện chỗ đậu xe thời gian thực" (Design an Efficient FPGA-based Accelerator for Real-time Parking Occupancy Detection) do sinh viên Nguyễn Vũ Thành Nguyễn (Khoa Khoa học và Kỹ thuật Máy tính, Trường Đại học Bách Khoa - ĐHQG TP.HCM) thực hiện dưới sự hướng dẫn của PGS. TS. Trần Ngọc Thịnh và KS. Huỳnh Phúc Nghị, tập trung giải quyết triệt để bài toán nhận diện trạng thái bãi đỗ xe thông minh thông qua việc kết hợp mạng nơ-ron nhị phân (Binary Neural Network - BNN) và công nghệ vi mạch mảng phần tử logic lập trình được (Field-Programmable Gate Array - FPGA).

+-----------------------------------------------------------------------------------+
|                            HỆ THỐNG SMART PARKING EDGE AI                         |
+-----------------------------------------------------------------------------------+
|  [Camera Giám sát]                                                                |
|         │ (Luồng video RTSP)                                                      |
|         ▼                                                                         |
|  [Ultra96-V2 MPSoC Hub]                                                           |
|    ├── Processing System (PS): ARM Cortex-A53 (Quản lý luồng, Tiền xử lý ảnh)     |
|    └── Programmable Logic (PL): BNN Hardware Accelerator (Phân loại vị trí đỗ)    |
|         │                                                                         |
|         ▼ (Metadata trạng thái trống / bận)                                       |
|  [Cloud Server & Database] ──▶ [Ứng dụng Di động / Bảng LED hướng dẫn đỗ xe]      |
+-----------------------------------------------------------------------------------+

Vấn đề thực tiễn và bài toán kỹ thuật

Các giải pháp bãi đỗ xe thông minh truyền thống đang đối mặt với những rào cản lớn:

  1. Giải pháp cảm biến vật lý (IoT Sensors): Cảm biến từ trường hoặc siêu âm gắn tại từng ô đỗ có chi phí lắp đặt, bảo trì đắt đỏ ($50 - $100/vị trí), tuổi thọ pin hạn chế và dễ hỏng hóc do thời tiết.
  2. Giải pháp xử lý ảnh tập trung (Cloud AI): Truyền tải liên tục hàng chục luồng video độ phân giải cao về máy chủ trung tâm gây tắc nghẽn băng thông mạng, chi phí hạ tầng máy chủ lớn và độ trễ cao.
  3. Giải pháp AI biên truyền thống (Edge GPU): Sử dụng các dòng vi xử lý đồ họa nhúng như NVIDIA Jetson Nano cho các mô hình dấu phẩy động 32-bit (FP32) tiêu thụ nhiều năng lượng (10W - 15W), tỏa nhiệt lớn và chi phí phần cứng cao khi mở rộng quy mô.

Mục tiêu của dự án

  1. Nghiên cứu và tối ưu hóa mô hình BNN: Xây dựng mô hình phân loại ảnh nhị phân hóa dựa trên kiến trúc FracBNN kết hợp tập dữ liệu bãi đỗ xe CNRPark+EXT.
  2. Thiết kế bộ mã hóa đầu vào Thermometer Encoder: Chuyển đổi dữ liệu ảnh RGB $32 \times 32$ thành định dạng nhị phân 1-bit hiệu quả mà không làm suy giảm các đặc trưng biên và hình thái xe.
  3. Hiện thực hóa bộ tăng tốc phần cứng trên FPGA: Tổng hợp và triển khai kiến trúc phần cứng chuyên dụng trên kit vi xử lý đa lõi nhúng SoC Xilinx Zynq UltraScale+ MPSoC (Ultra96-V2).
  4. Đánh giá hiệu năng và triển khai thực tế: Đo đạc các chỉ số kỹ thuật về độ trễ (latency), thông lượng khung hình (FPS), mức tiêu thụ năng lượng (Power Consumption) và độ chính xác phân loại (Accuracy).

Phạm vi và giới hạn của đề tài

  • Tập dữ liệu kiểm nghiệm: Tập dữ liệu chuẩn quốc tế CNRPark và CNRPark+EXT bao gồm hàng chục nghìn ảnh cắt phân vùng ô đỗ xe dưới nhiều góc độ và điều kiện ánh sáng (nắng, mưa, bóng râm, góc khuất).
  • Phần cứng mục tiêu: Bo mạch Avnet Ultra96-V2 tích hợp chip Xilinx Zynq UltraScale+ MPSoC ZU3EG.
  • Đầu vào xử lý: Các khối ảnh phân vùng ô đỗ kích thước $32 \times 32$ pixel được trích xuất từ camera giám sát cố định.

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

Phân tích hiện trạng công nghệ

Tiêu chí Cảm biến từ / Siêu âm (SENSIT, IParking) Cloud Vision AI (Server GPU) Edge GPU (NVIDIA Jetson Nano) Edge FPGA (Đề tài: Ultra96-V2 + FracBNN)
Chi phí triển khai ban đầu Rất cao (yêu cầu gắn từng ô) Trung bình (tận dụng camera) Trung bình ($150 - $200/hub) Tối ưu ($200 - $250/hub quản lý nhiều camera)
Băng thông mạng yêu cầu Thấp (chỉ gửi dữ liệu nhị phân) Cực cao (truyền luồng Video HD) Thấp (chỉ gửi kết quả phân loại) Thấp (chỉ gửi kết quả phân loại)
Mức tiêu thụ điện năng Rất thấp (dùng pin) Rất cao (>300W/server) Trung bình (5W - 10W) Cực thấp (1.5W - 3.5W trên chip)
Độ trễ suy luận (Latency) Nhanh (~100ms) Chậm (phụ thuộc đường truyền mạng) Khá (30ms - 50ms) Thời gian thực (< 15ms)
Khả năng bảo trì Phức tạp, dễ hư hỏng cơ học Dễ dàng quản lý tập trung Trung bình Tốt, chip công nghiệp chịu nhiệt độ cao

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc phải có):
    • Mô hình BNN phân loại nhị phân trạng thái bãi đỗ (trống/có xe) với kích thước $32 \times 32$.
    • Lõi IP tăng tốc phần cứng tổng hợp bằng ngôn ngữ C/C++ thông qua công cụ Vivado HLS.
    • Tích hợp thành công luồng xử lý trên nền tảng PYNQ Overlay tương thích hệ điều hành nhúng Linux.
  • Should Have (Nên có):
    • Tích hợp bộ mã hóa Thermometer Encoder trực tiếp trên mạch logic khả trình (Programmable Logic - PL).
    • Khả năng xử lý song song nhiều phân vùng ô đỗ xe trong cùng một chu kỳ quét.
  • Could Have (Có thể có):
    • Giao diện API RESTful để đồng bộ dữ liệu thời gian thực lên Dashboard quản lý.
  • Won't Have (Chưa thực hiện trong phạm vi này):
    • Tích hợp nhận diện biển số xe tự động (ANPR) trên cùng lõi logic BNN.

Kiến trúc hệ thống phần cứng và phần mềm

Hệ thống được tổ chức theo mô hình đồng thiết kế phần cứng / phần mềm (HW/SW Co-design) dựa trên cấu trúc dị thể của dòng SoC Xilinx ZU3EG:

+---------------------------------------------------------------------------------------+
|                       ZYNQ ULTRASCALE+ MPSOC ARCHITECTURE                             |
+---------------------------------------------------------------------------------------+
| [PROCESSING SYSTEM (PS)]                                                              |
|   ├── Quad-core ARM Cortex-A53 @ 1.2GHz (Ubuntu Linux, PYNQ Framework, Driver)       |
|   ├── 2GB LPDDR4 Memory (Chứa ảnh gốc, bảng trọng số, chương trình điều khiển)       |
|   └── AXI Master Interface ──────────────────────────────────────────────┐            |
+──────────────────────────────────────────────────────────────────────────┼────────────+
| [PROGRAMMABLE LOGIC (PL)]                                                ▼            |
|   ┌─────────────────────────────────────────────────────────────────────────────────┐ |
|   │ BNN HARDWARE ACCELERATOR IP (Xilinx Vivado Synthesized)                         │ |
|   │  ├── AXI DMA Engine / AXI-Stream Protocol                                       │ |
|   │  ├── Line Buffer & Input Feeder (32x32 Image Cache)                             │ |
|   │  ├── Thermometer Encoding Unit (FP32/INT8 -> 1-bit Stream)                      │ |
|   │  ├── Binary Convolution Core (XNOR Array + Popcount Adder Trees)                 │ |
|   │  ├── Batch Normalization & Threshold Activation Unit                            │ |
|   │  └── On-chip Memory: 214 BRAM Blocks (Chứa Binarized Weights & Intermediate Maps)│ |
|   └─────────────────────────────────────────────────────────────────────────────────┘ |
+---------------------------------------------------------------------------------------+

Công nghệ và công cụ sử dụng

  • Môi trường huấn luyện AI: PyTorch v1.10, Python 3.8, CUDA Toolkit 11.3.
  • Công cụ thiết kế phần cứng: Xilinx Vivado Design Suite 2020.2, Vivado HLS (High-Level Synthesis).
  • Nền tảng thực thi nhúng: PYNQ Framework v2.6, Ubuntu 18.04 LTS RootFS.
  • Phần cứng mục tiêu: Avnet Ultra96-V2 (Chip ZU3EG: 70,560 LUTs, 141,120 Flip-Flops, 214 BRAMs, 360 DSP slices).

Implementation và kết quả

Chi tiết giải thuật và mô hình mạng nơ-ron

Khác biệt cốt lõi giữa mạng CNN chuẩn và BNN nằm ở phép toán đại số tuyến tính. Trong CNN, phép tích chập yêu cầu các phép nhân-cộng dấu phẩy động đa bit (MAC - Multiply-Accumulate) tiêu tốn nhiều tài nguyên DSP:

$$y = \sum_{i} W_i \cdot X_i + b$$

Trong kiến trúc BNN, trọng số ($W$) và tín hiệu kích hoạt ($A$) đều được lượng tử hóa về hai giá trị ${-1, +1}$. Phép nhân ma trận phức tạp được thay thế hoàn toàn bằng cổng logic XNOR và mạch đếm bit 1 (Popcount):

$$W_b = \text{Sign}(W) = \begin{cases} +1 & \text{nếu } W \ge 0 \ -1 & \text{nếu } W < 0 \end{cases}$$

$$\text{Conv}(W_b, A_b) = 2 \times \text{Popcount}(\text{XNOR}(W_b, A_b)) - N$$

(Trong đó $N$ là tổng số bit của vector tích chập).

import torch
import torch.nn as nn

class BinaryActivation(nn.Module):
    """
    Hàm kích hoạt nhị phân sử dụng Straight-Through Estimator (STE)
    cho quá trình lan truyền ngược (Backpropagation)
    """
    def __init__(self):
        super(BinaryActivation, self).__init__()

    def forward(self, x):
        # Forward pass: Lượng tử hóa về -1 hoặc +1
        out_forward = torch.sign(x)
        # Giữ out_forward = +1 khi x == 0
        out_forward[out_forward == 0] = 1.0
        
        # STE: Trong quá trình backward, đạo hàm được gán bằng 1 
        # trong khoảng [-1, 1], triệt tiêu ngoài khoảng
        clip_mask = (x.abs() <= 1.0).float()
        return x + (out_forward - x).detach()

class BinaryConv2d(nn.Conv2d):
    """
    Lớp tích chập nhị phân hóa trọng số
    """
    def forward(self, input):
        # Nhị phân hóa ma trận trọng số
        real_weights = self.weight
        scaling_factor = torch.mean(torch.mean(torch.mean(abs(real_weights), dim=3, keepdim=True), 
                                              dim=2, keepdim=True), dim=1, keepdim=True)
        binary_weights = torch.sign(real_weights)
        binary_weights[binary_weights == 0] = 1.0
        binary_weights = binary_weights * scaling_factor.detach()
        
        return nn.functional.conv2d(input, binary_weights, self.bias, 
                                    self.stride, self.padding, self.dilation, self.groups)

Bộ mã hóa đầu vào Thermometer Encoding

Để tránh việc lớp đầu tiên phải thực hiện phép toán dấu phẩy động 32-bit làm tắc nghẽn đường ống phần cứng, giải pháp sử dụng phương pháp mã hóa nhị phân theo mức Thermometer Encoding:

#include <ap_int.h>

// Hàm thực thi bộ mã hóa nhiệt kế trên FPGA bằng Vivado HLS
// Chuyển đổi 1 pixel thang độ xám (8-bit: 0-255) thành chuỗi nhị phân 7-bit
ap_uint<7> thermometer_encoder(ap_uint<8> pixel_val) {
    #pragma HLS INLINE
    ap_uint<7> encoded_val = 0;
    
    // Ngưỡng phân đoạn theo các mức năng lượng quang học
    if (pixel_val >= 32)  encoded_val[0] = 1;
    if (pixel_val >= 64)  encoded_val[1] = 1;
    if (pixel_val >= 96)  encoded_val[2] = 1;
    if (pixel_val >= 128) encoded_val[3] = 1;
    if (pixel_val >= 160) encoded_val[4] = 1;
    if (pixel_val >= 192) encoded_val[5] = 1;
    if (pixel_val >= 224) encoded_val[6] = 1;
    
    return encoded_val;
}

// Lõi tích chập nhị phân hướng phần cứng sử dụng XNOR và Popcount
void binary_conv_engine(ap_uint<64> input_feature, ap_uint<64> weight, int &accum_out) {
    #pragma HLS PIPELINE II=1
    
    // Phép toán logic XNOR bitwise
    ap_uint<64> xnor_result = ~(input_feature ^ weight);
    
    // Mạch đếm bit 1 (Popcount) tối ưu trên LUT
    int bit_count = 0;
    for (int i = 0; i < 64; i++) {
        #pragma HLS UNROLL
        bit_count += xnor_result[i];
    }
    
    // Ánh xạ về giá trị đại số tuyến tính: 2 * Popcount - N
    accum_out += (2 * bit_count - 64);
}

Kết quả thử nghiệm và đánh giá thực nghiệm

Mô hình được huấn luyện trên tập dữ liệu CNRPark+EXT và đánh giá so sánh trực tiếp trên hai nền tảng phần cứng: Avnet Ultra96-V2 (FPGA)NVIDIA Jetson Nano (GPU).

BIỂU ĐỒ SO SÁNH HIỆU QUẢ NĂNG LƯỢNG VÀ THÔNG LƯỢNG
┌─────────────────────────────────────────────────────────────┐
│ Thông lượng (FPS) - [Càng cao càng tốt]                     │
│ Ultra96-V2 (FracBNN) : ████████████████████████ 80.3 FPS    │
│ Jetson Nano (YOLOv3) : ███████ 24.5 FPS                     │
├─────────────────────────────────────────────────────────────┤
│ Điện năng tiêu thụ (Watt) - [Càng thấp càng tốt]            │
│ Ultra96-V2 (FracBNN) : ████ 2.45 W                          │
│ Jetson Nano (GPU)    : ████████████████ 8.60 W              │
└─────────────────────────────────────────────────────────────┘

Bảng tổng hợp số liệu thực nghiệm

Tham số đo đạc NVIDIA Jetson Nano (YOLOv3-tiny) NVIDIA Jetson Nano (VGG-16 BNN) Xilinx Ultra96-V2 (CNV BNN Baseline) Xilinx Ultra96-V2 (Đề tài: FracBNN + CNRPark)
Độ trễ xử lý (Latency) 40.8 ms 28.6 ms 16.0 ms 12.45 ms
Thông lượng (Throughput) 24.5 FPS 35.0 FPS 62.5 FPS 80.3 FPS
Độ chính xác (F1-Score) 89.2% 85.4% 88.7% 94.6%
Công suất trên chip (On-chip Power) 8.60 W 6.50 W 2.80 W 2.45 W
Năng lượng / Khung hình (Energy/Img) 350.8 mJ 185.9 mJ 44.8 mJ 30.5 mJ
Tài nguyên LUT sử dụng N/A (GPU Cores) N/A (GPU Cores) 43,200 (61.2%) 47,520 (67.3%)
Tài nguyên BRAM sử dụng N/A N/A 148 (69.1%) 162 (75.7%)
Tài nguyên DSP sử dụng N/A N/A 12 (3.3%) 8 (2.2%)

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

  1. Ứng dụng thành công mô hình FracBNN trên dữ liệu bãi đỗ thực tế: Khắc phục điểm yếu chí tử về suy giảm độ chính xác của mạng BNN truyền thống bằng cách tích hợp các kết nối tắt kép phân đoạn (Dual-residual connections), giúp độ chính xác đạt 94.6%, thu hẹp khoảng cách với các mạng FP32 đầy đủ trong khi giảm dung lượng mô hình xuống hơn 90%.

  2. Tối ưu hóa phần cứng không dùng DSP: Bằng cách chuyển đổi triệt để các tầng tích chập và đầu vào sang dạng nhị phân, thiết kế đã giải phóng 97.8% các khối DSP trên chip ZU3EG, chỉ sử dụng các mảng Look-Up Tables (LUT) và Flip-Flops. Điều này cho phép vi mạch vận hành ở mức nhiệt độ thấp và tiết kiệm năng lượng tối đa.

  3. Cải thiện vượt bậc về hiệu suất năng lượng (Energy Efficiency): Thiết kế trên Ultra96-V2 tiêu thụ năng lượng trên mỗi khung hình chỉ 30.5 mJ, đạt hiệu quả năng lượng cao gấp 11.5 lần so với giải pháp chạy YOLOv3-tiny trên NVIDIA Jetson Nano (350.8 mJ).

  4. Quy trình HW/SW Co-design hoàn chỉnh: Xây dựng hoàn thiện chuỗi công cụ từ PyTorch $\rightarrow$ Vivado HLS $\rightarrow$ Bitstream Overlay $\rightarrow$ Ứng dụng PYNQ nhúng, cho phép các kỹ sư dễ dàng tái sử dụng và tùy biến cho các bài toán biên khác.


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

Kịch bản vận hành thực tế

Hệ thống được thiết kế để lắp đặt trực tiếp tại các bãi đỗ xe ngoài trời, tầng hầm trung tâm thương mại hoặc các tuyến đường đỗ xe công cộng:

[Camera Góc Rộng 4K] ──▶ [Bộ tách Frame & Crop ROI] ──▶ [Ultra96-V2 Accelerator] 
                                                                 │
                                                       (Phân tích 50-100 ô đỗ)
                                                                 │
                                                                 ▼ (< 1 giây/chu kỳ)
[Cloud Dashboard Quản trị] ◀── [MQTT Broker / 4G LTE] ◀── [Kết quả JSON]
{
  "hub_id": "BK_PARKING_ZONE_A",
  "timestamp": "2023-01-09T08:30:00Z",
  "total_slots": 64,
  "occupied_slots": 42,
  "vacant_slots": 22,
  "vacant_slot_ids": ["A01", "A04", "A05", "A12", "A18", "A22"]
}

Phân tích hiệu quả kinh tế và ROI

Giả sử triển khai cho một bãi đỗ xe quy mô 200 vị trí:

  • Phương án Cảm biến IoT truyền thống:
    • 200 cảm biến từ/siêu âm $\times$ $60 = $12,000.
    • Chi phí lắp đặt, kéo dây, bộ gateway: $3,000.
    • Tổng đầu tư ban đầu: $15,000.
    • Chi phí thay pin định kỳ mỗi 2 năm: $2,000.
  • Phương án Edge AI FPGA (Đề tài đề xuất):
    • 4 Camera IP góc rộng chuẩn công nghiệp $\times$ $150 = $600.
    • 2 Kit Ultra96-V2 SoC Hub $\times$ $250 = $500.
    • Phụ kiện và thi công lắp đặt: $1,000.
    • Tổng đầu tư ban đầu: $2,100.
  • Hiệu quả kinh tế: Tiết kiệm 86% chi phí đầu tư ban đầu, thời gian hoàn vốn (Payback Period) rút ngắn từ 18 tháng xuống còn 3 tháng.

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

Hạn chế kỹ thuật

  • Độ phụ thuộc vào bước tiền xử lý ROI: Hệ thống yêu cầu cấu hình vị trí các ô đỗ cố định trong giai đoạn cài đặt ban đầu. Khi góc quay camera bị lệch do tác động ngoại lực, cần tiến hành cân chỉnh lại bounding box.
  • Tác động của thời tiết khắc nghiệt: Trong điều kiện mưa bão lớn làm nhòe ống kính hoặc ban đêm thiếu sáng nghiêm trọng, tỷ lệ âm tính giả (False Negative) tăng nhẹ 3.2%.
  • Kích thước ảnh đầu vào nhỏ ($32 \times 32$): Hạn chế khả năng nhận diện các vật cản nhỏ hoặc phân biệt các loại phương tiện đặc thù (xe đạp điện, xe đẩy hàng lấn chiếm ô đỗ).

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

  • Tích hợp End-to-End Object Detection nhị phân: Nghiên cứu kiến trúc Tiny-YOLO nhị phân hóa hoàn toàn để phát hiện đồng thời cả ô đỗ và phương tiện mà không cần chia giai đoạn crop ROI.
  • Tự động cân chỉnh góc camera: Bổ sung thuật toán học không giám sát (Unsupervised Optical Flow) để tự động hiệu chỉnh tọa độ ô đỗ khi camera bị rung lắc.
  • Hỗ trợ lượng tử hóa hỗn hợp (Mixed-Precision Quantization): Kết hợp các tầng 1-bit, 2-bit và 4-bit linh hoạt theo độ nhạy đặc trưng của từng lớp nơ-ron để nâng F1-Score lên trên 98%.

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

+---------------------------------------------------------------------------------------+
|                                 ĐỐI TƯỢNG HƯỞNG LỢI                                   |
+---------------------------------------------------------------------------------------+
|  SINH VIÊN & NGHIÊN CỨU SINH                                                          |
|  - Nguồn tài liệu chuyên sâu về thiết kế phần cứng vi mạch & BNN.                     |
|  - Mã nguồn mẫu về HLS C++ và PYNQ Overlay trên Xilinx UltraScale+.                   |
+---------------------------------------------------------------------------------------+
|  KỸ SƯ HỆ THỐNG NHÚNG & AI DEVELOPERS                                                 |
|  - Kỹ thuật tối ưu hóa đường ống phần cứng (#pragma HLS PIPELINE, UNROLL).            |
|  - Phương pháp chuyển đổi mô hình PyTorch sang RTL thực thi trên FPGA.                 |
+---------------------------------------------------------------------------------------+
|  DOANH NGHIỆP & NHÀ QUẢN LÝ BÃI XE                                                    |
|  - Giải pháp Smart Parking chi phí thấp, tận dụng hệ thống camera hiện hữu.           |
|  - Tiết kiệm 86% chi phí đầu tư thiết bị so với giải pháp cảm biến.                   |
+---------------------------------------------------------------------------------------+
|  CỘNG ĐỒNG HỌC THUẬT VÀ ĐÔ THỊ THÔNG MINH                                             |
|  - Minh chứng tính khả thi của Edge AI ứng dụng vi mạch FPGA công suất thấp.          |
|  - Giảm thiểu ùn tắc và lượng khí thải carbon tại các khu đô thị.                      |
+---------------------------------------------------------------------------------------+

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

1. Yêu cầu phần cứng và công cụ phát triển để triển khai dự án này là gì?

Để triển khai đầy đủ hệ thống, bạn cần:

  • Phần cứng: Bo mạch Avnet Ultra96-V2 (hoặc các dòng Xilinx Zynq-7000 / Zynq UltraScale+ tương đương có tối thiểu 50k LUTs), thẻ nhớ microSD tối thiểu 16GB (Class 10), nguồn cấp 12V/2A hoặc 12V/4A, Camera IP hỗ trợ chuẩn RTSP.
  • Phần mềm: Máy trạm x86_64 chạy Ubuntu 18.04/20.04 LTS, bộ công cụ Xilinx Vivado Design Suite & Vivado HLS bản 2020.2 trở lên, Python 3.8 với các thư viện PyTorch, PYNQ, OpenCV.

2. Giới hạn mở rộng (Scalability) của một bộ tăng tốc Ultra96-V2 là bao nhiêu ô đỗ?

Với thông lượng đạt 80.3 FPS cho các khối ảnh $32 \times 32$ (tương đương ~12.45 ms/khung hình), một kit Ultra96-V2 có khả năng quét và phân loại liên tục 80 ô đỗ xe trong vòng 1 giây. Đối với các bãi xe thông thường chu kỳ cập nhật trạng thái từ 3-5 giây là hoàn hảo, một thiết bị có thể quản lý đồng thời từ 240 đến 400 ô đỗ xe (tương đương kết nối 4-8 luồng camera).

3. Tích hợp bộ tăng tốc này vào hạ tầng camera giám sát IP hiện hữu như thế nào?

Hệ thống không yêu cầu thay đổi phần cứng camera có sẵn. Quy trình tích hợp diễn ra như sau:

  1. Luồng video được lấy trực tiếp từ camera qua giao thức mạng RTSP (rtsp://username:password@ip_camera:554/stream1).
  2. CPU ARM trên Ultra96-V2 bắt khung hình, thực hiện crop các vùng ảnh ô đỗ (ROI) theo tọa độ định trước.
  3. Dữ liệu được đẩy vào bộ nhớ DMA để mạch FPGA thực thi suy luận siêu tốc.
  4. Kết quả trạng thái được đóng gói thành chuỗi JSON và gửi lên máy chủ quản trị qua giao thức HTTP/MQTT.

4. Chi phí vận hành, bảo trì và độ tin cậy của phần cứng FPGA so với GPU thế nào?

FPGA có độ tin cậy công nghiệp vượt trội (Industrial Grade), hoạt động ổn định trong dải nhiệt độ rộng mà không cần quạt tản nhiệt công suất lớn. Do toàn bộ mô hình được "đúc" thành các cổng logic phần cứng và tiêu thụ điện năng chỉ ~2.45W (so với 8.6W - 15W của GPU), rủi ro quá nhiệt, sụt áp hoặc lỗi bộ nhớ thấp hơn đáng kể, giúp hệ thống duy trì hoạt động liên tục $24/7$ với tuổi thọ phần cứng trên 5 năm.

5. Tỷ suất hoàn vốn đầu tư (ROI) và thời gian thu hồi vốn thực tế khi triển khai hệ thống?

Nhờ tận dụng hạ tầng camera có sẵn và không phải chi trả chi phí cảm biến tại từng điểm đỗ, một bãi đỗ xe 200 vị trí chỉ tốn khoảng $2,100 chi phí thiết bị. Việc tự động hóa phát hiện chỗ trống giúp tăng tỷ lệ quay vòng bãi xe (turnover rate) lên gấp 2-4 lần và giảm thiểu nhân sự điều phối, mang lại thời gian thu hồi vốn trung bình chỉ từ 3 đến 6 tháng.


Kết luận

Đồ án tốt nghiệp "Thiết kế bộ tăng tốc FPGA hiệu quả cho phát hiện chỗ đậu xe thời gian thực" của tác giả Nguyễn Vũ Thành Nguyễn đã chứng minh xuất sắc tính khả thi, hiệu quả vượt trội của việc kết hợp mạng nơ-ron nhị phân (FracBNN) và chip vi mạch khả trình FPGA Xilinx Zynq UltraScale+ MPSoC.

Bằng việc thay thế các phép tính dấu phẩy động phức tạp bằng các cổng logic cơ bản XNOR và Popcount, đề tài đã đạt được các chỉ số ấn tượng: độ chính xác 94.6%, thông lượng 80.3 FPS, độ trễ 12.45 ms và mức tiêu thụ công suất chỉ 2.45 W. Đây là minh chứng rõ nét cho xu hướng chuyển dịch tính toán trí tuệ nhân tạo từ đám mây về thiết bị biên (Edge AI), mở ra tiềm năng thương mại hóa rộng lớn trong các dự án giao thông thông minh và đô thị thông minh tại Việt Nam.

Bạn có thể áp dụng kiến trúc này cho hệ thống giám sát bãi đỗ xe hoặc mở rộng sang các bài toán phân loại giao thông khác trên nền tảng nhúng FPGA.