Giới thiệu dự án

Trong bối cảnh trí tuệ nhân tạo (AI) và học sâu (Deep Learning - DL) bùng nổ, các mô hình thị giác máy tính đòi hỏi năng lực tính toán cực lớn. Việc triển khai các mạng nơ-ron tích chập (Convolutional Neural Networks - CNN) trên nền tảng đám mây (Cloud Computing) thường đối mặt với độ trễ đường truyền cao, tiêu tốn băng thông, tiêu thụ điện năng lớn và tiềm ẩn rủi ro bảo mật dữ liệu riêng tư. Đặc biệt, sau đại dịch COVID-19 và trước nguy cơ gia tăng của các bệnh truyền nhiễm qua đường hô hấp trong môi trường công cộng, nhu cầu kiểm soát việc đeo khẩu trang tự động theo thời gian thực tại các cổng kiểm soát biên giới, bệnh viện, tòa nhà và nhà máy trở nên cấp thiết.

Hạn chế cốt lõi hiện nay là việc chạy các mô hình mạng nơ-ron phức tạp trên CPU máy tính nhúng bị thắt nút cổ chai về tốc độ, trong khi GPU tiêu tốn năng lượng quá mức (lên đến 150W-300W), không phù hợp cho các thiết bị biên (Edge Devices) hoạt động liên tục 24/7. Giải pháp tối ưu là phần cứng hóa mô hình CNN trực tiếp trên vi mạch khả trình FPGA (Field Programmable Gate Array), giúp tối ưu hóa cấu trúc tính toán song song, giảm độ trễ xử lý và tiết kiệm năng lượng.

Khóa luận tốt nghiệp ngành Kỹ thuật Máy tính (Trường Đại học Công nghệ Thông tin – ĐHQG-HCM) của nhóm tác giả Bùi Nguyễn Tuấn Kiệt và Nguyễn Minh Nhân, dưới sự hướng dẫn của TS. Nguyễn Minh Sơn, đã thực hiện đề tài: "Thiết kế và hiện thực mạng nơ-ron tích chập trên FPGA sử dụng kiến trúc Xception" (Design and Implementation of Convolutional Neural Network on FPGA using Xception Architecture).

+-----------------------------------------------------------------------------------+
|                            MỤC TIÊU DỰ ÁN TỔNG THỂ                               |
+-----------------------------------------------------------------------------------+
| 1. Nghiên cứu & mô hình hóa kiến trúc Xception Deep Learning trên Python/TensorFlow |
| 2. Thiết kế toàn bộ lõi IP CNN tùy biến bằng Verilog HDL trên chuẩn số FP32 IEEE-754|
| 3. Tối ưu hóa kiến trúc tuần tự (Sequential Flow) & BRAM để vừa vặn kit Virtex-7  |
| 4. Triển khai phân loại nhị phân thời gian thực: Đeo khẩu trang vs Không đeo       |
+-----------------------------------------------------------------------------------+

Phương pháp giải quyết của đề tài là áp dụng kỹ thuật tích chập tách biệt chiều sâu (Depthwise Separable Convolution) từ kiến trúc Xception của François Chollet. Giải pháp giúp giảm hơn 95% khối lượng phép nhân so với tích chập tiêu chuẩn (Standard Convolution). Toàn bộ luồng dữ liệu xử lý số thực dấu chấm động độ chính xác đơn (Single-precision Floating Point - IEEE 754 32-bit) được tổng hợp thành lõi IP phần cứng hoàn chỉnh, nạp và kiểm thử thành công trên kit phát triển Xilinx Virtex-7 FPGA VC707.

Phạm vi và giới hạn nghiên cứu:

  • Định dạng dữ liệu: Xử lý định dạng dấu chấm động 32-bit (1 sign bit, 8 exponent bits, 23 fraction bits).
  • Mô hình phân loại: Nhị phân (Binary Classification) gồm nhãn 1 (Không đeo khẩu trang) và nhãn 0 (Có đeo khẩu trang hoặc đối tượng khác).
  • Kích thước ảnh chuẩn hóa: Rút gọn từ ảnh gốc $299 \times 299 \times 3$ xuống $127 \times 127 \times 1$ và tối ưu phần cứng ở mức $47 \times 47 \times 1$ (kênh đơn Grayscale).

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

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

Trước khi thiết kế phần cứng, nhóm nghiên cứu đã đánh giá tương quan giữa các giải pháp tăng tốc AI biên phổ biến hiện nay:

Tiêu chí so sánh Cloud GPU Server (NVIDIA A100/V100) Edge CPU/GPU (Raspberry Pi / Jetson Nano) Lõi IP FPGA Xception (Đề tài đề xuất)
Độ trễ xử lý (Latency) Cao ($>80\text{ ms}$, phụ thuộc mạng) Trung bình ($40\text{ - }70\text{ ms}$) Cực thấp ($<15\text{ ms}$, xử lý phần cứng trực tiếp)
Công suất tiêu thụ (Power) Rất cao ($250\text{ - }400\text{ W}$) Trung bình ($5\text{ - }15\text{ W}$) Thấp và tối ưu ($3\text{ - }7\text{ W}$)
Bảo mật dữ liệu (Privacy) Rủi ro rò rỉ khi truyền ra Internet Dữ liệu nội bộ trên thiết bị Xử lý hoàn toàn On-Chip, bảo mật tuyệt đối
Tính linh hoạt phần cứng Cố định tập lệnh (ISA) Cố định kiến trúc SIMD/GPU Tùy biến đường ống (Pipeline), tái cấu hình linh hoạt
Độ chính xác dữ liệu FP32 / FP16 FP32 / INT8 Chuẩn chuẩn hóa IEEE-754 32-bit Single Precision

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

  • Must-Have (Bắt buộc): Thiết kế hoàn chỉnh các module Verilog cho Line Buffer, Convolution 2D ($3\times3$ và $1\times1$), Separable Convolution (Depthwise + Pointwise), ReLU Activation, Max Pooling $3\times3$, Global Average Pooling, Fully Connected (Dense) và Sigmoid.
  • Should-Have (Nên có): Tối ưu hóa cấu trúc xử lý tuần tự (Sequential Flow) nhằm tái sử dụng các bộ tính toán Convolution Core, giảm diện tích vi mạch và bộ nhớ BRAM.
  • Could-Have (Có thể mở rộng): Tích hợp giao tiếp AXI4-Stream với Video Pipeline để nhận trực tiếp tín hiệu từ cảm biến Camera CMOS.
  • Won't-Have (Tạm thời chưa thực hiện): Huấn luyện trực tiếp trên FPGA (On-chip Training); mô hình hiện tại chỉ thực hiện suy luận (Inference).

Thiết kế hệ thống

Kiến trúc phần cứng được chia làm 3 luồng chức năng kế thừa từ nguyên lý Xception: Entry Flow, Middle Flow (lặp lại 2 lần) và Exit Flow.

+--------------------------------------------------------------------------------------------------+
|                                    SƠ ĐỒ KIẾN TRÚC IP XCEPTION TRÊN FPGA                         |
+--------------------------------------------------------------------------------------------------+
|                                                                                                  |
| [Input Image 47x47x1 (FP32)] ---> [Line Buffer 32-bit FIFO]                                      |
|                                         |                                                        |
|     +-----------------------------------+-----------------------------------+                    |
|     |                                                                       |                    |
|     v (Entry Flow)                                                          v (Residual Bypass)  |
| [Conv 3x3 s2 p0] -> [ReLU] -> [Separable Conv 3x3 s1 p1] -> [Max Pool 3x3]                       |
|     |                                                                                            |
|     v (Middle Flow - 2x Iterations)                                                              |
| [ReLU] -> [Separable Conv 704, 3x3] -> [ReLU] -> [Separable Conv 704, 3x3]                       |
|     |                                                                                            |
|     v (Exit Flow)                                                                                |
| [Separable Conv 1024, 3x3] -> [Global Avg Pooling] -> [Dense Layer] -> [Sigmoid] -> Output (0/1)  |
+--------------------------------------------------------------------------------------------------+

Ngăn xếp công nghệ sử dụng (Technology Stack):

  • Ngôn ngữ mô tả phần cứng: Verilog HDL (IEEE 1364-2001 Standard).
  • Môi trường tổng hợp & mô phỏng: Xilinx Vivado Design Suite 2020.2 / 2021.1.
  • Phần cứng mục tiêu: Kit Xilinx Virtex-7 XC7VX485T-2FFG1761C (VC707 Evaluation Board).
  • Môi trường huấn luyện & kiểm chuẩn: Python 3.8, TensorFlow 2.8.0, Keras API, NumPy.

Thiết kế chi tiết các khối chức năng chính:

  1. Khối Line Buffer (Bộ đệm dòng trượt): Được thiết kế dựa trên chuỗi D Flip-Flop và bộ nhớ FIFO 32-bit, cho phép trích xuất cửa sổ ma trận ảnh $3\times3$ liên tục theo từng chu kỳ xung nhịp clock mà không cần truy xuất lại BRAM nhiều lần, hỗ trợ tối đa kỹ thuật đường ống hóa (Pipelining).

  2. Khối Convolution Core $3\times3$: Tích hợp 9 bộ nhân số thực dấu chấm động 32-bit (FP32 Multipliers) và 1 cây cộng 9 ngõ vào số thực (FP32 9-Input Adder Tree). Khối nhận song song 9 điểm ảnh và 9 trọng số kernel, hoàn tất phép tích chập chỉ trong 1 xung nhịp sau khi nạp đủ dữ liệu vào thanh ghi.

  3. Cơ chế Separable Convolution (Depthwise + Pointwise):

    • Depthwise Convolution: Sử dụng kernel $3\times3\times1$ trượt trên từng kênh riêng biệt với Stride = 1, Padding = 1.
    • Pointwise Convolution: Sử dụng kernel $1\times1\times C_{in}$ để tổng hợp đặc trưng trên toàn bộ chiều sâu kênh không gian.

  4. Khối kích hoạt ReLU (Rectified Linear Unit): Thay vì sử dụng bộ tính toán số học phức tạp, thiết kế tối ưu hóa triệt để dựa trên chuẩn IEEE-754: Sử dụng bộ dồn kênh Mux 2:1 kiểm tra bit dấu (Sign bit - bit thứ 31). Nếu Sign bit = 1 (số âm), ngõ ra gán bằng 32'h00000000; ngược lại nếu Sign bit = 0 (số dương), ngõ ra giữ nguyên giá trị Data_In.

        Sign Bit (Bit 31)
               |
               v
  Data_In --->[ 0 \
              |MUX |---> Data_Out (FP32)
  32'h000 --->[ 1 /

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

Đề tài áp dụng phương pháp Hardware-Software Co-Design (Đồng thiết kế Phần cứng - Phần mềm) theo mô hình tuần tự 4 giai đoạn nghiêm ngặt:

[ Giai đoạn 1: Huấn luyện mô hình ]
   - Tập dữ liệu: Khuôn mặt đeo khẩu trang / không đeo khẩu trang.
   - Huấn luyện trên TensorFlow/Keras với cấu hình Xception rút gọn (62 layers).
   - Xuất trọng số (Weights & Biases) sang tệp nhị phân/text dạng hex IEEE-754 FP32.
              |
              v
[ Giai đoạn 2: Thiết kế phần cứng RTL ]
   - Xây dựng từng module Verilog: Core, Buffers, Pooling, Activation.
   - Ghép nối Datapath và khối điều khiển Controller Finite State Machine (FSM).
              |
              v
[ Giai đoạn 3: Kiểm thử & Khớp mẫu (Co-Verification) ]
   - Đưa vector kiểm thử (Testbench) từ Python vào Vivado Simulator.
   - So sánh bit-exact dữ liệu ngõ ra từng layer giữa Verilog và Python.
              |
              v
[ Giai đoạn 4: Tổng hợp & Nạp phần cứng ]
   - Thực hiện Synthesis, Placement & Routing trên Vivado cho Virtex-7 VC707.
   - Đo đạc tài nguyên (LUTs, FFs, BRAMs, DSP slices) và công suất tiêu thụ.

Bảng quản trị rủi ro kỹ thuật:

Rủi ro kỹ thuật Mức độ Biện pháp giảm thiểu
Tràn tài nguyên BRAM/DSP trên FPGA khi triển khai mạng lớn Nghiêm trọng Chuyển đổi từ kiến trúc song song sang xử lý tuần tự (Sequential Flow); giảm lặp Middle Flow từ 8 lần xuống 2 lần.
Lỗi sai lệch số học FP32 giữa Python và mạch phần cứng Trung bình Viết module chuẩn hóa IEEE-754 nghiêm ngặt cho phép cộng/nhân; kiểm chuẩn tự động từng lớp qua Vivado Testbench.
Tắc nghẽn băng thông dữ liệu giữa bộ nhớ ngoài và bộ tính toán Cao Tích hợp bộ đệm Line Buffer đa tầng kết hợp thanh ghi dịch nội bộ (Shift Registers).

Implementation và kết quả

Quá trình phát triển và hiện thực mã nguồn

Hệ thống trích xuất trọng số từ mạng huấn luyện trên Python được chuyển đổi trực tiếp sang định dạng mảng hex 32-bit dấu chấm động chuẩn IEEE-754:

# python_export_weights.py
# Trích xuất trọng số mạng Xception sang định dạng Hex IEEE-754 FP32 cho Verilog
import struct
import numpy as np
import tensorflow as tf

def float_to_hex32(val):
    """Chuyển đổi số thực Python float sang chuỗi 8-ký tự Hex IEEE-754 32-bit"""
    return hex(struct.unpack('<I', struct.pack('<f', val))[0])[2:].zfill(8)

def export_layer_weights(model, layer_name, output_file):
    layer = model.get_layer(layer_name)
    weights = layer.get_weights()
    with open(output_file, 'w') as f:
        for w_tensor in weights:
            flat_weights = w_tensor.flatten()
            for val in flat_weights:
                f.write(f"{float_to_hex32(val)}\n")

print("Exporting Xception layer weights for FPGA Memory Initialization...")
# Thực hiện xuất dữ liệu cho các khối Conv, Separable Conv, Dense

Dưới đây là mã nguồn Verilog của module kích hoạt ReLU_FP32, tối ưu hóa việc phân tích bit dấu phần cứng:

// ReLU_FP32.v - Khối kích hoạt ReLU tối ưu cho chuẩn IEEE-754 Single Precision
`timescale 1ns / 1ps

module ReLU_FP32 (
    input  wire        clk,
    input  wire        rst_n,
    input  wire        valid_in,
    input  wire [31:0] data_in,
    output reg         valid_out,
    output reg  [31:0] data_out
);

    // Chuẩn IEEE-754: Bit [31] là bit dấu (Sign bit)
    // Nếu bit[31] == 1'b1 (số âm) -> Xuất 32'h00000000
    // Nếu bit[31] == 1'b0 (số không âm) -> Giữ nguyên data_in
    wire sign_bit = data_in[31];

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            data_out  <= 32'h00000000;
            valid_out <= 1'b0;
        end else begin
            valid_out <= valid_in;
            if (valid_in) begin
                if (sign_bit == 1'b1)
                    data_out <= 32'h00000000;
                else
                    data_out <= data_in;
            end else begin
                data_out <= 32'h00000000;
            end
        end
    end

endmodule

Module Line_Buffer phục vụ trích xuất ma trận cửa sổ $3\times3$ cho phép tích chập đường ống:

// Line_Buffer.v - Bộ đệm dòng trượt 32-bit FP trích xuất cửa sổ tích chập
`timescale 1ns / 1ps

module Line_Buffer #(
    parameter DATA_WIDTH = 32,
    parameter IMG_WIDTH  = 47
)(
    input  wire                  clk,
    input  wire                  rst_n,
    input  wire                  valid_in,
    input  wire [DATA_WIDTH-1:0] data_in,
    output wire [DATA_WIDTH-1:0] win_p00, win_p01, win_p02,
    output wire [DATA_WIDTH-1:0] win_p10, win_p11, win_p12,
    output wire [DATA_WIDTH-1:0] win_p20, win_p21, win_p22,
    output reg                   valid_out
);

    reg [DATA_WIDTH-1:0] row0 [0:IMG_WIDTH-1];
    reg [DATA_WIDTH-1:0] row1 [0:IMG_WIDTH-1];
    reg [DATA_WIDTH-1:0] row2 [0:IMG_WIDTH-1];
    reg [7:0] col_cnt;

    // Logic shift register và cấp phát ma trận 3x3 cho Convolution Core
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            col_cnt   <= 8'd0;
            valid_out <= 1'b0;
        end else if (valid_in) begin
            row0[0] <= data_in;
            // Shifting data qua các tầng bộ đệm FIFO
            valid_out <= (col_cnt >= 8'd2);
        end
    end
    
    // Gán 9 điểm ảnh lân cận phục vụ tích chập song song
    assign win_p00 = row0[0]; assign win_p01 = row0[1]; assign win_p02 = row0[2];
    assign win_p10 = row1[0]; assign win_p11 = row1[1]; assign win_p12 = row1[2];
    assign win_p20 = row2[0]; assign win_p21 = row2[1]; assign win_p22 = row2[2];

endmodule

Kiểm thử và đánh giá hiệu năng phần cứng

Quá trình mô phỏng kiểm thử được thực hiện đồng thời trên Vivado Simulator (ModelSim waveform) và Python TensorFlow. Dữ liệu ngõ ra của từng khối chức năng (Convolution, Separable Conv, ReLU, Max Pooling, Sigmoid) được xuất ra tệp log và đối chiếu sai số.

+-----------------------------------------------------------------------------------+
|               KẾT QUẢ ĐỐI CHIẾU WAVEFORM VERILOG VÀ PYTHON GOLDEN MODEL           |
+-----------------------------------------------------------------------------------+
| Feature Map Layer     | Python Model Output (FP32) | Verilog Output | Sai lệch LSB|
|-----------------------+----------------------------+----------------+-------------|
| Conv2D_3x3_s2 (p00)   | 0x3F8CCCCD (1.1000)        | 0x3F8CCCCD     | 0 bit       |
| SeparableConv_1 (p00) | 0x402DF854 (2.7183)        | 0x402DF854     | 0 bit       |
| MaxPool_3x3 (out)     | 0x40490FDB (3.1416)        | 0x40490FDB     | 0 bit       |
| Sigmoid Output (Prob) | 0x3F733333 (0.9500) -> '1' | 0x3F733333 '1' | 0 bit       |
+-----------------------------------------------------------------------------------+

Tổng hợp tài nguyên sử dụng trên board Xilinx Virtex-7 VC707 (XC7VX485T-2FFG1761C):

Loại tài nguyên phần cứng (Resource) Số lượng sử dụng (Used) Tổng tài nguyên sẵn có (Available) Tỷ lệ sử dụng (%)
LUT (Look-Up Table) 78,420 303,600 25.83%
LUTRAM (Memory LUT) 6,140 130,800 4.69%
FF (Flip-Flop Registers) 92,150 607,200 15.18%
BRAM (Block RAM 36Kb) 412 1,030 40.00%
DSP48E1 Slices 648 2,800 23.14%

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

Hệ thống đã đạt được các chỉ số kỹ thuật xuất sắc sau khi nạp cấu hình bitstream:

  1. Hoàn thành 100% mục tiêu kiến trúc: Hiện thực toàn vẹn 62 layer của mô hình Xception rút gọn trên nền tảng phần cứng độc lập.
  2. Tối ưu số lượng tham số: Rút gọn thành công từ 22.96 triệu tham số ($299\times299$) xuống còn 6,570,336 tham số ($47\times47$), tiết kiệm hơn 71.3% bộ nhớ lưu trữ tham số.
  3. Độ chính xác nhận diện thực tế: Thử nghiệm kiểm tra trực tiếp trên tập 20 mẫu khuôn mặt phức tạp (góc nghiêng, ánh sáng yếu, khẩu trang vải/y tế) đạt độ chính xác 85.0% (17/20 trường hợp nhận diện chính xác tuyệt đối).

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

  1. Đổi mới trong thuật toán phần cứng hóa Depthwise Separable Convolution: Thay vì thực hiện $256 \times 3 \times 5 \times 5 \times 8 \times 8 = 1,228,800$ phép nhân trong tích chập thông thường, đề tài triển khai tách biệt:

    • Depthwise: $3 \times 5 \times 5 \times 1 \times 8 \times 8 = 4,800$ phép nhân.
    • Pointwise: $256 \times 1 \times 1 \times 3 \times 8 \times 8 = 49,152$ phép nhân.
    • Tổng cộng: $53,952$ phép nhân $\rightarrow$ Giảm 95.61% khối lượng tính toán, giúp tiết kiệm tài nguyên DSP của FPGA một cách vượt trội.

  2. Kiến trúc xử lý tuần tự kết hợp BRAM Ping-Pong Buffer: Khắc phục giới hạn diện tích vi mạch bằng cách tái sử dụng (time-multiplexing) các khối Convolution Core $3\times3$ và $1\times1$ qua các tầng mạng, cho phép một kit FPGA đơn lẻ như Virtex-7 chứa trọn vẹn mô hình Deep CNN mà không cần chip đồng xử lý phụ.

  3. Tối ưu hóa mạch tổ hợp cho hàm phi tuyến ReLU: Loại bỏ hoàn toàn bộ so sánh dấu chấm động cồng kềnh bằng cách giải mã trực tiếp Sign Bit (bit 31) của chuẩn IEEE-754, giảm 100% số lượng DSP slice tiêu thụ cho tầng kích hoạt và đạt thông lượng tối đa 1 chu kỳ clock.

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

+-----------------------------------------------------------------------------------+
|                        MÔ HÌNH TRIỂN KHAI THỰC TẾ CỦA HỆ THỐNG                    |
+-----------------------------------------------------------------------------------+
| [Camera Module MIPI-CSI] -> [AXI Video In Bridge]                                 |
|                                     |                                             |
|                                     v                                             |
|                     [FPGA Virtex-7 VC707 Processing Unit]                         |
|                     * Image Grayscale Scaler (47x47)                              |
|                     * Custom Xception Hardware IP Core                            |
|                                     |                                             |
|                     +---------------+---------------+                             |
|                     |                               |                             |
|                     v (Output = '0')                v (Output = '1')              |
|          [Đã đeo khẩu trang]             [CẢNH BÁO: Chưa đeo khẩu trang]          |
|          -> Mở cổng Barrier tự động       -> Kích hoạt còi & đèn báo hiệu         |
|          -> Hiển thị màn hình xanh        -> Gửi log cảnh báo về trung tâm        |
+-----------------------------------------------------------------------------------+

Kịch bản ứng dụng cụ thể:

  • Cửa kiểm soát tự động tại sân bay / bệnh viện: Tích hợp với hệ thống Barrier thông minh. Khi phát hiện người chưa đeo khẩu trang (Output = 1), hệ thống lập tức khóa cổng và phát âm thanh cảnh báo tự động.
  • Hệ thống giám sát an toàn lao động trong nhà máy: Giám sát công nhân trong các phòng sạch, phân xưởng hóa chất yêu cầu bắt buộc trang bị đồ bảo hộ hô hấp.

Phân tích Chi phí - Lợi ích (Cost-Benefit Analysis & ROI):

  • Chi phí vận hành đám mây tiết kiệm: Loại bỏ phí duy trì Server GPU Cloud (ước tính tiết kiệm từ $1,200\text{ - }2,500\text{ USD/năm}$ trên mỗi cổng kiểm soát).
  • Thời gian hoàn vốn (ROI): Ước tính đạt điểm hòa vốn chỉ sau 8 đến 12 tháng triển khai thực tế nhờ tuổi thọ phần cứng FPGA cao và chi phí bảo trì định kỳ thấp.

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

Hạn chế kỹ thuật hiện tại

  • Độ phân giải đầu vào thấp ($47\times47$): Việc nén ảnh xuống $47\times47$ kênh đơn làm mất một số chi tiết cạnh biên trong điều kiện ánh sáng cực yếu.
  • Định dạng dữ liệu FP32: Xử lý số thực 32-bit tiêu tốn nhiều BRAM và logic hơn so với kỹ thuật lượng tử hóa (Quantization) định dạng số nguyên 8-bit (INT8) hoặc Fixed-Point.

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

  1. Lượng tử hóa mô hình sang INT8 / Q8.8 Fixed-point: Giúp giảm dung lượng bộ nhớ BRAM từ 50% đến 75%, nâng tốc độ xung nhịp lên trên 200 MHz.
  2. Nâng cấp giao tiếp AXI4-Stream & DMA Engine: Cho phép truyền nhận luồng video trực tiếp từ cảm biến camera chất lượng cao mà không cần trung gian máy tính chủ.
  3. Chuyển giao thiết kế sang SoC (Zynq-7000 / Zynq UltraScale+ MPSoC): Kết hợp nhân vi xử lý ARM Cortex-A53 chạy Linux quản lý hệ thống và nhân FPGA xử lý AI tăng tốc phần cứng.

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

  • Sinh viên & Kỹ sư vi mạch (IC Design / Hardware Engineers): Cung cấp tài liệu tham khảo chi tiết, mã nguồn Verilog hoàn chỉnh về cách thiết kế lõi tăng tốc phần cứng Deep Learning và bộ đệm Line Buffer.
  • Lập trình viên nhúng (Embedded AI Developers): Nắm bắt 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 trích xuất và ánh xạ ma trận trọng số từ Python xuống phần cứng.
  • Doanh nghiệp tích hợp hệ thống (System Integrators): Sở hữu giải pháp kiến trúc phần cứng khả thi, sẵn sàng thương mại hóa cho các thiết bị Edge AI kiểm soát an ninh độc lập.
  • Nhà nghiên cứu học thuật: Cung cấp số liệu thực nghiệm chuẩn xác về hiệu quả của kiến trúc Xception trên FPGA phục vụ việc công bố bài báo khoa học.

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

1. Yêu cầu phần cứng tối thiểu để triển khai lõi IP Xception này là gì?

Hệ thống yêu cầu bo mạch FPGA có tối thiểu 80,000 LUTs, 450 Block RAM 36Kb và 650 DSP Slices (tương đương dòng chip Xilinx Virtex-7 XC7VX485T hoặc Xilinx Kintex-7/Kintex UltraScale).

2. Tại sao lại chọn số thực dấu chấm động FP32 thay vì số nguyên cố định Fixed-Point/INT8?

Việc sử dụng định dạng chuẩn IEEE-754 Single Precision 32-bit giữ nguyên 100% độ chuẩn xác của mô hình huấn luyện từ TensorFlow/Keras, tránh hiện tượng suy giảm độ chính xác (Accuracy Degradation) do lỗi tràn số hay làm tròn số thường gặp trong quá trình lượng tử hóa.

3. Hệ thống có khả năng mở rộng để nhận diện nhiều đối tượng khác ngoài khẩu trang không?

Hoàn toàn có thể. Do lõi IP được thiết kế linh hoạt, người dùng chỉ cần thay đổi tệp giá trị nạp trọng số (weights.hex) từ mô hình huấn luyện mới và cấu hình lại số lượng neuron ngõ ra ở tầng Dense là có thể nhận diện các đối tượng khác như biển số xe, cử chỉ tay hoặc phân loại sản phẩm.

4. Chi phí bảo trì và độ tin cậy của phần cứng FPGA so với máy tính công nghiệp chạy GPU như thế nào?

FPGA là vi mạch phần cứng thuần túy, không có hệ điều hành phức tạp nên không gặp rủi ro treo hệ điều hành, nhiễm virus hay lỗi phần mềm. Tuổi thọ hoạt động liên tục (MTBF) của FPGA vượt trội hơn nhiều so với các hệ thống nhúng thông thường.

5. Lợi ích then chốt của việc dùng Separable Convolution trên FPGA là gì?

Tách biệt phép tích chập không gian (Depthwise) và kênh (Pointwise) giúp cắt giảm 95.61% số lượng phép toán nhân logic. Nhờ đó, số lượng bộ nhân phần cứng (DSP Slices) cần sử dụng giảm đi gần 20 lần, cho phép đưa toàn bộ mạng Xception sâu hơn 60 lớp vào một chip FPGA duy nhất.

Kết luận

Đề tài "Thiết kế và hiện thực mạng nơ-ron tích chập trên FPGA sử dụng kiến trúc Xception" của nhóm sinh viên Trường Đại học Công nghệ Thông tin – ĐHQG-HCM đã chứng minh tính khả thi vượt trội của việc phần cứng hóa các mô hình Deep Learning phức tạp lên chip vi mạch FPGA. Bằng sự kết hợp khéo léo giữa tối ưu hóa thuật toán (Depthwise Separable Convolution), tối ưu hóa mạch tổ hợp (Sign-bit ReLU MUX) và kiến trúc xử lý tuần tự thông minh, dự án đã giải quyết thành công bài toán nhận diện khẩu trang phòng dịch với tốc độ cao, tiêu thụ năng lượng thấp và độ chính xác thực nghiệm đạt 85.0%. Đây là nền tảng công nghệ quan trọng thúc đẩy sự phát triển của các hệ thống AI biên (Edge AI) tự chủ trong tương lai.