Giới thiệu dự án

Trong kỷ nguyên bùng nổ của trí tuệ nhân tạo (AI) và thị giác máy tính (Computer Vision), bài toán nhận diện và xác minh khuôn mặt (Face Identification - FI) đã trở thành hạ tầng cốt lõi trong các hệ thống giám sát an ninh thông minh, chấm công sinh trắc học và kiểm soát ra vào tự động. Theo các báo cáo công nghiệp về thị trường Edge AI, nhu cầu xử lý sinh trắc học tại biên (Edge Computing) đang tăng trưởng hơn 25% mỗi năm. Tuy nhiên, luồng dữ liệu trích xuất từ các mạng nơ-ron tích chập (Convolutional Neural Network - CNN) như FaceNet, ArcFace hay DenseNet thường sinh ra các vector đặc trưng (feature embeddings) có số chiều lớn (128, 256, hoặc 512 chiều). Khi triển khai tìm kiếm danh tính trên tập cơ sở dữ liệu lớn (quy mô từ 10.000 đến hàng triệu khuôn mặt), việc tính toán độ tương đồng liên tục gây quá tải nghiêm trọng cho bộ vi xử lý trung tâm (CPU).

Triển khai thuật toán so khớp trên máy chủ GPU đám mây đem lại thông lượng cao nhưng lại vấp phải bài toán tiêu thụ công suất lớn (thường từ 75W - 250W/GPU), độ trễ đường truyền mạng và chi phí phần cứng đắt đỏ. Khóa luận tốt nghiệp "Thiết kế hệ thống tìm kiếm khuôn mặt trên FPGA" do sinh viên Lưu Quyết Thắng và Mai Anh Phong (ngành Kỹ thuật Máy tính, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM, hướng dẫn bởi ThS. Trương Văn Cương) tập trung giải quyết triệt để bài toán này bằng phương pháp đồng thiết kế phần cứng/phần mềm (Hardware/Software Co-design) trên nền tảng Zynq-7000 SoC.

                    HỆ THỐNG TÌM KIẾM KHUÔN MẶT
+------------------------------------------------------------------+
| Máy chủ (Host Server)                                            |
|  - Trích xuất Feature Vector (CNN 128/256/512-dim)               |
|  - Quản trị Cơ sở dữ liệu khuôn mặt (Database Gallery)           |
+------------------------------------------------------------------+
                                |
                   Direct Memory Access (DMA)
                                v
+------------------------------------------------------------------+
| Zynq-7000 SoC Kit (XC7Z010CLG400-1)                              |
|  +---------------------------+   +----------------------------+  |
|  | Processing System (PS)    |   | Programmable Logic (PL)    |  |
|  | - ARM Cortex-A9 Core      |   | - Xillybus IP Core         |  |
|  | - Xillinux OS (Ubuntu)    |   | - Dual-Clock Frame Reader  |  |
|  | - C Host Software Driver  |<->| - Cosine Engine (FP32 MAC) |  |
|  +---------------------------+   +----------------------------+  |
+------------------------------------------------------------------+

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

  1. Thiết kế phần cứng chuyên dụng (Hardware Accelerator): Xây dựng IP core tính toán độ tương đồng Cosine (Cosine Similarity) với chuẩn dấu chấm động IEEE-754 độ chính xác đơn (Single Precision 32-bit Floating-Point) bằng ngôn ngữ Verilog HDL.
  2. Hiện thực kênh truyền thông lượng cao: Tích hợp Xillybus DMA IP Core tạo đường truyền dữ liệu hai chiều (Upstream/Downstream) tốc độ cao giữa hệ điều hành Linux nhúng và khối tính toán phần cứng FPGA.
  3. Hiện thực hóa hệ thống hoàn chỉnh: Kết nối máy chủ trích xuất vector đặc trưng với kit Zynq-7000 SoC, cho phép so khớp thời gian thực trên cơ sở dữ liệu tối thiểu 10.000 khuôn mặt với độ chính xác số học tương đương mô hình phần mềm.

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

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

Trong các hệ thống nhận diện khuôn mặt hai giai đoạn (Two-stage Face Recognition):

  • Giai đoạn 1 (Feature Extraction): Mạng CNN trích xuất vector đặc trưng $N$-chiều từ ảnh khuôn mặt đầu vào.
  • Giai đoạn 2 (Similarity Ranking): Tính toán khoảng cách hoặc góc giữa vector truy vấn (Query Vector $\mathbf{A}$) và toàn bộ vector trong cơ sở dữ liệu (Gallery Vectors $\mathbf{B}$).

Độ tương đồng Cosine là chuẩn đo lường tối ưu nhất: $$\text{Similarity} = \cos(\theta) = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| |\mathbf{B}|} = \frac{\sum_{i=0}^{n-1} A_i B_i}{\sqrt{\sum_{i=0}^{n-1} A_i^2} \cdot \sqrt{\sum_{i=0}^{n-1} B_i^2}}$$

Tiêu chí Server CPU (x86-64) Embedded GPU (Jetson Nano) Đề xuất: Zynq-7000 FPGA SoC
Công suất tiêu thụ Rất cao (65W - 150W) Trung bình (5W - 10W) Cực thấp (< 2.5W toàn board)
Tính toán dấu chấm động (FP32) Tuần tự hoặc SIMD đa luồng Song song khối lớn (Warp) Pipeline phần cứng chuyên biệt chu kỳ thực
Độ trễ truyền nhận (Latency) Cao do tắc nghẽn OS/PCIe Trung bình qua CUDA Driver Rất thấp nhờ Direct FIFO & DMA streaming
Khả năng tùy biến kích thước vector Phụ thuộc lệnh CPU Phụ thuộc Kernel GPU Tùy biến động ($N = 128, 256, 512$) qua thanh ghi
Chi phí triển khai biên Rất cao Trung bình Tối ưu, phù hợp thiết bị IoT công nghiệp

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

  • Must have (Bắt buộc): Module Cosine HDL tuân thủ chuẩn IEEE-754 FP32; kênh truyền DMA Xillybus ổn định; hỗ trợ vector tùy biến độ dài 128/256/512 phần tử; sai số tính toán phần cứng so với Python < 0.01%.
  • Should have (Nên có): Tự động flush buffer khi dữ liệu chưa đầy (cơ chế timeout 10ms); giao diện điều khiển phần mềm đa luồng trên Linux C/C++.
  • Could have (Có thể mở rộng): Tích hợp nhiều lõi Cosine tính toán song song (Multi-core MAC pipeline); hỗ trợ định dạng FP16/Bfloat16.
  • Won't have (Chưa thực hiện ở phiên bản này): Nạp toàn bộ mô hình trích xuất CNN trực tiếp vào fabric FPGA của chip Zynq nhỏ (XC7Z010).

Thiết kế hệ thống

Kiến trúc phần cứng trên khối logic lập trình (Programmable Logic - PL) bao gồm các module thành phần:

[Máy chủ / Host Memory]
         |  (DMA Host Interface)
         v
[Xillybus IP Core] <---> [Asynchronous FIFO / Frame Reader] (Dual Clock Domain)
                                   |
         +-------------------------+-------------------------+
         |                                                   |
         v (ina[31:0])                                       v (inb[31:0])
  [FP32 MAC Core A*B]                                 [FP32 MAC Cores A^2 & B^2]
         |                                                   |
         | (Dot Product)                                     v
         |                                      [FP32 Sqrt & Multiplier]
         |                                                   | (Norm A * Norm B)
         +-------------------------+-------------------------+
                                   |
                                   v
                         [FP32 Division Core]
                                   |
                                   v (cosine_out[31:0])
                    [User Read FIFO / Xillybus Upstream]

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

  • EDA & Synthesis Tool: Xilinx Vivado Design Suite v2020.2 / LogiCORE IP.
  • Phần cứng mục tiêu: Xilinx Zynq-7000 SoC (xc7z010clg400-1).
  • Hệ điều hành nhúng: Xillinux v2.0 (Ubuntu Linux 16.04/18.04 LTS for ARM Cortex-A9).
  • IP Cores tiêu chuẩn: Xilinx Floating-Point Operator IP (Add/Sub, Multiply, Square-Root, Divide), Xillybus Lite DMA Core.
  • Ngôn ngữ phát triển: Verilog HDL (RTL PL), C/C++ POSIX (PS Device Driver Application), Python 3.8 (Data preprocessing & Testbench generator).

Chi tiết các cổng giao tiếp phần cứng (I/O Signal Specification)

Khối IP Tên tín hiệu Hướng Độ rộng Chức năng kỹ thuật
Cosine Engine clk / rst_n Input 1 bit Xung clock hệ thống và tín hiệu reset đồng bộ tích cực mức thấp
valid_in Input 1 bit Báo hiệu dữ liệu đầu vào ina, inb hợp lệ
start Input 1 bit Kích hoạt chu kỳ tính toán tại phần tử đầu tiên của vector
size Input 32 bit Kích thước số phần tử vector ($N = 128, 256, 512$)
ina / inb Input 32 bit Dữ liệu phần tử vector A và B theo định dạng IEEE-754 FP32
cosine_out Output 32 bit Giá trị Cosine Similarity đầu ra (IEEE-754 Single Precision)
cosine_done Output 1 bit Tích cực mức cao (1) khi kết quả cosine_out sẵn sàng
Frame Reader in_fifo1_wren Input 1 bit Cho phép ghi luồng vector từ file thiết bị /dev/xillybus_write_32
in_fifo2_wren Input 1 bit Cho phép ghi luồng vector so sánh
user_r_read_32_empty Output 1 bit Cờ báo FIFO đọc kết quả đang rỗng
user_r_read_32_data Output 32 bit Dữ liệu kết quả đẩy ngược lên Host Server qua DMA

Phương pháp luận (Methodology)

Dự án áp dụng mô hình Hardware/Software Co-Design theo quy trình V-Model:

  1. Giai đoạn 1: Mô hình hóa thuật toán Cosine bằng Python; xuất ma trận mẫu dữ liệu dạng Hex/Binary.
  2. Giai đoạn 2: Thiết kế RTL bằng Verilog cho từng khối con (FP32 Multiplier, Adder, Accumulator, Sqrt, Divider, FSM Controller).
  3. Giai đoạn 3: Viết Testbench mô phỏng kiểm thử toàn diện trên Vivado Simulator với 5.000 mẫu dữ liệu ngẫu nhiên và dữ liệu ảnh thực tế.
  4. Giai đoạn 4: Tổng hợp phần cứng (Synthesis & Implementation), phân tích tài nguyên (Resource Utilization) và định thời (Timing Constraints).
  5. Giai đoạn 5: Ghép nối hệ thống trên chip Zynq-7000, kiểm thử kênh truyền Linux Device Driver và đo lường thông số thực tế.

Implementation và kết quả

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

1. Khối nhân-cộng tích lũy (Multiply and Accumulate - MAC) và Pipeline Cosine

Đơn vị tính toán Cosine gồm 4 khối số học dấu chấm động LogiCORE được cấu hình pipeline nhằm đạt thông lượng 1 kết quả/chu kỳ sau khi lấp đầy đường ống:

  • Khối tính tích vô hướng tử số: $\sum_{i=0}^{N-1} A_i \cdot B_i$
  • Hai khối tính bình phương tích lũy mẫu số: $\sum_{i=0}^{N-1} A_i^2$ và $\sum_{i=0}^{N-1} B_i^2$
  • Khối nhân hai mẫu số và căn bậc hai: $\sqrt{\left(\sum A_i^2\right) \cdot \left(\sum B_i^2\right)}$
  • Khối chia floating-point 32-bit tạo kết quả cuối cùng.
// Trích xuất cấu trúc điều khiển FSM Counter và quản lý Pipeline Cosine
module cosine_counter (
    input wire clk,
    input wire rst_n,
    input wire start,
    input wire en,
    input wire [31:0] din,      // Kích thước vector (Vector Size)
    output reg [31:0] cnt_out,
    output reg valid_out
);
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            cnt_out   <= 32'd0;
            valid_out <= 1'b0;
        end else if (en) begin
            if (start) begin
                cnt_out   <= 32'd1;
                valid_out <= 1'b0;
            end else if (cnt_out > 32'd0 && cnt_out < din + 32'd4) begin
                cnt_out   <= cnt_out + 32'd1;
                valid_out <= (cnt_out == din + 32'd3) ? 1'b1 : 1'b0;
            end else begin
                cnt_out   <= 32'd0;
                valid_out <= 1'b0;
            end
        end
    end
endmodule

2. Phần mềm điều khiển giao tiếp máy chủ (C Host Driver Application)

Phần mềm trên ARM Core (Xillinux) mở các luồng giao tiếp với tệp thiết bị UNIX đại diện cho kênh DMA phần cứng:

// Trích xuất mã nguồn C Driver đọc/ghi dữ liệu qua Xillybus Device Files
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define NUMBER_OF_FRAME 128
#define DEV_WRITE_1 "/dev/xillybus_write_32_1"
#define DEV_WRITE_2 "/dev/xillybus_write_32_2"
#define DEV_READ    "/dev/xillybus_read_32"

void send_feature_vectors(const char* file_path, int fd_device) {
    FILE *fp = fopen(file_path, "r");
    char *line = NULL;
    size_t len = 0;
    ssize_t read_cnt;
    float buf[NUMBER_OF_FRAME];
    int counter = 0;

    while ((read_cnt = getline(&line, &len, fp)) != -1 && counter < NUMBER_OF_FRAME) {
        if (read_cnt > 1) {
            buf[counter++] = atof(line);
        }
    }
    write(fd_device, (void*)buf, counter * sizeof(float));
    fclose(fp);
    if (line) free(line);
    printf("DONE WRITING %d FLOATS TO FPGA DMA!\n", counter);
}

int receive_similarity_result(int fd_read) {
    float result = 0.0f;
    int counter = 0;
    // Cần thêm 4 chu kỳ trễ pipeline của khối Cosine Engine
    while (counter < 1) {
        ssize_t re = read(fd_read, (void*)&result, sizeof(float));
        if (re > 0) {
            counter += re / 4;
            printf("Cosine Similarity Result (FP32): %f (0x%08X)\n", 
                    result, *(unsigned int*)&result);
        }
    }
    printf("DONE READING SIMILARITY RESULT!\n");
    return 0;
}

Kiểm thử và đánh giá (Testing & Validation)

Hệ thống được xác minh thông qua 2 bộ dữ liệu:

  1. Random Synthetic Dataset: 5.000 gói dữ liệu (Packet Data) sinh tự động từ Python biểu diễn dưới dạng chuỗi nhị phân 32-bit.
  2. Real Dataset: Vector đặc trưng trích xuất từ tập dữ liệu khuôn mặt thực tế qua mạng CNN.
Cấu trúc gói tin Testbench (Packet Bit-Structure):
+------------------------------------------------------------------------------------------------+
| result_python [31:0] | y[size-1] ... y[0] | x[size-1] ... x[0] | size [31:0] | packet_id [31:0]|
+------------------------------------------------------------------------------------------------+
 MSB (64 + 2*size*32)                                                                          LSB

Kết quả kiểm thử cho thấy:

  • Tỷ lệ chính xác số học (Correctness Ratio): Đạt 99.76% trùng khớp tuyệt đối ở mức bit so với mô hình Python float32 tiêu chuẩn trên 5.000 packet kiểm thử.
  • Sai số cực tiểu xuất hiện ở các bit LSB cuối cùng là do chuẩn làm tròn nửa khoảng cách (Round-to-Nearest Even) của DSP IP Core trong phép toán căn bậc hai và chia.

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

Hệ thống được tổng hợp và thực thi thành công trên board Zynq-7000 (XC7Z010CLG400-1).

Thành phần tài nguyên phần cứng Sử dụng (Used) Tổng có sẵn (Available) Tỷ lệ sử dụng (%)
LUT (Look-Up Tables) 654 17.600 3.55%
FF (Flip-Flops) 747 35.200 2.12%
I/O Pins 69 100 69.00%
Tần số hoạt động tối đa ($F_{\max}$) 13.514 MHz (Khối Cosine Engine thuần)
Miền xung Clock Xillybus DMA 100.000 MHz 
TÀI NGUYÊN TIÊU THỤ TRÊN CHIP (XC7Z010)
LUT [===---------------------------------]  3.55%
FF  [==----------------------------------]  2.12%
I/O [====================================] 69.00%

Hiệu năng tính toán chi tiết

  • Số chu kỳ xử lý (Clock Cycles) cho vector 512 chiều: 515 cycles ($N + 3$ chu kỳ trễ đường ống).
  • Thời gian xử lý 1 phép so khớp (Latency): 38.108 µs (ở tần số $F_{\max}$).
  • Thông lượng tính toán (Throughput): Đạt 26.240 phép so sánh/giây trên duy nhất một engine đơn luồng, hoàn thành duyệt danh mục 10.000 khuôn mặt chỉ trong 0.381 giây.

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

  1. Kiến trúc Pipeline FP32 tiết kiệm diện tích tối đa: Bằng cách kết hợp linh hoạt DSP slices và Logic Fabric thông qua Xilinx Floating-Point IP, thiết kế module Cosine chỉ chiếm 3.55% LUT và 2.12% FF của dòng chip Zynq nhỏ nhất (XC7Z010), mở ra tiềm năng nhân bản lên hàng chục lõi tính toán song song trên cùng một vi mạch.
  2. Kiến trúc phân tách hai miền xung nhịp (Clock Domain Crossing - CDC): Thiết kế module Frame Reader kết hợp Asynchronous FIFO cho phép khối DMA hoạt động ở tốc độ 100 MHz trong khi khối Cosine tính toán ở tần số thiết kế riêng biệt mà không gây mất mát dữ liệu (Data Corruption) hay hiện tượng bất ổn định (Metastability).
  3. Giải phóng 100% tải tính toán số thực cho CPU chủ: Toàn bộ các phép toán nặng gồm nhân dồn, căn bậc hai và chia dấu chấm động được offload hoàn toàn sang phần cứng chuyên dụng; CPU ARM chỉ đảm nhận tác vụ I/O stream.
Giải pháp so sánh Thời gian so khớp 10.000 khuôn mặt (Vector 512-D) Công suất tiêu thụ trung bình
Thuần phần mềm ARM Cortex-A9 (1 Core @ 667MHz) ~ 2.450 giây ~ 1.5W
Máy tính nhúng Raspberry Pi 4 (Quad-core CPU) ~ 0.820 giây ~ 6.0W
Đề xuất: Zynq-7000 SoC (FPGA Accelerator) 0.381 giây (Tăng tốc 6.4x so với ARM) < 2.0W

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

Các tình huống ứng dụng thực tế

  • Hệ thống camera giám sát an ninh thông minh tại tòa nhà: Camera IP gửi luồng đặc trưng khuôn mặt nén về trạm SoC biên để so khớp tức thời với danh sách đen (Blacklist) hoặc danh sách nhân viên 10.000 người mà không phụ thuộc vào kết nối Internet.
  • Thiết bị eKYC và chấm công sinh trắc học tốc độ cao: Giảm độ trễ xác thực xuống dưới 50ms, loại bỏ hoàn toàn hiện tượng xếp hàng chờ đợi tại cửa kiểm soát thông minh.
[IP Camera / Sensor]
         | (Video Stream)
         v
[Edge Processor: CNN Extraction]
         | (128-D Vector)
         v
[Zynq-7000 FPGA Hardware Accelerator] ---> [Khóa cửa tự động / Alert System]

Hướng dẫn triển khai và tích hợp hệ thống

  1. Nạp Bitstream: Tích hợp bitstream đã đóng gói vào thư mục khởi động của thẻ nhớ SD chạy Xillinux OS.
  2. Khởi tạo Driver: Hệ điều hành tự động nhận diện thiết bị tại /dev/xillybus_write_32_1, /dev/xillybus_write_32_2 và /dev/xillybus_read_32.
  3. Thực thi phần mềm: Chạy ứng dụng C/C++ kết nối cơ sở dữ liệu khuôn mặt và nhận dữ liệu truy vấn từ giao diện Web/Camera.

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

Hạn chế kỹ thuật

  • Tần số hoạt động của khối Cosine đạt mức 13.514 MHz do độ trễ tổ hợp của chuỗi IP chia và căn bậc hai chưa được tối ưu hóa sâu các tầng thanh ghi đệm nội (Pipelined Stage Registers).
  • Hệ thống hiện tại sử dụng 1 IP Core Cosine đơn luồng nên chưa khai thác hết băng thông kênh truyền DMA 100 MHz.

Hướng nâng cấp

  • Tối ưu tần số và đa nhân song song: Bố trí thêm thanh ghi trung gian để đẩy tần số lên mức >100 MHz đồng bộ với bus Xillybus; song song hóa 8 đến 16 lõi Cosine Engine trên chip Zynq-7020 hoặc Zynq UltraScale+ nhằm nâng thông lượng lên hơn 300.000 phép so khớp/giây.
  • Chuyển đổi lượng tử hóa (Quantization): Nghiên cứu áp dụng định dạng Fixed-point (INT8/INT16) hoặc Bfloat16 nhằm loại bỏ hoàn toàn các IP floating-point phức tạp, giúp tiết kiệm hơn 60% tài nguyên logic.

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

  • Sinh viên & Kỹ sư nhúng/FPGA: Cung cấp tài liệu tham khảo chi tiết về thiết kế phần cứng tính toán số thực IEEE-754, kỹ thuật đóng gói IP Core và lập trình điều khiển DMA trên nền tảng SoC Xilinx Zynq.
  • Nhà phát triển AI / Computer Vision: Cung cấp giải pháp kiến trúc tăng tốc phần cứng cho các thuật toán tìm kiếm tương đồng vector (Vector Database / Similarity Search) tại biên.
  • Doanh nghiệp phát triển giải pháp IoT sinh trắc học: Bản thiết kế tham chiếu hoàn chỉnh với chi phí linh kiện thấp, tiêu thụ ít điện năng và độ tin cậy công nghiệp cao.

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

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

Cần kit phát triển Zynq-7000 (như ZedBoard, Zybo Z7-10 hoặc PYNQ-Z2 trang bị chip XC7Z010/XC7Z020), máy tính cài đặt phần mềm Xilinx Vivado Design Suite (khuyên dùng bản 2020.2 trở lên) và thẻ nhớ MicroSD tối thiểu 8GB đã nạp hệ điều hành Xillinux.

2. Tại sao thiết kế lại dùng chuẩn số thực IEEE-754 thay vì số nguyên cố định (Fixed-point)?

Vector đặc trưng trích xuất từ các mạng deep learning hiện đại (FaceNet, ArcFace) có miền giá trị phân bố liên tục xung quanh các khoảng số học rất nhỏ. Việc duy trì chuẩn IEEE-754 32-bit giúp giữ nguyên vẹn độ chính xác phân lớp nhận dạng mà không cần trải qua bước huấn luyện lại (Re-training) hay hiệu chỉnh lượng tử hóa phức tạp.

3. Làm thế nào để thay đổi kích thước vector đặc trưng từ 128 lên 512 hoặc 1024 chiều?

Kích thước vector được thiết kế dưới dạng tham số động (Dynamic Parameter). Người dùng chỉ cần truyền giá trị độ dài mong muốn vào chân tín hiệu size[31:0] của IP Core mà không cần biên dịch lại mã nguồn Verilog.

4. Cơ chế đồng bộ dữ liệu giữa hai miền xung nhịp hoạt động như thế nào?

Module Frame Reader sử dụng cấu trúc Asynchronous Dual-Clock FIFO. Xung nhịp ghi kết nối với miền xung 100 MHz của Xillybus DMA, xung nhịp đọc kết nối với miền xung nhịp của bộ xử lý Cosine, đảm bảo an toàn tuyệt đối tránh hiện tượng xung đột dữ liệu.

5. Chi phí sản xuất thương mại của giải pháp này ước tính bao nhiêu?

Với việc sử dụng dòng chip giá rẻ Zynq-7000 (XC7Z010), tổng chi phí bo mạch phần cứng cho một trạm xử lý biên chỉ dao động từ $50 - $80 USD, thấp hơn đáng kể so với việc trang bị các bộ máy tính công nghiệp hoặc card tăng tốc chuyên dụng.

Kết luận

Đồ án tốt nghiệp "Thiết kế hệ thống tìm kiếm khuôn mặt trên FPGA" của nhóm sinh viên Lưu Quyết Thắng và Mai Anh Phong đã giải quyết trọn vẹn bài toán hóc búa về hiệu năng và công suất trong tìm kiếm khuôn mặt tại biên. Bằng việc kết hợp kiến trúc tính toán pipeline chuẩn xác IEEE-754 FP32 trên fabric FPGA với cơ chế truyền nhận dữ liệu DMA thông lượng cao qua Xillybus, hệ thống đạt tốc độ xử lý 26.240 khuôn mặt/giây, độ chính xác số học 99.76% và chỉ tiêu thụ một phần nhỏ tài nguyên chip Zynq-7000. Đây là công trình nghiên cứu ứng dụng có giá trị thực tiễn cao, đóng góp nền tảng vững chắc cho việc phát triển các thiết bị biên AI thế hệ mới phục vụ an ninh và đô thị thông minh.