Note：强化学习(一)

2026 | ming

本系列文章并非我以往的入门教程风格，不追求面面俱到、循序渐进地带新手走进强化学习。相反，它是我个人在学习强化学习过程中所整理笔记的一次重新梳理与分享。

如果你已经学过强化学习的基础知识，但因为时间久远而遗忘了大部分细节，希望快速重温核心概念与典型算法，那么这份笔记将非常适合你。它默认你已有一定的理论背景（例如知道什么是状态、动作、奖励、策略、价值函数等），因此不会从零解释基本术语，而是着重帮你把零散的记忆"串"起来。

笔记中附带的所有代码均可直接复制执行，且每一行代码都配有详细的注释，清晰说明核心逻辑、参数含义及实现思路。这些代码的可扩展性很高，你可以直接以这些代码为模板，根据特定的任务场景、数据特点，灵活调整参数设置、优化模型结构，快速适配不同的强化学习任务，无需从零搭建代码框架，大大节省开发和调试时间。

本系列所有代码和笔记都会以jupyter笔记的形式开源，本系列末尾会附上Github链接。

参考文献

v π ( s ) v_{\\pi}(s)

这里的 <math xmlns="http://www.w3.org/1998/Math/MathML"> G t G_{t} </math>Gt 是从状态 <math xmlns="http://www.w3.org/1998/Math/MathML"> s s </math>s 出发，遵循策略 <math xmlns="http://www.w3.org/1998/Math/MathML"> π \pi </math>π 所能获得的回报（return）。当模型已知时，我们可以通过贝尔曼方程递归地解这个期望。但在模型未知时，这个期望分布是隐式的------我们没法写出它的概率密度函数。

蒙特卡洛方法的处理方式很直接：不进行解析计算，而是从经验中采样 。我们让智能体在环境中实际运行（称为一个 episode），记录从某个状态出发后续获得的真实回报 <math xmlns="http://www.w3.org/1998/Math/MathML"> G G </math>G ，然后通过多次采样的平均值来逼近真实的价值。

具体来说，如果我们在第 <math xmlns="http://www.w3.org/1998/Math/MathML"> i i </math>i 个 episode 中观察到从状态 <math xmlns="http://www.w3.org/1998/Math/MathML"> s s </math>s 出发的回报为 <math xmlns="http://www.w3.org/1998/Math/MathML"> G ( i ) G^{(i)} </math>G(i) ，那么经过 <math xmlns="http://www.w3.org/1998/Math/MathML"> n n </math>n 次独立采样后，状态价值的估计为：
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> V n ( s ) = G ( 1 ) + G ( 2 ) + . . . + G ( n ) n V_{n}(s)=\frac{G^{(1)}+G^{(2)}+...+G^{(n)}}{n} </math>Vn(s)=nG(1)+G(2)+...+G(n)

这种"观测-平均"的思路，就是蒙特卡洛方法的核心。

在实际操作中，一个 episode 通常包含多个状态。有意思的是，一次完整的采样可以更新路径上所有状态的价值估计，而不只是最终状态。

假设智能体从起点出发，依次经过状态 <math xmlns="http://www.w3.org/1998/Math/MathML"> A → B → C A \to B \to C </math>A→B→C ，最终到达终点。在每个时间步获得的奖励分别为 <math xmlns="http://www.w3.org/1998/Math/MathML"> R 0 , R 1 , R 2 R_0,R_1,R_2 </math>R0,R1,R2。由于回报 <math xmlns="http://www.w3.org/1998/Math/MathML"> G t G_t </math>Gt 定义为未来折扣奖励之和，我们可以从后向前递推计算，如图4.1：
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> G C = R 2 G B = R 1 + γ G C G A = R 0 + γ G B \begin{aligned} & G_{C} = R_{2} \\ & G_{B} = R_{1} + \gamma G_{C} \\ & G_{A} = R_{0} + \gamma G_{B} \end{aligned} </math>GC=R2GB=R1+γGCGA=R0+γGB

这种反向计算非常高效------一次完整的 episode 结束，我们就能得到这条轨迹上所有访问过的状态的真实回报值。这也是为什么蒙特卡洛方法需要等到 episode 结束才能进行更新。

在实际进行策略控制（control）时，我们不用 <math xmlns="http://www.w3.org/1998/Math/MathML"> V π ( s ) V_{\pi}(s) </math>Vπ(s) 而是用 <math xmlns="http://www.w3.org/1998/Math/MathML"> Q π ( s , a ) Q_{\pi}(s,a) </math>Qπ(s,a) 。如果我们只有 <math xmlns="http://www.w3.org/1998/Math/MathML"> V π ( s ) V_{\pi}(s) </math>Vπ(s)，在改进策略时会遇到一个根本性问题：我们不知道选择哪个动作更好 。因为 <math xmlns="http://www.w3.org/1998/Math/MathML"> v π ( s ) v_{\pi}(s) </math>vπ(s) 已经隐含了对动作 <math xmlns="http://www.w3.org/1998/Math/MathML"> a a </math>a 的期望（即按照 <math xmlns="http://www.w3.org/1998/Math/MathML"> π \pi </math>π 选择动作），它无法告诉你"如果此刻我选择动作 <math xmlns="http://www.w3.org/1998/Math/MathML"> a a </math>a 会怎样"。

而动作价值函数 <math xmlns="http://www.w3.org/1998/Math/MathML"> Q π ( s , a ) Q_{\pi}(s,a) </math>Qπ(s,a) 估计的是"在状态 <math xmlns="http://www.w3.org/1998/Math/MathML"> s s </math>s 下具体执行动作 <math xmlns="http://www.w3.org/1998/Math/MathML"> a a </math>a ，然后遵循策略 <math xmlns="http://www.w3.org/1998/Math/MathML"> π \pi </math>π 的期望回报"：
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> Q π ( s , a ) = E π [ G t ∣ S t = s , A t = a ] Q_{\pi}(s,a)=\mathbb{E} {\pi}[G{t}|S_{t}=s,A_{t}=a] </math>Qπ(s,a)=Eπ[Gt∣St=s,At=a]

有了 <math xmlns="http://www.w3.org/1998/Math/MathML"> Q Q </math>Q 函数，策略改进变得异常简单：直接在每个状态下选择 <math xmlns="http://www.w3.org/1998/Math/MathML"> Q Q </math>Q 值最大的动作即可 。更重要的是，基于 <math xmlns="http://www.w3.org/1998/Math/MathML"> Q Q </math>Q 的更新天然兼容 <math xmlns="http://www.w3.org/1998/Math/MathML"> ϵ \epsilon </math>ϵ-greedy 等探索策略------我们可以持续地评估那些当前策略不会选择的动作，从而保证探索。

因此，MC 控制的流程通常是这样的循环：
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> 采样 episode → 更新 Q ( s , a ) → 改进 π → 采样 episode → ⋯ \text{采样 episode} \rightarrow \text{更新 } Q(s,a) \rightarrow \text{改进 } \pi \rightarrow \text{采样 episode} \rightarrow \cdots </math>采样 episode→更新 Q(s,a)→改进 π→采样 episode→⋯

在实际实现中，如果我们每次都用 <math xmlns="http://www.w3.org/1998/Math/MathML"> Q n ( s , a ) = 1 n ∑ G ( i ) Q_n(s,a) = \frac{1}{n}\sum G^{(i)} </math>Qn(s,a)=n1∑G(i) 来计算，就需要存储所有的历史回报。这在内存上是不经济的。好在，我们可以推导出增量式更新 的形式。通过简单的代数变形，第 <math xmlns="http://www.w3.org/1998/Math/MathML"> n n </math>n 次估计可以表示为第 <math xmlns="http://www.w3.org/1998/Math/MathML"> n − 1 n-1 </math>n−1 次估计加上一个修正项：
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> Q n ( s , a ) = Q n − 1 ( s , a ) + 1 n [ G ( n ) − Q n − 1 ( s , a ) ] Q_n(s,a) = Q_{n-1}(s,a) + \frac{1}{n}\left[G^{(n)} - Q_{n-1}(s,a)\right] </math>Qn(s,a)=Qn−1(s,a)+n1[G(n)−Qn−1(s,a)]

这个形式非常优美：新的估计等于旧的估计，朝着新观测到的回报 <math xmlns="http://www.w3.org/1998/Math/MathML"> G ( n ) G^{(n)} </math>G(n) 迈出一小步（步长为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 n \frac{1}{n} </math>n1）。这种写法非常省内存，实际上我们可以把 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 n \frac{1}{n} </math>n1 替换为一个定值 <math xmlns="http://www.w3.org/1998/Math/MathML"> α \alpha </math>α (这个值也叫指数移动平均)，指数移动平均为较新的数据赋予了更大的权重，使得训练的更加稳定，效果更好。
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> Q n ( s , a ) ← Q n − 1 ( s , a ) + α [ G ( n ) − Q n − 1 ( s , a ) ] Q_n(s,a) \leftarrow Q_{n-1}(s,a) + \alpha\left[G^{(n)} - Q_{n-1}(s,a)\right] </math>Qn(s,a)←Qn−1(s,a)+α[G(n)−Qn−1(s,a)]

虽然蒙特卡洛方法概念简单、实现直接，但它有两个明显的痛点：

第一，高方差 。由于 <math xmlns="http://www.w3.org/1998/Math/MathML"> G G </math>G 是一系列随机奖励的折扣和，它的方差会随着轨迹长度指数级增长。这意味着 MC 估计的波动可能很大，收敛速度较慢，尤其是在长轨迹场景中。

第二，必须等待 episode 结束。这限制了 MC 方法在连续任务（non-episodic tasks）中的应用，也让它在实时性要求高的场景中显得笨拙。如果环境是一个超长的棋局，或者根本没有明确的终止状态，MC 就无法直接应用。

4.2 代码实现

如下是蒙特卡洛算法的具体实现：

python 复制代码

import numpy as np
from collections import defaultdict

def train_monte_carlo(env, episodes=2000, gamma=0.95, eps=0.2, alpha=0.05):
    """
    使用蒙特卡洛方法训练智能体，返回一个表示每个格子最佳动作的二维矩阵。

    参数:
        env: GridWorld 环境对象，需要提供 reset() 和 step(action) 方法。
        episodes: 训练的 episode 总数，每个 episode 从起点走到终点（或掉入陷阱）结束。
        gamma: 折扣因子，表示未来奖励在当前时刻的价值衰减程度（0~1）。
        eps: epsilon-贪心策略中的探索概率，以一定概率随机选择动作，避免陷入局部最优。
        alpha: 学习率，控制每次更新 Q 值时对新样本的采纳程度（0~1）。

    返回:
        policy_map: 二维 numpy 数组，形状为 (height, width)，每个元素为 0,1,2,3 分别代表
                    上、下、左、右动作；若为 -1 则表示该格子为障碍物（不可通行）。
    """
    
    # Q 值表：字典，键为 (state, action) 元组，值为该状态-动作对的估计价值。
    # 使用 defaultdict(float) 使得未出现过的键默认值为 0.0，无需手动初始化。
    Q = defaultdict(float)

    # 策略表：字典，键为 state，值为该状态下每个动作被选中的概率分布。
    # 初始化为等概率（每个动作 0.25），即完全随机策略。
    policy = defaultdict(lambda: {a: 0.25 for a in range(4)})

    # 主训练循环，重复 episodes 次
    for _ in range(episodes):
        # 重置环境，获取起始状态，并清空本轮的轨迹记忆列表
        state = env.reset()
        memory = []          # 存储本轮轨迹：每个元素为 (state, action, reward)
        done = False         # 是否到达终止状态（目标或陷阱）

        # ---------- 采样阶段：与环境交互，收集一条完整的 episode ----------
        while not done:
            # 根据当前策略 policy 获取状态 state 下各动作的概率
            probs = policy[state]
            # 按概率随机选择一个动作
            action = np.random.choice(list(probs.keys()), p=list(probs.values()))
            
            # 执行动作，得到下一个状态、即时奖励和是否终止的标志
            next_state, reward, done = env.step(action)
            
            # 将本次转移记录到 memory 中（用于后续学习）
            memory.append((state, action, reward))
            
            # 更新当前状态，准备下一步
            state = next_state

        # ---------- 学习阶段：利用收集到的轨迹更新 Q 值和策略 ----------
        G = 0   # 累积回报，从终止状态向前累加（蒙特卡洛的核心）
        
        # 反向遍历轨迹，从最后一步回到第一步
        for state, action, reward in reversed(memory):
            # 计算当前时刻的回报 G：立即奖励 + 折扣后的未来回报
            G = reward + gamma * G
            
            # 状态-动作对的键
            key = (state, action)
            
            # 增量式更新 Q 值：新估计 = 旧估计 + alpha * (目标值 - 旧估计)
            # 目标值 G 就是本次 episode 中从该步开始的实际折扣累积奖励
            Q[key] += alpha * (G - Q[key])
            
            # 根据更新后的 Q 值，重新计算该状态的 epsilon-贪心策略
            # 1. 获取当前状态下所有动作的 Q 值
            q_vals = [Q[(state, a)] for a in range(4)]
            
            # 2. 找出最大 Q 值对应的动作（如果有多个，np.argmax 返回第一个）
            best = np.argmax(q_vals)
            
            # 3. 计算基础概率：每个动作至少获得 eps/4 的概率
            base = eps / 4
            
            # 4. 生成新的策略概率分布字典：
            #    - 非最优动作：仅获得基础概率 base
            #    - 最优动作：额外获得 (1 - eps) 的概率
            policy[state] = {a: base + (1 - eps if a == best else 0) for a in range(4)}

    # ---------- 训练结束，生成最终的确定性策略地图 ----------
    # 识别障碍物格子：env.reward_map 中值为 None 的位置即为障碍物
    obstacle = np.vectorize(lambda x: x is None)(env.reward_map)
    
    # 初始化策略地图，默认所有格子为 0
    policy_map = np.zeros((env.height, env.width), dtype=int)
    
    # 遍历每一个格子
    for r in range(env.height):
        for c in range(env.width):
            # 如果是障碍物，标记为 -1
            if obstacle[r, c]:
                policy_map[r, c] = -1
            else:
                # 否则，计算该状态下所有动作的 Q 值，选择最大 Q 值对应的动作
                q_vals = [Q[((r, c), a)] for a in range(4)]
                policy_map[r, c] = np.argmax(q_vals)
    
    return policy_map

4.3 结果展示

还是使用3.2小节搭建的网格世界环境来测试蒙特卡洛算法，测试代码如下：

python 复制代码

env = GridWorld(
    height=6,
    width=6,
    goal_state=(5, 5),
    start_state=(0,0),
    obstacle_ratio=0.1,  
    trap_ratio=0.3,  
)
env.render()	# 如图4.2

policy_map = train_monte_carlo(env, episodes=2000)

env.render(policy_map=policy_map)	# 如图4.3

END~