基于FPGA的Qlearning强化学习模型设计指南

随着人工智能技术的飞速发展，深度学习和强化学习已经在图像识别、自然语言处理、自动驾驶、机器人控制等领域取得了突破性进展。然而，传统的GPU和CPU平台在部署这些模型时，往往面临功耗高、延迟大、体积大等问题，难以满足边缘计算和实时推理的需求。FPGA凭借其高度并行的计算架构、可重构性、低功耗和低延迟等优势，成为部署AI模型的理想硬件平台。本文将以Q-Learning作为强化学习的代表，系统阐述如何在FPGA上实现这两种模型。文章将从数学原理出发，逐步分析每一个关键计算步骤，并给出相应的Verilog硬件描述语言实现代码，帮助读者建立从算法到硬件的完整映射关系。

1.Q-Learning基本原理

      Q-Learning是一种无模型（Model-Free）的强化学习算法，属于时序差分（Temporal Difference, TD）学习方法。其核心思想是学习一个动作价值函数Q(s,a)，表示在状态s下采取动作a所能获得的期望累积奖励。

1.1 Q值更新公式

Q-Learning的核心更新公式为：

其中：

将此公式展开：

1.2 ε-贪心策略

在选择动作时，Q-Learning通常采用ε-贪心（ε-greedy）策略来平衡探索和利用：

2.Q-Table的FPGA存储设计

       Q-Learning需要维护一个Q表，存储所有状态-动作对的Q值。假设有Ns个状态和Na个动作，Q表的大小为Ns×Na。在FPGA中，Q表可用Block RAM实现：

module q_table #(

    parameter NUM_STATES  = 16,

    parameter NUM_ACTIONS = 4,

    parameter DATA_WIDTH  = 16,

    parameter ADDR_WIDTH  = 6    // log2(16*4) = 6

)(

    input  wire                    clk,

    input  wire                    we,          // 写使能

    input  wire [ADDR_WIDTH-1:0]   addr_rd,     // 读地址

    input  wire [ADDR_WIDTH-1:0]   addr_wr,     // 写地址

    input  wire [DATA_WIDTH-1:0]   data_in,     // 写入数据

    output reg  [DATA_WIDTH-1:0]   data_out     // 读出数据

);

    // Q表存储：使用BRAM

    reg [DATA_WIDTH-1:0] q_mem [0:NUM_STATES*NUM_ACTIONS-1];

    // 初始化Q表为0

    integer i;

    initial begin

        for (i = 0; i < NUM_STATES * NUM_ACTIONS; i = i + 1)

            q_mem[i] = 0;

    end

    // 同步读写

    always @(posedge clk) begin

        if (we)

            q_mem[addr_wr] <= data_in;

        data_out <= q_mem[addr_rd];

    end

endmodule

地址映射关系：对于状态s和动作a，Q表中的地址为：

addr=s×Na+a

// 地址计算模块

module addr_calc #(

    parameter NUM_ACTIONS = 4

)(

    input  wire [3:0] state,

    input  wire [1:0] action,

    output wire [5:0] addr

);

    // 当NUM_ACTIONS为2的幂时，乘法可用移位实现

    assign addr = (state << 2) + action;  // state * 4 + action

endmodule

3. 求最大Q值模块

在Q值更新和动作选择中，都需要找到maxa′Q(st+1,a′)及其对应的动作。假设有4个动作：

对应的verilog设计如下：

module find_max_q #(

    parameter NUM_ACTIONS = 4

)(

    input  wire signed [15:0] q_values [0:NUM_ACTIONS-1],

    output reg  signed [15:0] max_q,

    output reg  [1:0]         best_action

);

    integer i;

    always @(*) begin

        max_q       = q_values[0];

        best_action = 2'd0;

        for (i = 1; i < NUM_ACTIONS; i = i + 1) begin

            if (q_values[i] > max_q) begin

                max_q       = q_values[i];

                best_action = i[1:0];

            end

        end

    end

endmodule

4.TD误差计算

时序差分（TD）误差是Q-Learning更新的核心，定义为：

其中每一步运算都需要用定点数实现：

即：

对应的verilog设计如下：

module td_error_calc (

    input  wire signed [15:0] reward,       // r_t (Q7.8)

    input  wire signed [15:0] gamma,        // 折扣因子 (Q7.8), e.g., 0.9 = 230

    input  wire signed [15:0] max_q_next,   // max Q(s_{t+1}, a')

    input  wire signed [15:0] q_current,    // Q(s_t, a_t)

    output wire signed [15:0] td_error      // δ

);

    // Step 1: gamma * max_q_next

    wire signed [31:0] gamma_q_full;

    wire signed [15:0] gamma_q;

    assign gamma_q_full = gamma * max_q_next;

    assign gamma_q = gamma_q_full[23:8];  // 截断回Q7.8

    // Step 2: r + gamma * max_q_next

    wire signed [15:0] target;

    assign target = reward + gamma_q;

    // Step 3: td_error = target - q_current

    assign td_error = target - q_current;

endmodule

5.Q值更新模块

完整的Q值更新公式：

其中α是学习率，δ是TD误差。

module q_update (

    input  wire signed [15:0] q_old,      // 当前Q值

    input  wire signed [15:0] alpha,      // 学习率 (Q7.8), e.g., 0.1 = 26

    input  wire signed [15:0] td_error,   // TD误差

    output wire signed [15:0] q_new       // 更新后的Q值

);

    // alpha * td_error

    wire signed [31:0] update_full;

    wire signed [15:0] update_step;

    assign update_full = alpha * td_error;

    assign update_step = update_full[23:8];  // 截断回Q7.8

    // Q_new = Q_old + alpha * td_error

    assign q_new = q_old + update_step;

endmodule

6.ε-贪心策略的FPGA实现

ε-贪心策略需要一个随机数生成器。在FPGA中，通常使用线性反馈移位寄存器（LFSR）来生成伪随机数：

module lfsr_random #(

    parameter WIDTH = 16

)(

    input  wire            clk,

    input  wire            rst_n,

    input  wire [WIDTH-1:0] seed,

    output wire [WIDTH-1:0] rand_out

);

    reg [WIDTH-1:0] lfsr_reg;

    // 16位LFSR，反馈多项式：x^16 + x^14 + x^13 + x^11 + 1

    wire feedback;

    assign feedback = lfsr_reg[15] ^ lfsr_reg[13] ^ lfsr_reg[12] ^ lfsr_reg[10];

    always @(posedge clk or negedge rst_n) begin

        if (!rst_n)

            lfsr_reg <= seed;

        else

            lfsr_reg <= {lfsr_reg[WIDTH-2:0], feedback};

    end

    assign rand_out = lfsr_reg;

endmodule

ε-贪心动作选择模块：

module epsilon_greedy #(

    parameter NUM_ACTIONS = 4

)(

    input  wire        clk,

    input  wire        rst_n,

    input  wire        enable,

    input  wire signed [15:0] epsilon,     // ε值 (Q7.8), e.g., 0.1 = 26

    input  wire [15:0]        rand_value,  // 随机数

    input  wire [1:0]         best_action, // argmax Q(s,a)

    output reg  [1:0]         selected_action,

    output reg                action_valid

);

    // 将随机数映射到[0, 1)范围（取高8位作为Q0.8）

    wire [7:0] rand_normalized;

    assign rand_normalized = rand_value[15:8];

    // epsilon的小数部分

    wire [7:0] eps_frac;

    assign eps_frac = epsilon[7:0];

    always @(posedge clk or negedge rst_n) begin

        if (!rst_n) begin

            selected_action <= 2'd0;

            action_valid    <= 1'b0;

        end else if (enable) begin

            if (rand_normalized < eps_frac) begin

                // 探索：随机选择动作

                selected_action <= rand_value[1:0];  // 用随机数低2位

            end else begin

                // 利用：选择最佳动作

                selected_action <= best_action;

            end

            action_valid <= 1'b1;

        end else begin

            action_valid <= 1'b0;

        end

    end

endmodule

7. Q-Learning完整控制器

综上所述，整个系统的流程图如下：

将以上模块整合成一个完整的Q-Learning控制器，通过状态机管理整个学习流程：

module q_learning_controller #(

    parameter NUM_STATES  = 16,

    parameter NUM_ACTIONS = 4,

    parameter DATA_WIDTH  = 16

)(

    input  wire                   clk,

    input  wire                   rst_n,

    input  wire                   start_episode,

    input  wire [3:0]             current_state,

    input  wire signed [15:0]     reward,

    input  wire [3:0]             next_state,

    input  wire                   episode_done,

    output reg  [1:0]             action_out,

    output reg                    action_valid,

    output reg                    update_done

);

    // 参数（Q7.8格式）

    localparam signed [15:0] ALPHA   = 16'sd26;   // 0.1

    localparam signed [15:0] GAMMA   = 16'sd230;  // 0.9

    localparam signed [15:0] EPSILON = 16'sd26;   // 0.1

    // 状态机状态

    localparam S_IDLE          = 4'd0;

    localparam S_READ_Q_ALL    = 4'd1;

    localparam S_WAIT_READ     = 4'd2;

    localparam S_SELECT_ACTION = 4'd3;

    localparam S_WAIT_ENV      = 4'd4;

    localparam S_READ_NEXT_Q   = 4'd5;

    localparam S_WAIT_NEXT     = 4'd6;

    localparam S_FIND_MAX      = 4'd7;

    localparam S_COMPUTE_TD    = 4'd8;

    localparam S_UPDATE_Q      = 4'd9;

    localparam S_WRITE_Q       = 4'd10;

    localparam S_DONE          = 4'd11;

    reg [3:0] fsm_state;

    reg [1:0] action_idx;      // 动作遍历索引

    reg signed [15:0] q_vals_current [0:NUM_ACTIONS-1];

    reg signed [15:0] q_vals_next    [0:NUM_ACTIONS-1];

    // Q表接口信号

    reg        q_we;

    reg [5:0]  q_addr_rd, q_addr_wr;

    reg signed [15:0] q_data_in;

    wire signed [15:0] q_data_out;

    // LFSR随机数

    wire [15:0] rand_val;

    // 内部计算信号

    wire signed [15:0] max_q_next;

    wire [1:0]         best_action;

    wire signed [15:0] td_err;

    wire signed [15:0] q_new;

    // 实例化Q表

    q_table #(

        .NUM_STATES(NUM_STATES),

        .NUM_ACTIONS(NUM_ACTIONS)

    ) u_qtable (

        .clk(clk), .we(q_we),

        .addr_rd(q_addr_rd), .addr_wr(q_addr_wr),

        .data_in(q_data_in), .data_out(q_data_out)

    );

    // 实例化LFSR

    lfsr_random u_lfsr (

        .clk(clk), .rst_n(rst_n),

        .seed(16'hACE1), .rand_out(rand_val)

    );

    // 实例化最大值查找

    find_max_q u_find_max (

        .q_values(q_vals_next),

        .max_q(max_q_next),

        .best_action(best_action)

    );

    // 实例化TD误差计算

    td_error_calc u_td (

        .reward(reward), .gamma(GAMMA),

        .max_q_next(max_q_next),

        .q_current(q_vals_current[action_out]),

        .td_error(td_err)

    );

    // 实例化Q值更新

    q_update u_qupdate (

        .q_old(q_vals_current[action_out]),

        .alpha(ALPHA), .td_error(td_err),

        .q_new(q_new)

    );

    // 主状态机

    always @(posedge clk or negedge rst_n) begin

        if (!rst_n) begin

            fsm_state    <= S_IDLE;

            action_idx   <= 0;

            action_out   <= 0;

            action_valid <= 0;

            update_done  <= 0;

            q_we         <= 0;

        end else begin

            case (fsm_state)

                S_IDLE: begin

                    update_done <= 0;

                    q_we <= 0;

                    if (start_episode) begin

                        action_idx <= 0;

                        fsm_state  <= S_READ_Q_ALL;

                    end

                end

                S_READ_Q_ALL: begin

                    // 逐个读取当前状态的所有Q值

                    q_addr_rd <= (current_state << 2) + action_idx;

                    fsm_state <= S_WAIT_READ;

                end

                S_WAIT_READ: begin

                    q_vals_current[action_idx] <= q_data_out;

                    if (action_idx == NUM_ACTIONS - 1) begin

                        action_idx <= 0;

                        fsm_state  <= S_SELECT_ACTION;

                    end else begin

                        action_idx <= action_idx + 1;

                        fsm_state  <= S_READ_Q_ALL;

                    end

                end

                S_SELECT_ACTION: begin

                    // ε-贪心选择

                    if (rand_val[15:8] < EPSILON[7:0])

                        action_out <= rand_val[1:0];

                    else begin

                        // 找当前状态最大Q值对应动作

                        // 简化实现：遍历比较

                        action_out <= 0;

                        if (q_vals_current[1] > q_vals_current[0])

                            action_out <= 1;

                        if (q_vals_current[2] > q_vals_current[action_out])

                            action_out <= 2;

                        if (q_vals_current[3] > q_vals_current[action_out])

                            action_out <= 3;

                    end

                    action_valid <= 1;

                    fsm_state    <= S_WAIT_ENV;

                end

                S_WAIT_ENV: begin

                    action_valid <= 0;

                    // 等待环境返回reward和next_state

                    // 此处简化，假设下一周期就能获取

                    action_idx <= 0;

                    fsm_state  <= S_READ_NEXT_Q;

                end

                S_READ_NEXT_Q: begin

                    q_addr_rd <= (next_state << 2) + action_idx;

                    fsm_state <= S_WAIT_NEXT;

                end

                S_WAIT_NEXT: begin

                    q_vals_next[action_idx] <= q_data_out;

                    if (action_idx == NUM_ACTIONS - 1) begin

                        fsm_state <= S_FIND_MAX;

                    end else begin

                        action_idx <= action_idx + 1;

                        fsm_state  <= S_READ_NEXT_Q;

                    end

                end

                S_FIND_MAX: begin

                    // find_max_q组合逻辑已计算好max_q_next

                    fsm_state <= S_COMPUTE_TD;

                end

                S_COMPUTE_TD: begin

                    // td_error_calc组合逻辑已计算好td_err

                    fsm_state <= S_UPDATE_Q;

                end

                S_UPDATE_Q: begin

                    // q_update组合逻辑已计算好q_new

                    fsm_state <= S_WRITE_Q;

                end

                S_WRITE_Q: begin

                    q_we      <= 1;

                    q_addr_wr <= (current_state << 2) + action_out;

                    q_data_in <= q_new;

                    fsm_state <= S_DONE;

                end

                S_DONE: begin

                    q_we        <= 0;

                    update_done <= 1;

                    fsm_state   <= S_IDLE;

                end

                default: fsm_state <= S_IDLE;

            endcase

        end

    end

endmodule

8.ε衰减机制

在Q-Learning训练过程中，ε值通常需要逐步衰减，从较多探索逐渐过渡到更多利用：

其中ϵdecay通常为0.995或0.99。

module epsilon_decay (

    input  wire        clk,

    input  wire        rst_n,

    input  wire        decay_trigger,       // 触发衰减

    input  wire signed [15:0] decay_factor, // 衰减因子 (Q7.8)，e.g., 0.995=255

    input  wire signed [15:0] epsilon_min,  // 最小epsilon

    output reg  signed [15:0] epsilon       // 当前epsilon

);

    localparam signed [15:0] EPSILON_INIT = 16'sd256;  // 1.0

    always @(posedge clk or negedge rst_n) begin

        if (!rst_n) begin

            epsilon <= EPSILON_INIT;

        end else if (decay_trigger) begin

            // epsilon = epsilon * decay_factor

            // 注意：两个Q7.8相乘后右移8位

            reg signed [31:0] new_eps;

            new_eps = (epsilon * decay_factor) >>> 8;

            // 下限约束

            if (new_eps[15:0] < epsilon_min)

                epsilon <= epsilon_min;

            else

                epsilon <= new_eps[15:0];

        end

    end

endmodule

9.总结

并行Q值读取：使用多端口RAM或将Q表分成多个Bank，允许同时读取一个状态对应的所有动作的Q值，从而将Q值读取从多个周期缩短到单个周期。

查找表加速：对于状态空间和动作空间较小的问题，可以将整个Q表分布在FPGA的分布式RAM（LUT RAM）中，实现单周期读写。

流水线化：将TD误差计算、Q值更新等步骤进行流水线化处理，使得在更新一个状态-动作对的同时，可以开始下一个状态的Q值读取。