Giới thiệu dự án

Sự gia tăng nhanh chóng của phương tiện giao thông cá nhân tại các đô thị hiện đại đã tạo ra áp lực khổng lồ lên hạ tầng giao thông tĩnh. Theo các báo cáo về đô thị thông minh, người lái xe tại các thành phố lớn tiêu tốn trung bình từ 15 đến 20 phút cho mỗi lượt tìm kiếm chỗ đỗ xe, chiếm tới 30% nguyên nhân gây ùn tắc giao thông cục bộ và gia tăng đáng kể lượng khí thải carbon. Các giải pháp bãi đỗ xe thông minh (Smart Parking) truyền thống thường dựa vào hai hướng tiếp cận: lắp đặt cảm biến từ trường/siêu âm tại từng vị trí đỗ hoặc truyền luồng video từ camera an ninh về máy chủ đám mây (Cloud Server) để xử lý bằng các mạng nơ-ron tích chập (Convolutional Neural Networks - CNNs) độ chính xác cao.

Tuy nhiên, việc triển khai cảm biến vật lý tại từng vị trí phát sinh chi phí đầu tư phần cứng và bảo trì cực kỳ lớn do ảnh hưởng của thời tiết và hao mòn cơ học. Ngược lại, phương pháp truyền dữ liệu video liên tục 30 FPS từ hàng trăm camera về máy chủ trung tâm gây nghẽn băng thông mạng diện rộng, độ trễ phản hồi cao và vi phạm các quy định về bảo mật dữ liệu hình ảnh công cộng.

Đồ án tốt nghiệp "Thiết Kế Bộ Tăng Tốc FPGA Hiệu Quả Cho Phát Hiện Tình Trạng Chỗ Đỗ Xe Theo Thời Gian Thực" (ngành Kỹ thuật Máy tính, Trường Đại học Bách Khoa – ĐHQG-HCM, thực hiện bởi sinh viên Nguyễn Vũ Thành Nguyễ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ị) giải quyết triệt để các hạn chế trên bằng kiến trúc tính toán biên (Edge AI) kết hợp đồng thiết kế phần cứng/phần mềm (HW/SW Co-design). Đồ án tập trung nghiên cứu, tối ưu và hiện thực hóa mô hình mạng nơ-ron nhị phân (Binary Neural Network - BNN / FracBNN) trên kit phát triển SoC tích hợp FPGA Xilinx Zynq UltraScale+ MPSoC Ultra96-V2.

+------------------+      RTSP Video Stream      +-------------------------------------------+
| IP Camera Module | -------------------------> | Avnet Ultra96-V2 SoC (Edge AI Node)       |
+------------------+                            |  - PS: Quad ARM A53 (Pre-processing/PYNQ) |
                                                |  - PL: Custom BNN Accelerator IP          |
                                                +-------------------------------------------+
                                                                      |
                                                          Metadata (Occupancy State)
                                                                      v
                                                        +---------------------------+
                                                        | Cloud Dashboard / App UI  |
                                                        +---------------------------+

Mục tiêu dự án

  1. Nghiên cứu và huấn luyện mô hình BNN: Áp dụng kiến trúc FracBNN kết hợp ResNet-20 trên tập dữ liệu chuẩn CNRPark+EXT, thực hiện lượng tử hóa trọng số và hàm kích hoạt về dạng 1-bit/2-bit mà vẫn duy trì độ chính xác phân loại tương đương mạng số thực (FP32).
  2. Thiết kế bộ mã hóa dữ liệu đầu vào (Thermometer Encoder): Chuyển đổi các khối ảnh màu $32 \times 32 \times 3$ sang miền nhị phân tối ưu cho việc tính toán bằng cổng logic phần cứng.
  3. Hiện thực bộ tăng tốc phần cứng trên FPGA: Sử dụng Vivado HLS để tổng hợp logic tính toán song song XNOR-Popcount, đóng gói thành IP Core giao tiếp qua bus AXI4-Stream với bộ xử lý ARM.
  4. Đánh giá hiệu năng và triển khai thực tế: Thực thi kiểm thử thời gian thực trên board nhúng Ultra96-V2, đo lường độ trễ (latency), tốc độ khung hình (FPS), điện năng tiêu thụ và so sánh với nền tảng GPU nhúng (Nvidia Jetson Nano).

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

  • Phạm vi: Nhận diện trạng thái trống (Free) hoặc có xe (Busy) của từng ô đỗ xe dựa trên patch ảnh kích thước $32 \times 32$ pixels được cắt từ khung hình camera giám sát góc nhìn cố định.
  • Giới hạn: Không tích hợp nhận dạng biển số xe (ALPR) trực tiếp trong cùng một luồng suy luận của bộ gia tốc BNN; việc xác định tọa độ ô đỗ ban đầu được cấu hình thông qua ma trận vùng quan tâm (Region of Interest - ROI).

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

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

Trước khi đi vào thiết kế chuyên sâu, đồ án tiến hành đánh giá toàn diện các phương pháp giám sát bãi đỗ xe hiện hành trên thị trường quốc tế và Việt Nam.

Tiêu chí Cảm biến IoT (SENSIT, Cisco) Xử lý Cloud (mAlexNet/VGG) Edge GPU (Jetson Nano) Edge FPGA BNN (Đồ án đề xuất)
Chi phí triển khai Rất cao (1 cảm biến/ô) Cao (Chi phí máy chủ/băng thông) Trung bình (Giá phần cứng GPU) Tối ưu (Tái dụng camera sẵn có)
Độ bền thiết bị Thấp (Dễ hỏng do môi trường) Rất cao (Đặt tại Data Center) Trung bình Cao (Khả năng chịu nhiệt công nghiệp)
Độ trễ suy luận 1 - 5 giây 500ms - 2s (Phụ thuộc mạng) 30 - 60ms (Mô hình tiêu chuẩn) < 15ms (Thời gian thực)
Băng thông mạng Rất thấp (Chỉ gửi trạng thái) Cực cao (Gửi video 1080p liên tục) Thấp (Chỉ gửi metadata) Cực thấp (Chỉ gửi metadata kết quả)
Công suất tiêu thụ Pin 3-5 năm Hàng trăm kW tại server 5W - 10W 2.5W - 4.2W
Tính linh hoạt Không thể nâng cấp tính năng Dễ nâng cấp phần mềm Dễ lập trình lại Lập trình lại được logic phần cứng

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

  • Must have (Bắt buộc):
    • Tốc độ xử lý đạt $\ge 30$ FPS trên dữ liệu ảnh $32 \times 32$.
    • Độ chính xác phân loại (Classification Accuracy) trên tập CNRPark đạt $\ge 90%$.
    • Mạch tăng tốc chạy hoàn toàn trên Programmable Logic (PL) của Ultra96-V2 mà không cần kết nối máy chủ khi suy luận.
  • Should have (Nên có):
    • Công suất tiêu thụ tổng thể hệ thống duy trì dưới 5W.
    • Tích hợp pipeline giao tiếp Direct Memory Access (DMA) để tối ưu truyền dữ liệu giữa bộ nhớ DDR và mảng logic FPGA.
  • Could have (Có thể mở rộng):
    • Tự động phát hiện và đánh dấu tọa độ ô đỗ xe không cần căn chỉnh thủ công ban đầu.
  • Won't have (Chưa thực hiện):
    • Xử lý nhận dạng ký tự quang học (OCR) biển số xe trực tiếp trên cùng IP Core BNN trong phiên bản này.

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm hai phân vùng chính theo mô hình Heterogeneous System-on-Chip:

+---------------------------------------------------------------------------------------+
|                                    XILINX ZYNQ MPSoC                                  |
|                                                                                       |
|  +---------------------------------------+   AXI-Lite    +-------------------------+  |
|  | Processing System (PS)                | ------------> | Control Registers       |  |
|  | - Quad-core ARM Cortex-A53 @ 1.2GHz   |               +-------------------------+  |
|  | - PYNQ Linux OS (v2.6) / Python Driver|                                            |
|  | - Memory Management (pynq.allocate)   |   AXI4-Stream +-------------------------+  |
|  | - LPDDR4 Controller (2GB RAM)         | <===========> | AXI DMA Engine          |  |
|  +---------------------------------------+   (via HP)    +-------------------------+  |
|                                                                      || AXI-Stream    |
|  +-------------------------------------------------------------------||-------------+  |
|  | Programmable Logic (PL)                                           \/             |  |
|  |  +---------------------+      +---------------------+      +------------------+  |  |
|  |  | Thermometer Encoder | ---> | Binary Conv Engine  | ---> | Batch Normal-    |  |  |
|  |  | (Bit-plane Gen)     |      | (XNOR + Popcount)   |      | ization / Sign   |  |  |
|  |  +---------------------+      +---------------------+      +------------------+  |  |
|  |            ^                            |                           |            |  |
|  |            |                            v                           |            |  |
|  |    Weight BRAM Buffer <======== Custom On-chip Storage <============+            |  |
|  +----------------------------------------------------------------------------------+  |
+---------------------------------------------------------------------------------------+

Ngăn xếp công nghệ (Technology Stack)

  • Framework phần mềm AI: PyTorch v1.10.0 (Torchvision v0.11.1), CUDA Toolkit v11.3 (dùng trong pha huấn luyện).
  • Công cụ EDA & Phần cứng: Xilinx Vivado Design Suite v2020.2, Vivado High-Level Synthesis (HLS) v2020.2.
  • Nền tảng nhúng: PYNQ Framework v2.6.0 trên hệ điều hành nhân Linux Ubuntu 18.04 LTS (AArch64).
  • Phần cứng mục tiêu: Avnet Ultra96-V2 chứa chip Xilinx Zynq UltraScale+ MPSoC ZU3EG (SBVA484).

Thông số phần cứng FPGA Xilinx Zynq UltraScale+ ZU3EG

  • Logic Cells: 154,350.
  • Lookup Tables (LUTs): 70,560.
  • Flip-Flops (FFs): 141,120.
  • Block RAM (BRAM): 216 blocks (khoảng 7.6 MB dung lượng on-chip memory).
  • DSP Slices: 360 slices.

Phương pháp nghiên cứu (Methodology)

Quy trình phát triển tuân theo mô hình HW/SW Co-Design V-Model, chia thành 3 giai đoạn then chốt:

[1. Thu thập & Tiền xử lý]       [2. Huấn luyện & Lượng tử hóa]      [3. Tổng hợp & Triển khai]
CNRPark+EXT Dataset           -> PyTorch Model (STE / FracBNN)    -> Vivado HLS C++ Core
(Cắt patch 32x32, cân bằng)      (Loss: Cross-Entropy, AdamW)        (Pragmas, Pipeline, Bitwise)
                                                                                  |
                                                                                  v
[6. Đánh giá & So sánh]         [5. Tích hợp Hệ điều hành PYNQ]     [4. Vivado Block Design]
Ultra96-V2 vs Jetson Nano     <- Python Overlays & DMA Buffers    <- AXI Interconnect + DMA IP
  • Tiến độ thực hiện: 19/09/2022 – 09/01/2023.
  • Quản trị rủi ro: Hiện tượng sụt giảm độ chính xác nghiêm trọng khi lượng tử hóa xuống 1-bit được khắc phục bằng cách sử dụng giải thuật ước lượng gradient thẳng (Straight-Through Estimator - STE) và kỹ thuật mã hóa Thermometer cho lớp đầu vào thay vì binarize trực tiếp.

Implementation và kết quả

Quá trình phát triển phần mềm và phần cứng

1. Nguyên lý tính toán nơ-ron nhị phân (BNN Mathematical Core)

Trong mạng CNN chuẩn (FP32), phép tích chập giữa ma trận đầu vào $\mathbf{X}$ và trọng số $\mathbf{W}$ tiêu tốn hàng triệu phép nhân-cộng số thực (MACs):

$$\mathbf{S} = \sum_{i=1}^{N} X_i \cdot W_i$$

Trong kiến trúc BNN, trọng số và kích hoạt được nhị phân hóa về ${-1, +1}$ thông qua hàm Sign:

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

Khi $X_b, W_b \in {-1, +1}$, phép nhân đại số được thay thế chính xác bằng cổng logic XNOR, và phép tích lũy được thay bằng bộ đếm số lượng bit 1 (Popcount):

$$\mathbf{X} \circledast \mathbf{W} = 2 \times \text{Popcount}(\text{XNOR}(X_b, W_b)) - N$$

import torch
import torch.nn as nn

class BinaryActivationSTE(torch.autograd.Function):
    """
    Straight-Through Estimator (STE) cho hàm lượng tử hóa nhị phân 1-bit.
    Forward: Trả về giá trị nhị phân {-1, +1}.
    Backward: Truyền thẳng gradient nếu giá trị nằm trong khoảng [-1, 1].
    """
    @staticmethod
    def forward(ctx, input_tensor):
        ctx.save_for_backward(input_tensor)
        return torch.sign(input_tensor)

    @staticmethod
    def backward(ctx, grad_output):
        input_tensor, = ctx.saved_tensors
        # Cắt gradient ngoài khoảng [-1, 1] để ổn định huấn luyện
        grad_input = grad_output.clone()
        grad_input[input_tensor.abs() > 1.0] = 0
        return grad_input

class BinaryConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=1):
        super(BinaryConv2d, self).__init__()
        self.stride = stride
        self.padding = padding
        self.shape = (out_channels, in_channels, kernel_size, kernel_size)
        self.weight = nn.Parameter(torch.rand(self.shape) * 0.001, requires_grad=True)

    def forward(self, x):
        # Nhị phân hóa trọng số và kích hoạt
        real_weights = self.weight
        binary_weights = BinaryActivationSTE.apply(real_weights)
        binary_x = BinaryActivationSTE.apply(x)
        return nn.functional.conv2d(binary_x, binary_weights, stride=self.stride, padding=self.padding)

2. Tối ưu hóa phần cứng bằng Vivado HLS (C++ Engine)

Bộ tăng tốc được hiện thực bằng ngôn ngữ C++ trong Vivado HLS, sử dụng triệt để các directive pragma nhằm tăng mức độ song song hóa phần cứng:

#include <ap_int.h>
#include <hls_stream.h>

#define KERNEL_SIZE 3
#define IN_CHANNELS 64
#define OUT_CHANNELS 64

typedef ap_uint<64> bit_vector_t;

void binary_conv_engine(
    hls::stream<bit_vector_t> &in_stream,
    hls::stream<ap_int<16>> &out_stream,
    const bit_vector_t weights[OUT_CHANNELS][KERNEL_SIZE][KERNEL_SIZE]
) {
    #pragma HLS INTERFACE axis port=in_stream
    #pragma HLS INTERFACE axis port=out_stream
    #pragma HLS INTERFACE s_axilite port=return bundle=CTRL_BUS

    bit_vector_t window[KERNEL_SIZE][KERNEL_SIZE];
    #pragma HLS ARRAY_PARTITION variable=window complete dim=0

    // Đọc luồng dữ liệu và thực hiện tính toán song song
    for (int oc = 0; oc < OUT_CHANNELS; ++oc) {
        #pragma HLS PIPELINE II=1
        ap_int<16> accumulator = 0;

        for (int kh = 0; kh < KERNEL_SIZE; ++kh) {
            #pragma HLS UNROLL
            for (int kw = 0; kw < KERNEL_SIZE; ++kw) {
                #pragma HLS UNROLL
                // Phép toán cốt lõi: XNOR kết hợp với bộ đếm bit popcount
                bit_vector_t xnor_val = ~(window[kh][kw] ^ weights[oc][kh][kw]);
                ap_int<8> bit_count = 0;
                
                for (int b = 0; b < 64; ++b) {
                    #pragma HLS UNROLL
                    bit_count += xnor_val[b];
                }
                accumulator += (2 * bit_count - 64);
            }
        }
        out_stream.write(accumulator);
    }
}

3. Điều khiển suy luận qua PYNQ Driver trên ARM Cortex-A53

Phần mềm trên Processing System (PS) quản lý việc cấp phát bộ nhớ vật lý liên tục (Contiguous Memory Allocation - CMA) và điều khiển luồng AXI DMA:

from pynq import Overlay, allocate
import numpy as np

# Nạp Bitstream vào FPGA
overlay = Overlay('/home/xilinx/pynq/overlays/bnn_parking/bnn_parking.bit')
dma = overlay.axi_dma_0

def infer_parking_patch(image_patch_32x32):
    """
    Truyền dữ liệu patch ảnh qua DMA tới bộ tăng tốc BNN trên PL
    """
    # Cấp phát bộ nhớ đệm DMA
    input_buffer = allocate(shape=(32, 32, 3), dtype=np.uint8)
    output_buffer = allocate(shape=(2,), dtype=np.int16)

    # Sao chép dữ liệu ảnh vào DMA buffer
    input_buffer[:] = image_patch_32x32

    # Kích hoạt truyền dữ liệu non-blocking
    dma.sendchannel.transfer(input_buffer)
    dma.recvchannel.transfer(output_buffer)
    
    dma.sendchannel.wait()
    dma.recvchannel.wait()

    # Phân loại trạng thái: 0 = Free, 1 = Busy
    result = np.argmax(output_buffer)
    return "Busy" if result == 1 else "Free"

Kiểm thử và đánh giá thực nghiệm

Mô hình được kiểm thử trên tập dữ liệu chuẩn quốc tế CNRPark+EXT bao gồm hơn 150,000 ảnh chụp các vị trí đỗ xe trong nhiều điều kiện thời tiết khác nhau (nắng gắt, nhiều mây, mưa, ban đêm).

                 +---------------------------------------+
                 |          Predicted Class              |
                 |     Free (0)     |     Busy (1)       |
+----------------+------------------+--------------------+
| Actual Free (0)| True Neg (TN)    | False Pos (FP)     |
|                |      94.6%       |       5.4%         |
+----------------+------------------+--------------------+
| Actual Busy (1)| False Neg (FN)   | True Pos (TP)      |
|                |       3.8%       |      96.2%         |
+----------------+------------------+--------------------+
  • Accuracy: $95.4%$ trên tập kiểm thử phân loại trạng thái vị trí đỗ xe.
  • Precision: $94.7%$.
  • Recall: $96.2%$.
  • F1-Score: $0.954$.

Tài nguyên phần cứng tiêu thụ trên Ultra96-V2 (ZU3EG)

Thành phần tài nguyên Khả dụng trên chip Tài nguyên sử dụng Tỷ lệ sử dụng (%)
LUT (Look-up Table) 70,560 41,280 58.5%
FF (Flip-Flop) 141,120 52,430 37.1%
BRAM (Block RAM 36Kb) 216 128 59.2%
DSP48 Slices 360 18 5.0% (Tiết kiệm tối đa)

Ghi chú: Việc số lượng DSP chỉ chiếm 5% chứng minh rằng phần lớn các phép toán đã được chuyển đổi thành công từ nhân số thực (DSP-intensive) sang mảng logic LUTs/FFs nhị phân.


Kết quả đạt được và so sánh hiệu năng

So sánh toàn diện giữa giải pháp FPGA Ultra96-V2 của đồ án với giải pháp GPU nhúng (Nvidia Jetson Nano) và giải pháp luận văn khóa trước (Vien's thesis - YOLOv3-tiny):

Chỉ số đánh giá Base Group (HK192 - CNV) Vien's Thesis (YOLOv3-tiny) Nvidia Jetson Nano (VGG-16) Đồ án này (FracBNN Ultra96-V2)
Nền tảng phần cứng Ultra96-V2 Ultra96-V2 Jetson Nano 128-core Ultra96-V2 MPSoC
Độ trễ (Latency) 16.0 ms 45.2 ms 32.8 ms 12.45 ms
Tốc độ (FPS) 62.5 FPS 22.1 FPS 30.4 FPS 80.3 FPS
Công suất tiêu thụ 3.8 W 4.9 W 8.6 W 2.9 W
Năng lượng / Khung hình 60.8 mJ/frame 221.4 mJ/frame 282.0 mJ/frame 36.1 mJ/frame
Độ chính xác (Top-1) 88.2% 91.0% 94.8% 95.4%
Tốc độ khung hình (FPS) [Cao hơn là tốt hơn]:
Base Group (CNV)     : [=============] 62.5 FPS
Vien (YOLOv3-tiny)   : [====] 22.1 FPS
Jetson Nano (GPU)    : [======] 30.4 FPS
Đồ án (FracBNN FPGA) : [=================] 80.3 FPS

Hiệu suất năng lượng (mJ / Khung hình) [Thấp hơn là tốt hơn]:
Base Group (CNV)     : [===========] 60.8 mJ
Vien (YOLOv3-tiny)   : [==============================] 221.4 mJ
Jetson Nano (GPU)    : [======================================] 282.0 mJ
Đồ án (FracBNN FPGA) : [======] 36.1 mJ

Đổi mới và đóng góp khoa học

  1. Ứng dụng thành công cấu trúc FracBNN kết hợp bộ mã hóa Thermometer: Giải quyết bài toán suy giảm độ chính xác nghiêm trọng ở lớp tích chập đầu tiên của mạng BNN truyền thống, cho phép đưa ảnh RGB trực tiếp vào mạng nhị phân mà không làm bùng nổ tài nguyên DSP.
  2. Triệt tiêu 95% nhu cầu sử dụng khối nhân DSP: Thay thế toàn bộ phép tính tích chập phức tạp bằng chuỗi logic nhị phân XNOR + Popcount, tận dụng tối đa kiến trúc mảng LUTs phong phú của công nghệ UltraScale+.
  3. Cải thiện 7.8x hiệu suất năng lượng so với GPU nhúng: Đạt mức tiêu thụ năng lượng cực thấp (36.1 mJ/frame so với 282.0 mJ/frame của Jetson Nano), mở ra khả năng triển khai các trạm camera quan sát thông minh sử dụng pin hoặc năng lượng mặt trời.
  4. Quy trình HW/SW Co-design hoàn chỉnh: Xây dựng cầu nối thông suốt từ khâu huấn luyện cấp cao trên PyTorch, tự động xuất trọng số, tổng hợp phần cứng qua Vivado HLS đến nạp thực thi trực tiếp bằng PYNQ Python Driver.

Ứ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ế để kết nối trực tiếp với hệ thống camera IP có sẵn tại các bãi đỗ xe thương mại, tầng hầm chung cư hoặc bãi xe thông minh ngoài trời.

[Bãi đỗ xe]                 [Trạm xử lý biên - Edge Node]             [Đầu cuối / Người dùng]
+---------------+           +-----------------------------+           +-------------------+
| 4x IP Cameras | --RTSP--> | Ultra96-V2 Edge AI Node     | --JSON--> | Web Dashboard     |
| (Covering     |           | - Crop 64 parking slots     | (MQTT)    | (Bản đồ chỗ trống)|
|  64 slots)    |           | - FPGA Pipeline Inference   |           |                   |
+---------------+           | - Batch processing @ 80 FPS |           | Mobile User App   |
                            +-----------------------------+           +-------------------+

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

  • Khuôn viên thử nghiệm: Bãi đỗ xe quy mô 200 vị trí.
  • Chi phí giải pháp cảm biến IoT truyền thống: $200 \text{ cảm biến} \times 45\text{ USD} + 2,000\text{ USD (Bộ thu phát trung tâm)} = 11,000\text{ USD}$. Chi phí thay pin định kỳ mỗi 2 năm: $1,500\text{ USD}$.
  • Chi phí giải pháp Edge FPGA (Đồ án đề xuất): 4 camera góc rộng ($4 \times 100\text{ USD}$) + 1 bộ điều khiển Ultra96-V2 ($350\text{ USD}$) + Phụ kiện/Vỏ bảo vệ ($150\text{ USD}$) = $900\text{ USD}$.
  • Mức tiết kiệm chi phí đầu tư ban đầu: Đạt trên $91.8%$ so với phương án dùng cảm biến vật lý.

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

Hạn chế hiện tại

  • Kích thước đầu vào cố định: Mô hình hiện tại tối ưu hóa trên kích thước ảnh patch $32 \times 32$ pixels, có thể gặp hiện tượng giảm độ chính xác nếu góc đặt camera quá xa khiến độ phân giải thực tế của ô đỗ xe bị mờ hoặc méo hình quá mức.
  • Phụ thuộc cấu hình ROI ban đầu: Vị trí các ô đỗ xe cần được thiết lập tọa độ ban đầu thông qua giao diện cấu hình quản trị trước khi đưa vào luồng nhận diện tự động.

Hướng phát triển tiếp theo

  • Tích hợp mô hình phát hiện tự động (Auto-Slot Detection): Kết hợp mạng Binarized Object Detection nhẹ để tự động tìm và cập nhật tọa độ ô đỗ xe khi vạch sơn bị mờ hoặc bãi xe thay đổi layout.
  • Mở rộng nhận diện đa tác vụ (Multi-task Edge Node): Tận dụng phần tài nguyên logic còn trống (41.5% LUTs, 40.8% BRAM) để tích hợp song song module nhận dạng biển số xe (ALPR) dạng 1-bit nhị phân trên cùng một chip ZU3EG.

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

  • Sinh viên và Nghiên cứu sinh: Cung cấp tài liệu tham khảo thực tế về phương pháp luận đồng thiết kế phần cứng - phần mềm (HW/SW Co-Design), kỹ thuật lượng tử hóa mạng nơ-ron nhị phân BNN và quy trình lập trình HLS trên dòng chip Xilinx Zynq UltraScale+.
  • Kỹ sư Hệ thống Nhúng & AI: Nắm bắt giải pháp tối ưu hóa bộ nhớ, kỹ thuật ánh xạ phép toán XNOR-Popcount trên mảng FPGA và phương pháp điều khiển DMA hiệu năng cao thông qua Python PYNQ.
  • Doanh nghiệp và Nhà vận hành Bãi xe: Tiếp cận phương án công nghệ chi phí thấp, độ bền cao, tận dụng hạ tầng camera sẵn có để hiện đại hóa hệ thống quản lý bãi đỗ xe tự động mà không cần đầu tư máy chủ đắt đỏ.

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 bộ tăng tốc này là gì?

Về phần cứng, bạn cần board nhúng Avnet Ultra96-V2 (hoặc bất kỳ kit phát triển nào tích hợp chip Xilinx Zynq UltraScale+ MPSoC ZU3EG trở lên), thẻ nhớ microSD tối thiểu 16GB (Class 10), nguồn cấp DC 12V/2A. Về phần mềm, hệ thống yêu cầu image PYNQ v2.6, Xilinx Vivado/Vivado HLS 2020.2 và thư viện PyTorch 1.10 để huấn luyện mô hình.

2. Tại sao BNN lại chạy trên FPGA nhanh và tiết kiệm điện hơn nhiều so với GPU?

GPU truyền thống được tối ưu hóa cho các phép tính số thực dấu phẩy động 32-bit (FP32) hoặc 16-bit (FP16) bằng các khối nhân số học lớn. Khi chạy mô hình nhị phân 1-bit, GPU vẫn phải sử dụng thanh ghi và ALU đa bit gây lãng phí tài nguyên. Ngược lại, FPGA cho phép tổng hợp trực tiếp các cổng logic XNOR và mạch đếm Popcount ở cấp độ phần cứng bằng các bảng tra LUT 6 đầu vào, loại bỏ hoàn toàn nhu cầu dùng bộ nhân phức tạp và giảm thiểu tối đa năng lượng nạp/xả tụ điện.

3. Hệ thống xử lý thế nào khi thời tiết mưa lớn, sương mù hoặc ban đêm?

Tập dữ liệu huấn luyện CNRPark+EXT chứa hàng chục nghìn mẫu ảnh chụp trong các điều kiện thời tiết phức tạp (mưa, thiếu sáng, chói lóa). Do đó, mô hình FracBNN đã học được các đặc trưng không gian mạnh mẽ, duy trì độ chính xác nhận diện trên 92% ngay cả trong điều kiện ánh sáng yếu vào ban đêm.

4. Chi phí bảo trì của bộ tăng tốc FPGA so với máy chủ Cloud như thế nào?

Bộ tăng tốc FPGA biên tiêu thụ dưới 3W điện năng, không phát sinh chi phí duy trì máy chủ hàng tháng và không yêu cầu băng thông Internet tốc độ cao để truyền tải video liên tục. Chi phí bảo trì định kỳ gần như bằng không do thiết bị không có bộ phận chuyển động cơ học và có thể hoạt động liên tục 24/7 trong nhiều năm.

5. Có thể nâng cấp mô hình AI sau khi đã đóng gói thành file Bitstream nạp vào FPGA không?

Hoàn toàn có thể. Nhờ tính chất tái cấu hình linh hoạt (Reconfigurability) của FPGA, khi cần cập nhật cấu trúc mạng hoặc tập trọng số mới, kỹ sư chỉ cần nạp lại file .bit và cập nhật file driver .py thông qua giao diện mạng của PYNQ trong vòng vài giây mà không cần thay thế phần cứ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 Tình Trạng Chỗ Đỗ Xe Theo Thời Gian Thực" của sinh viên Nguyễn Vũ Thành Nguyễn đã chứng minh tính khả thi và ưu thế vượt trội của việc áp dụng mô hình Binary Neural Network (FracBNN) trên nền tảng phần cứng Xilinx Zynq UltraScale+ MPSoC Ultra96-V2. Với tốc độ xử lý vượt trội đạt 80.3 FPS, độ trễ suy luận chỉ 12.45 ms, độ chính xác phân loại 95.4% cùng mức tiêu thụ công suất ấn tượng chỉ 2.9W, nghiên cứu đã mang lại một giải pháp công nghệ toàn diện, giải quyết triệt để bài toán chi phí và hiệu năng cho các đô thị thông minh trong kỷ nguyên chuyển đổi số.