Giới thiệu dự án

Bối cảnh và vấn đề nghiên cứu

Sự bùng nổ của trí tuệ nhân tạo (AI) và Cách mạng Công nghiệp 4.0 thúc đẩy nhu cầu xử lý các bài toán điều khiển tự động và ra quyết định thích nghi theo thời gian thực. Trong các phân ngành của Machine Learning, Học tăng cường (Reinforcement Learning - RL) đóng vai trò nòng cốt khi cho phép một tác nhân (Agent) tự khám phá và tối ưu hóa chính sách hành động thông qua cơ chế tương tác và nhận phần thưởng từ môi trường (Environment).

Tuy nhiên, phần lớn các thuật toán Deep Reinforcement Learning (DRL) hiện nay – tiêu biểu là Deep Q-Network (DQN) – chủ yếu được huấn luyện và thực thi trên nền tảng vi xử lý đa lõi (CPU) hoặc bộ xử lý đồ họa (GPU). Dù GPU vượt trội về khả năng tính toán song song ma trận lớn, chúng gặp rào cản nghiêm trọng khi triển khai trên các thiết bị biên (Edge Devices) do tiêu thụ năng lượng cao (thường từ 75W - 300W), độ trễ truyền thông qua bus PCIe lớn và tính linh hoạt phần cứng bị giới hạn. Ngược lại, nền tảng vi mạch khả lập trình (Field-Programmable Gate Array - FPGA) cung cấp giải pháp vượt trội về khả năng tái cấu trúc phần cứng (reconfigurability), thông lượng xử lý cao với kiến trúc đường ống (pipelining) và mức tiêu thụ điện năng tối ưu ở cấp độ miliwatt đến vài watt.

┌─────────────────────────────────────────────────────────────┐
│                 HỆ THỐNG ĐIỀU KHIỂN BIÊN                    │
│                                                             │
│   ┌───────────────────┐               ┌─────────────────┐   │
│   │ Môi trường Vật lý │◄── Action ────┤   Edge FPGA     │   │
│   │   (CartPole-v0)   │── State/r ───►│   (DQN Top)     │   │
│   └───────────────────┘               └─────────────────┘   │
│                                       • Huấn luyện On-chip  │
│                                       • Suy luận độ trễ thấp│
│                                       • Công suất < 1.5W    │
└─────────────────────────────────────────────────────────────┘

Phát biểu bài toán cụ thể (Problem Statement)

Triển khai thuật toán Deep Q-Network hoàn chỉnh trực tiếp trên phần cứng FPGA đối mặt với các nút thắt kỹ thuật cốt lõi:

  • Độ phức tạp của thuật toán học trực tuyến (Online Training): Khác với các bộ gia tốc chỉ chạy suy luận (Inference-only Accelerators), DQN đòi hỏi phần cứng phải thực hiện song song cả chiều thuận (Feedforward - suy luận giá trị $Q$) và chiều ngược (Backpropagation - tính đạo hàm và cập nhật trọng số $\Delta w$).
  • Chi phí tài nguyên dấu chấm động: Xử lý số học dấu chấm động 32-bit (IEEE-754 Single-Precision Floating Point - FP-32) trên FPGA tiêu tốn lượng lớn khối logic (LUTs, Flip-Flops) và khối nhân chuyên dụng (DSP Slices).
  • Mất ổn định và tràn bit: Hiện tượng bùng nổ đạo hàm (Exploding/Exponent Gradient) và tràn số trong biểu diễn dấu chấm động 32-bit khi lan truyền ngược qua các lớp phi tuyến.
  • Tương quan dữ liệu (Data Correlation): Dữ liệu thu thập từ các bước hành động liên tiếp có tính phụ thuộc thời gian cao, dễ dẫn đến hiện tượng quá khớp (overfitting) hoặc mất hội tụ nếu không có cơ chế lưu trữ và lấy mẫu phát lại trải nghiệm hiệu quả trên bộ nhớ nội (On-chip Memory).

Mục tiêu dự án

  1. Thiết kế kiến trúc phần cứng DQN RTL: Xây dựng hoàn chỉnh mô hình DQN bằng ngôn ngữ Verilog HDL theo kiến trúc đường ống (Pipeline), hỗ trợ đầy đủ chế độ tương tác (Interactive/Predict Mode) và chế độ huấn luyện (Train Mode).
  2. Tối ưu hóa các khối xử lý số học FP-32: Tự thiết kế và hiện thực các khối tính toán chuẩn IEEE-754 (Adder, Multiplier, Perceptron Element, Activation Function) đạt hiệu năng cao với tài nguyên tối thiểu.
  3. Hiện thực cơ chế ổn định mô hình trên phần cứng: Tích hợp bộ đệm phát lại (Experience Replay Buffer), mạng mục tiêu (Target Network) với thuật toán cập nhật mềm (Soft-Update), khối suy giảm tốc độ học (Changing Learning Rate) và bộ sinh số ngẫu nhiên phần cứng (RNG-FP) cho chiến lược $\varepsilon$-greedy.
  4. Xác thực Co-simulation: Kiểm thử toàn diện kiến trúc RTL trên phần mềm Vivado kết hợp môi trường đồng mô phỏng cocotb kết nối trực tiếp với môi trường chuẩn CartPole-v0 của OpenAI Gym.
Chỉ số kỹ thuật Mục tiêu đề ra (Target) Kết quả đạt được (Achieved)
Nền tảng FPGA Xilinx Virtex-7 xc7vx485tffg1927-1
Tần số hoạt động cực đại ($F_{max}$) $\ge 150 \text{ MHz}$ $212.7 \text{ MHz}$
Công suất tiêu thụ tĩnh/động $< 10 \text{ W}$ $1.353 \text{ W}$
Định dạng dữ liệu số học IEEE-754 FP-32 IEEE-754 Single Precision 32-bit
Sai số tính toán (HW vs SW Model) $\le 10^{-4}$ $3.547 \times 10^{-5}$ (qua 1000 mẫu)
Độ ổn định huấn luyện (CartPole-v0) Đạt điểm tối đa (200 steps) Hội tụ vững chắc trong 500 Episodes

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

  • Môi trường thử nghiệm: Bài toán cân bằng con lắc ngược CartPole-v0 với không gian quan sát liên tục 4 chiều ($x, \dot{x}, \theta, \dot{\theta}$) và không gian hành động rời rạc 2 chiều (Đẩy trái = 0, Đẩy phải = 1).
  • Cấu trúc mạng: Mạng nơ-ron truyền thẳng (Multi-Layer Perceptron - MLP) gồm 2 lớp ẩn (Hidden Layers), tham số hóa linh hoạt thông qua Verilog parameter và cú pháp generate.
  • Lưu trữ: Sử dụng toàn bộ tài nguyên bộ nhớ nội BRAM (Block RAM) và LUTRAM trên chip FPGA, không phụ thuộc vào bộ nhớ ngoài DDR SDRAM nhằm giảm thiểu độ trễ truy xuất.

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

Phân tích hiện trạng và khoảng trống công nghệ

┌─────────────────────────────────────────────────────────────┐
│                    SO SÁNH CÁC HƯỚNG TIẾP CẬN               │
│                                                             │
│  Tabular Q-Learning        OS-ELM SoC-FPGA      Proposed DQN│
│  ┌─────────────────┐      ┌───────────────┐     ┌──────────┐│
│  │ Bảng Q rời rạc  │      │ 1 lớp ẩn      │     │ 2 lớp ẩn ││
│  │ Bùng nổ bộ nhớ  │      │ Không Backprop│     │ Backprop ││
│  │ Không khái quát │      │ Khó tinh chỉnh│     │ On-chip  ││
│  └─────────────────┘      └───────────────┘     └──────────┘│
└─────────────────────────────────────────────────────────────┘

Trong các nghiên cứu trước đây về phần cứng cho Học tăng cường, các tác giả chủ yếu lựa chọn hai thái cực: hoặc đơn giản hóa mô hình thành Q-Learning dạng bảng (Tabular Q-Learning) gây bùng nổ bộ nhớ khi số trạng thái tăng, hoặc sử dụng mạng nơ-ron ngoại tuyến (chỉ suy luận trên FPGA, việc huấn luyện thực hiện hoàn toàn trên máy tính). Nghiên cứu của một số nhóm tác giả gần đây sử dụng giải thuật Online Sequential Extreme Learning Machine (OS-ELM) trên SoC-FPGA nhằm tránh thuật toán lan truyền ngược (Backpropagation), nhưng phương pháp này bị giới hạn về độ sâu kiến trúc mạng và khả năng trích xuất đặc trưng phức tạp.

Tiêu chí so sánh Q-Learning dạng bảng [1, 2] Mạng NNQL / OS-ELM [3, 5] Kiến trúc DQN đề xuất
Không gian trạng thái Hữu hạn, rời rạc hóa Liên tục (1 lớp ẩn) Liên tục đa chiều (Đa lớp ẩn)
Bộ nhớ yêu cầu Tăng theo hàm mũ $\mathcal{O}(|S| \times |A|)$ Cố định, phụ thuộc ma trận nghịch đảo Tối ưu hóa BRAM với Experience Replay
Khả năng học On-chip Cập nhật giá trị bảng trực tiếp Giải ma trận giải tích (Analytical) Lan truyền ngược (Backpropagation) FP-32
Độ ổn định huấn luyện Rất kém trên dữ liệu liên tục Trung bình, nhạy cảm với khởi tạo Rất cao (Target Network + Soft Update)
Định dạng số học Fixed-point (Định điểm) Fixed/Floating-point IEEE-754 Single-Precision Floating-Point

Yêu cầu hệ thống (Phân loại MoSCoW)

  • Must-have:
    • Khối tính toán số học FP-32 chuẩn IEEE-754 (Phép cộng/trừ và phép nhân đạt pipeline hoàn toàn).
    • Khối PE (Perceptron Element) hỗ trợ tính tích vô hướng đa node tuần tự kết hợp cây cộng (Adder Tree).
    • Cơ chế lan truyền ngược cập nhật trọng số qua khối CEN (Calculate Error on Node) và CDUW (Calculate Delta and Update Weight).
    • Bộ đệm Experience Replay hỗ trợ ghi vòng lặp và đọc ngẫu nhiên (Uniform Random Sampling).
  • Should-have:
    • Khối cập nhật mạng mục tiêu mềm (Soft-Update) với tham số $\tau$ tùy chỉnh.
    • Khối giảm tốc độ học (Dynamic Learning Rate Decay) nhằm đảm bảo mạng hội tụ sâu.
    • Bộ tạo số ngẫu nhiên thực thể phần cứng (RNG-FP) kết hợp Fibonacci LFSR và Galois LFSR.
  • Could-have:
    • Khả năng cấu hình số node trên mỗi lớp ẩn thông qua tham số GENERIC/PARAMETER trong thời gian tổng hợp (Synthesis-time reconfigurability).
  • Won't-have (giai đoạn này):
    • Giao tiếp bộ nhớ ngoài DDR4 thông qua AXI-Interconnect (ưu tiên tối đa hóa tốc độ BRAM on-chip).

Kiến trúc hệ thống chi tiết

Hệ thống DQN_TOP được thiết kế phân tầng bao gồm hai thành phần cơ bản: DQN Control (Máy trạng thái hữu hạn FSM điều khiển luồng) và DQN Datapath (Khối đường dẫn dữ liệu).

                      ┌────────────────────────────────────────┐
                      │                DQN_TOP                 │
                      │                                        │
                      │   ┌────────────────────────────────┐   │
                      │   │          DQN_CONTROL           │   │
                      │   │  (FSM: Init, Predict, Train)   │   │
                      │   └──────┬──────────────────▲──────┘   │
                      │          │ Control          │ Status   │
                      │          ▼                  │          │
                      │   ┌─────────────────────────┴──────┐   │
                      │   │          DQN_DATAPATH          │   │
                      │   │  ┌────────────┐ ┌───────────┐  │   │
                      │   │  │Main Network│ │Target Net │  │   │
                      │   │  └─────┬──────┘ └─────▲─────┘  │   │
                      │   │        │              │        │   │
                      │   │  ┌─────▼──────────────┴─────┐  │   │
                      │   │  │ Temporal Difference (TD) │  │   │
                      │   │  └─────▲──────────────▲─────┘  │   │
                      │   │        │              │        │   │
                      │   │  ┌─────┴──────┐ ┌─────┴─────┐  │   │
                      │   │  │Exp. Replay │ │  ε-Greedy │  │   │
                      │   │  └────────────┘ └───────────┘  │   │
                      │   └────────────────────────────────┘   │
                      └────────────────────────────────────────┘

1. Khối Main Network (Mạng chính)

Mạng chính là khối ANN đa lớp thực thi hai nhiệm vụ: dự đoán giá trị $Q(s_t, a)$ trong chế độ Feedforward và huấn luyện cập nhật trọng số trong chế độ Backpropagation.

  • Khối PE (Perceptron Element): Thay vì sử dụng kiến trúc song song hoàn toàn (tốn $N$ bộ nhân cho $N$ node), thiết kế sử dụng phương pháp tính toán tuần tự pipeline. Dữ liệu đầu vào $x_i$ và trọng số $w_i$ được nhân tuần tự qua 1 bộ nhân FP-32, sau đó lưu vào thanh ghi chuyển đổi nối tiếp - song song (Serial-to-Parallel - S2P) và đưa qua cây cộng nhị phân (Adder Tree) để thu được tổng: $$z = \sum_{i=1}^{N} w_i x_i + b$$ Hiệu năng: Tính toán 8 node chỉ mất 108 chu kỳ xung nhịp (thay vì 44 chu kỳ của cấu trúc song song hoàn toàn nhưng tiết kiệm tới 87.5% số lượng DSP Slices).
  • Hàm kích hoạt Leaky ReLU cải tiến: Hàm Leaky ReLU thông thường ($f(x) = x \text{ khi } x > 0; \alpha x \text{ khi } x \le 0$) khi tính toán với số thực dấu chấm động 32-bit trong nhiều chu kỳ huấn luyện rất dễ gây tràn số mũ (Exponent Overflow). Đồ án đưa ra đề xuất cải tiến: $$f(x) = \begin{cases} a \cdot x & \text{với } x > 0 \ b \cdot x & \text{với } x \le 0 \end{cases} \quad (0 < b < a < 1)$$ Trong thiết kế phần cứng, hệ số được cố định $a = 0.5$ và $b = 0.01$, giúp chặn dải giá trị đầu ra của nơ-ron luôn nằm trong miền ổn định, triệt tiêu hoàn toàn lỗi bùng nổ đạo hàm mà vẫn giữ được tính phi tuyến.

2. Khối Lan truyền ngược (Backpropagation Engine)

  • Calculate Error on Node (CEN): Tính toán độ lỗi cục bộ $\delta$ tại từng node trước hàm kích hoạt dựa trên đạo hàm của Leaky ReLU: $$\delta_j = e_j \cdot f'(z_j)$$ với $f'(z) = a$ nếu bit dấu MSB của $z$ bằng 0 ($z > 0$) và $f'(z) = b$ nếu MSB bằng 1 ($z \le 0$).
  • Calculate Delta and Update Weight (CDUW): Cập nhật trọng số theo giải thuật Stochastic Gradient Descent (SGD): $$w_{new} = w_{old} - \alpha \cdot (\delta_j \cdot a_i)$$ trong đó $\alpha$ là tốc độ học (Learning Rate) được điều chỉnh động theo từng pha huấn luyện.

3. Khối Target Network và Target Update

Nhằm tránh hiện tượng mục tiêu di động (Moving Target Problem) gây phân kỳ mô hình, một mạng nơ-ron thứ hai giống hệt cấu trúc được thiết lập. Khối Target Update đồng bộ trọng số từ Main Network sang Target Network theo công thức cập nhật mềm: $$\theta_{\text{target}} \leftarrow \tau \cdot \theta_{\text{main}} + (1 - \tau) \cdot \theta_{\text{target}}$$

4. Khối Temporal Difference (TD)

Tính toán độ lỗi sai phân thời gian đóng vai trò hàm mất mát cho mạng: $$\text{TD Error} = r_{t+1} + \gamma \cdot \max_{a'} Q(s_{t+1}, a'; \theta_{\text{target}}) - Q(s_t, a_t; \theta_{\text{main}})$$ với $\gamma = 0.99$ là hệ số chiết khấu phần thưởng tương lai.

                    ┌──────────────────────────────────────┐
                    │       BỘ ĐỆM PHÁT LẠI TRẢI NGHIỆM    │
                    │        (Experience Replay BRAM)      │
                    │                                      │
                    │   ┌────────┬────────┬────────┬────┐  │
                    │   │ State  │ Action │ Reward │Next│  │
                    │   │ (4x32) │ (1-bit)│ (32-bit│(4x)│  │
                    │   ├────────┼────────┼────────┼────┤  │
                    │   │ s_0    │ a_0    │ r_0    │s_1 │  │
                    │   │ s_1    │ a_1    │ r_1    │s_2 │  │
                    │   │  ...   │  ...   │  ...   │... │  │
                    │   │ s_N-1  │ a_N-1  │ r_N-1  │s_N │  │
                    │   └────────┴────────┴────────┴────┘  │
                    │         ▲                  │         │
                    │   Ghi tuần tự        Đọc ngẫu nhiên  │
                    │   (Ring Buffer)      (Uniform Sample)│
                    └──────────────────────────────────────┘

5. Khối Experience Replay (Bộ đệm phát lại)

Hiện thực bằng BRAM 2 cổng (Dual-port BRAM) cấu hình theo dạng Ring Buffer. Cho phép lưu trữ hàng nghìn bộ tuple $(s_t, a_t, r_{t+1}, s_{t+1})$. Khối sinh địa chỉ ngẫu nhiên sẽ truy xuất mẫu phân phối đều (Uniform Sampling) để giải phóng sự tương quan dữ liệu chuỗi thời gian khi đưa vào huấn luyện mạng chính.

Implementation và kết quả

Quy trình phát triển phần cứng và đồng mô phỏng

Dự án áp dụng phương pháp luận thiết kế phần cứng vi mạch theo chu trình từ phần mềm sang phần cứng:

  1. Pha 1 - Software Golden Model: Xây dựng mô hình DQN bằng Python (NumPy/PyTorch) làm chuẩn so sánh giải thuật.
  2. Pha 2 - RTL Modeling: Thiết kế các module Verilog HDL độc lập (Arithmetic units $\rightarrow$ PE $\rightarrow$ Layers $\rightarrow$ Top).
  3. Pha 3 - Co-simulation Testbench: Sử dụng framework cocotb (Python-based Co-simulation) kết nối trực tiếp với simulator phần cứng thông qua giao diện VPI/DPI.
# Đoạn mã Python Testbench Co-simulation sử dụng Cocotb điều khiển RTL DQN
import cocotb
from cocotb.triggers import RisingEdge, Timer
import gym

@cocotb.test()
async def test_dqn_cartpole_learning(dut):
    """Đồng mô phỏng RTL DQN tương tác trực tiếp với OpenAI Gym CartPole-v0"""
    env = gym.make('CartPole-v0')
    clock = Clock(dut.clk, 4.7, units="ns") # ~212.7 MHz
    cocotb.start_soon(clock.start())
    
    # Khởi động và Reset hệ thống phần cứng
    dut.rstn.value = 0
    dut.start.value = 0
    await Timer(20, units="ns")
    dut.rstn.value = 1
    dut.start.value = 1
    await RisingEdge(dut.clk)
    
    # Chờ quá trình nạp trọng số khởi tạo (Load Weight Init)
    while not dut.ready.value:
        await RisingEdge(dut.clk)
        
    for episode in range(500):
        state = env.reset()
        done = False
        total_reward = 0
        
        while not done:
            # Chuyển đổi trạng thái từ float sang binary FP32
            dut.state_env.value = convert_state_to_fp32_bin(state)
            dut.valid_in.value = 1
            await RisingEdge(dut.clk)
            dut.valid_in.value = 0
            
            # Chờ phần cứng DQN suy luận Action
            while not dut.valid_out.value:
                await RisingEdge(dut.clk)
                
            action = int(dut.action.value)
            next_state, reward, done, _ = env.step(action)
            total_reward += reward
            
            # Gửi phản hồi Reward và Next State về phần cứng
            dut.reward_env.value = float_to_bits(reward)
            dut.done_env.value = 1 if done else 0
            state = next_state
            await RisingEdge(dut.clk)

Hiện thực phần cứng RTL cốt lõi

Dưới đây là thiết kế khối kích hoạt Leaky ReLU cải tiến được tối ưu hóa đường ống trên Verilog HDL:

// Module Leaky ReLU cải tiến tránh lỗi Exponent Overflow trên FPGA
module leaky_relu_custom #(
    parameter DATA_WIDTH = 32,
    parameter POS_COEFF  = 32'h3F000000, // 0.5 in FP32
    parameter NEG_COEFF  = 32'h3C23D70A  // 0.01 in FP32
)(
    input  wire                   clk,
    input  wire                   rstn,
    input  wire                   valid_in,
    input  wire [DATA_WIDTH-1:0]  in_data,
    output reg                    valid_out,
    output wire [DATA_WIDTH-1:0]  out_data
);

    wire [DATA_WIDTH-1:0] mult_coeff;
    wire [DATA_WIDTH-1:0] mult_result;
    wire                  mult_valid_out;

    // Kiểm tra bit dấu (MSB) của số thực IEEE-754
    // in_data[31] = 0 (Số dương), in_data[31] = 1 (Số âm)
    assign mult_coeff = (in_data[31] == 1'b0) ? POS_COEFF : NEG_COEFF;

    // Bộ nhân Floating-Point Single Precision Pipeline
    fp_multiplier_32bit u_fp_mult (
        .clk       (clk),
        .rstn      (rstn),
        .valid_in  (valid_in),
        .data_a    (in_data),
        .data_b    (mult_coeff),
        .valid_out (mult_valid_out),
        .result    (mult_result)
    );

    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            valid_out <= 1'b0;
        end else begin
            valid_out <= mult_valid_out;
        end
    end

    assign out_data = mult_result;

endmodule

Kết quả đo lường và đánh giá chi tiết

1. Tổng hợp tài nguyên phần cứng (Synthesis & Implementation Results)

Mô hình DQN_TOP được tổng hợp và thực thi trên dòng chip Xilinx Virtex-7 (xc7vx485tffg1927-1) sử dụng công cụ Vivado Design Suite.

┌─────────────────────────────────────────────────────────────┐
│             PHÂN BỔ TÀI NGUYÊN FPGA VIRTEX-7                │
│                                                             │
│  LUT:   [████████████░░░░░░░░░░░░░░░░░░░░░░] 38.4% (116.6K) │
│  FF:    [█████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 16.2% (98.3K)  │
│  DSP:   [█████████████████████░░░░░░░░░░░░░] 65.7% (1,840)  │
│  BRAM:  [████████░░░░░░░░░░░░░░░░░░░░░░░░░░] 26.8% (276)    │
└─────────────────────────────────────────────────────────────┘
Loại tài nguyên Sử dụng (Used) Khả dụng (Available) Tỷ lệ sử dụng (%)
LUT (Slice LUTs) 116,580 303,600 38.40 %
LUTRAM (Distributed RAM) 14,210 130,800 10.86 %
FF (Flip-Flops) 98,340 607,200 16.20 %
DSP48E1 Slices 1,840 2,800 65.71 %
Block RAM (BRAM 36Kb) 276 1,030 26.80 %

2. Độ trễ và sai số tính toán

  • Worst Negative Slack (WNS): $+0.412 \text{ ns}$ tại chu kỳ xung nhịp $T = 4.7 \text{ ns}$, khẳng định thiết kế thỏa mãn hoàn toàn ràng buộc thời gian (Timing Closure) ở tần số $212.7 \text{ MHz}$.
  • Sai số số học dấu chấm động: Kiểm thử 1,000 vector trạng thái ngẫu nhiên so khớp trực tiếp giữa tín hiệu ngõ ra phần cứng Verilog với mô hình phần mềm 64-bit chuẩn (Golden C++/Python Model). Sai số tuyệt đối lớn nhất đạt được là $3.547 \times 10^{-5}$, hoàn toàn nằm trong giới hạn cho phép của chuẩn IEEE-754 đơn chính xác mà không gây suy giảm chất lượng huấn luyện.

3. Đường cong đào tạo (Training Curve) trên CartPole-v0

Trong 500 Episodes huấn luyện liên tục:

  • 0 - 50 Episodes đầu: Tác nhân chủ yếu khám phá ngẫu nhiên ($\varepsilon = 1.0$), thời gian duy trì con lắc trung bình từ 15 - 35 steps.
  • Episode 50 - 200: Cơ chế $\varepsilon$-decay và bộ đệm Experience Replay phát huy tác dụng; mạng chính liên tục cập nhật sai số Temporal Difference, điểm thưởng trung bình tăng nhanh từ 40 lên 160 steps.
  • Episode 200 - 500: Mô hình đạt trạng thái ổn định hoàn toàn, liên tục đạt điểm số tối đa 200/200 steps trong nhiều phiên liên tiếp, chứng minh khả năng tự điều khiển cân bằng bền vững của phần cứng.

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

Các đột phá kỹ thuật tiêu biểu

  1. Kiến trúc tính toán nơ-ron tuần tự kết hợp cây cộng (Sequential PE with Adder Tree): Giải quyết triệt để bài toán thắt nút cổ chai về tài nguyên DSP trên FPGA. Bằng việc kết hợp bộ chuyển đổi dữ liệu S2P và cây cộng nhị phân, thiết kế cho phép tính toán mạng nơ-ron đa node với lượng DSP giảm hơn 65% so với kiến trúc song song thuần túy mà vẫn duy trì tần số xung nhịp cao ($> 200 \text{ MHz}$).
  2. Công thức phi tuyến Leaky ReLU chặn dải biên: Loại bỏ hiện tượng bùng nổ số mũ (Exponent Overflow) trong tính toán Backpropagation số thực FP-32 bằng việc áp dụng hệ số suy giảm kép $a = 0.5$ và $b = 0.01$.
  3. Bộ sinh số ngẫu nhiên phần cứng kép (RNG-FP): Thiết kế bộ tạo số thực ngẫu nhiên đồng đều trong khoảng $[0.0, 1.0]$ bằng cách kết hợp Fibonacci LFSR và Galois LFSR với mạch chuẩn hóa số mũ FP-32, phục vụ chính xác thuật toán $\varepsilon$-greedy mà không tiêu tốn chu kỳ tính toán của vi xử lý ngoài.
┌─────────────────────────────────────────────────────────────┐
│                 BỘ SINH SỐ NGẪU NHIÊN RNG-FP                │
│                                                             │
│  ┌──────────────────┐                                       │
│  │  Fibonacci LFSR  │──┐                                    │
│  └──────────────────┘  │    ┌──────────────┐   ┌─────────┐  │
│                        ├───►│ Bộ Ghép Bit  ├──►│ Chuẩn   │  │
│  ┌──────────────────┐  │    │  (23-bit M)  │   │ hóa     ├──► FP-32 [0,1]
│  │   Galois LFSR    │──┘    └──────────────┘   │ IEEE754 │  │
│  └──────────────────┘       Exponent = 127-E   └─────────┘  │
└─────────────────────────────────────────────────────────────┘

So sánh với các nghiên cứu tiền nhiệm

Đặc tính kỹ thuật Nghiên cứu của X. Zhang et al. [1] Nghiên cứu OS-ELM [5] Đề tài nghiên cứu này
Mô hình học máy Q-Learning (Dạng bảng) OS-ELM (1 lớp ẩn) Deep Q-Network (Đa lớp ẩn)
Thuật toán học Tra cứu bảng giá trị $Q$ Nghịch đảo ma trận giải tích Backpropagation On-chip + SGD
Độ trễ phản hồi (Inference) $12.4 \ \mu\text{s}$ $2.1 \ \mu\text{s}$ $0.51 \ \mu\text{s}$
Công suất hoạt động $2.8 \text{ W}$ $3.4 \text{ W}$ $1.353 \text{ W}$
Cơ chế ổn định Không L2 Normalization Experience Replay + Target Net

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

Kịch bản ứng dụng công nghiệp

  • Điều khiển Robot tốc độ siêu cao (Ultra-Low Latency Robotics): Áp dụng trực tiếp vào các hệ thống tay máy công nghiệp, cân bằng robot hai chân (Bipedal Robot) và máy bay không người lái (UAV) đòi hỏi chu kỳ phản hồi dưới $1 \text{ ms}$ mà CPU/GPU không thể đáp ứng do trễ ngắt hệ điều hành.
  • Hệ thống giao dịch tài chính tần số cao (High-Frequency Trading - HFT): Khả năng đưa ra quyết định mua/bán tối ưu dựa trên học tăng cường với độ trễ tính toán cấp độ nanosecond trực tiếp trên card FPGA PCIe.
  • Tối ưu hóa lưới điện thông minh (Smart Grid Power Routing): Điều phối phân bổ nguồn năng lượng tái tạo phân tán theo thời gian thực mà không làm tiêu hao năng lượng của trạm điều khiển biên.

Quy trình triển khai phần cứng

┌─────────────────────────────────────────────────────────────┐
│                 QUY TRÌNH TRIỂN KHAI PHẦN CỨNG              │
│                                                             │
│  Mã nguồn Verilog ──► Vivado Synthesis ──► Place & Route   │
│                                                   │         │
│                                                   ▼         │
│  Hệ thống Điều khiển ◄── Embedded Linux ◄── Bitstream (.bit)│
│  (AXI4-Stream / UART)     (Zynq / PCIe)    (Virtex-7 FPGA)  │
└─────────────────────────────────────────────────────────────┘
  1. Synthesis & Bitstream Generation: Sử dụng Xilinx Vivado để đóng gói toàn bộ kiến trúc RTL thành file bitstream cấu hình (.bit).
  2. Interface Wrapping: Bọc module DQN_TOP với các chuẩn giao tiếp công nghiệp thông dụng như AXI4-Stream hoặc AXI-Lite để kết nối trực tiếp với bộ xử lý ARM (trên các dòng Zynq-7000/UltraScale+ SoC) hoặc giao tiếp PCIe với máy chủ.
  3. Flash Deployment: Nạp file cấu hình vào bộ nhớ QSPI Flash trên bo mạch để hệ thống tự khởi chạy độc lập (Standalone Edge Device) ngay khi cấp nguồn.

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

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

  • Cấu hình mạng cố định tại thời điểm tổng hợp: Việc thay đổi số lượng lớp ẩn hoặc số nơ-ron đòi hỏi phải biên dịch lại mã nguồn Verilog thông qua Vivado, chưa hỗ trợ nạp cấu trúc động trong lúc hệ thống đang chạy (Run-time Reconfigurability).
  • Dung lượng Experience Replay phụ thuộc BRAM: Do giới hạn tài nguyên bộ nhớ nội của FPGA, kích thước bộ đệm kinh nghiệm bị khống chế ở mức vài nghìn mẫu; chưa thể mở rộng lên hàng triệu mẫu như trên các hệ thống máy chủ lớn sử dụng DDR.

Định hướng mở rộng tương lai

  1. Lượng tử hóa số học (Quantization): Chuyển đổi định dạng dấu chấm động FP-32 sang dạng dấu chấm tĩnh INT8 hoặc Bfloat16 nhằm giảm $75%$ tài nguyên bộ nhớ BRAM và nhân đôi tốc độ xử lý.
  2. Hỗ trợ không gian hành động liên tục: Mở rộng kiến trúc phần cứng sang các thuật toán DRL tiên tiến hơn như Deep Deterministic Policy Gradient (DDPG) hoặc Soft Actor-Critic (SAC).
  3. Triển khai đa tác nhân (Multi-Agent RL): Tận dụng tính song song của FPGA để hiện thực nhiều lõi DQN song song trên cùng một chip, phục vụ điều khiển đàn robot (Swarm Robotics).

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

┌─────────────────────────────────────────────────────────────┐
│                     ĐỐI TƯỢNG HƯỞNG LỢI                     │
│                                                             │
│   Sinh viên / NCG           Kỹ sư Vi mạch & AI              │
│   ┌─────────────────────┐   ┌───────────────────────────┐   │
│   │ Mẫu thiết kế RTL    │   │ Mẫu thiết kế RTL chuẩn    │   │
│   │ Co-simulation mẫu   │   │ Tối ưu hóa DSP / Pipeline │   │
│   └─────────────────────┘   └───────────────────────────┘   │
│                                                             │
│   Doanh nghiệp Công nghệ    Viện Nghiên cứu                 │
│   ┌─────────────────────┐   ┌───────────────────────────┐   │
│   │ Bộ gia tốc AI biên  │   │ Cơ sở phát triển DRL      │   │
│   │ Giảm 85% năng lượng │   │ trên phần cứng tái cấu    │   │
│   │                     │   │ trúc                      │   │
│   └─────────────────────┘   └───────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
  • Sinh viên và Học viên Cao học: Tài liệu tham khảo toàn diện về phương pháp luận thiết kế hệ thống tính toán học sâu trên phần cứng, cung cấp mã nguồn RTL và quy trình kiểm thử Co-simulation mẫu bằng cocotb.
  • Kỹ sư Thiết kế Vi mạch và Kỹ sư AI Phần cứng: Nắm bắt kỹ thuật tối ưu hóa đường ống số học dấu chấm động IEEE-754, kỹ thuật chia sẻ tài nguyên tính toán (Resource Sharing) và kiến trúc xử lý Backpropagation trên chip.
  • Doanh nghiệp Tự động hóa và Robot: Giải pháp công nghệ ứng dụng để phát triển các dòng sản phẩm điều khiển biên thông minh, cắt giảm hơn $85%$ chi phí năng lượng so với các giải pháp dùng GPU nhúng.
  • Các nhóm nghiên cứu Học máy chuyên sâu: Dữ liệu thực nghiệm chứng minh tính khả thi của việc huấn luyện học tăng cường trực tiếp trên phần cứng tái cấu trúc (Reconfigurable Computing).

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

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

Để tổng hợp và kiểm thử thiết kế, bạn cần công cụ Xilinx Vivado Design Suite (khuyến nghị phiên bản 2020.2 trở lên), nền tảng Python 3.8+ cài đặt gói cocotb, cocotb-test, gym==0.21.0 và một bo mạch phát triển FPGA như Xilinx VC707 (Virtex-7) hoặc các dòng Zynq UltraScale+.

2. Tại sao thiết kế lại dùng định dạng FP-32 thay vì Fixed-point để tiết kiệm tài nguyên?

Học tăng cường có độ nhạy cảm rất cao với sai số tích lũy của gradient trong quá trình lan truyền ngược. Sử dụng Fixed-point với độ rộng bit nhỏ dễ làm trôi trọng số và phân kỳ hàm $Q$. Định dạng IEEE-754 FP-32 đảm bảo dải động (Dynamic Range) đủ rộng để thuật toán SGD hội tụ chính xác tương đương mô hình phần mềm.

3. Thiết kế giải quyết bài toán đồng bộ giữa môi trường ngoài và FPGA như thế nào?

Hệ thống sử dụng cơ chế bắt tay tín hiệu (Handshaking Mechanism) thông qua các cờ valid_in, ready, valid_out và done_env. Mạch điều khiển FSM của FPGA sẽ chuyển sang trạng thái chờ khi môi trường tính toán trạng thái mới và chỉ tiếp tục xử lý khi có tín hiệu kích hoạt, triệt tiêu nguy cơ mất mát dữ liệu.

4. Chi phí phần cứng và mức độ tiết kiệm năng lượng thực tế ra sao?

Với mức công suất tiêu thụ đo được chỉ $1.353 \text{ W}$ trên chip Virtex-7, thiết kế tiêu thụ năng lượng thấp hơn từ 15 đến 30 lần so với các nền tảng GPU biên phổ biến (như NVIDIA Jetson Xavier/Nano vốn tiêu thụ 10W - 30W), trong khi mang lại độ trễ suy luận ổn định ở mức $0.51 \ \mu\text{s}$ trên mỗi bước quyết định.

5. Làm thế nào để mở rộng mô hình cho các bài toán điều khiển phức tạp hơn?

Bạn chỉ cần thay đổi các tham số STATE_NUM (kích thước vector trạng thái), ACTION_NUM (số lượng hành động) và HIDDEN_NODES trong module tham số chung DQN_PARAMS.vh. Cấu trúc generate trong Verilog sẽ tự động tạo ra số lượng khối tính toán PE và ma trận trọng số tương ứng trong quá trình tổng hợp.

Kết luận

Đồ án tốt nghiệp "Nghiên cứu và thiết kế mô hình học tăng cường trên FPGA với môi trường CartPole" của nhóm tác giả Huỳnh Xuân Min và Trần Văn Khoa đã hiện thực hóa thành công một kiến trúc phần cứng Deep Q-Network hoàn chỉnh, có khả năng tự tương tác, lưu trữ kinh nghiệm và tự huấn luyện hoàn toàn trên chip FPGA.

Bằng việc làm chủ thiết kế từ cấp độ thanh ghi (RTL), tối ưu hóa các phép toán số thực dấu chấm động IEEE-754, đề xuất hàm kích hoạt Leaky ReLU chống tràn số mũ và triển khai cơ chế Co-simulation hiện đại, nghiên cứu đã đạt được các chỉ số ấn tượng: tần số hoạt động cực đại $212.7 \text{ MHz}$, công suất tiêu thụ tối ưu $1.353 \text{ W}$ và điều khiển cân bằng hoàn hảo môi trường CartPole-v0. Đây là bước đệm quan trọng mở ra tiềm năng ứng dụng các thuật toán Trí tuệ nhân tạo tự thích nghi trên các thiết bị tính toán biên hiệu năng cao thế hệ mới.