필사 모드: 强化学习（Reinforcement Learning）完全指南：从理论基础到最新算法、实战实现

• 1. 强化学习概述
  • 1.1 核心构成要素
  • 1.2 强化学习的交互循环
  • 1.3 强化学习算法的分类
• 2. 数学基础
  • 2.1 Markov Decision Process（MDP）
  • 2.2 Return 与价值函数的定义
  • 2.3 Bellman 方程的推导
  • 2.4 Bellman Optimality Equation
  • 2.5 Advantage Function
• 3. 经典算法
  • 3.1 Dynamic Programming（DP）
  • 3.2 Monte Carlo（MC）Methods
  • 3.3 Temporal-Difference（TD）Learning
  • 3.4 SARSA（On-Policy TD Control）
  • 3.5 Q-Learning（Off-Policy TD Control）
• 4. Deep RL 革命
  • 4.1 DQN：Deep Q-Network（2013/2015）
  • 4.2 DQN 的改进变体
  • 4.3 Policy Gradient：REINFORCE
  • 4.4 Actor-Critic：A2C、A3C
  • 4.5 TRPO 与 PPO
  • 4.6 SAC：Soft Actor-Critic
  • 4.7 DDPG 与 TD3：连续动作空间
• 5. Model-based RL
  • 5.1 Model-based 的优势与挑战
  • 5.2 World Models（Ha & Schmidhuber，2018）
  • 5.3 MuZero（Schrittwieser 等，2020）
  • 5.4 Dreamer（Hafner 等，2020、2021、2023）
  • 5.5 自主算法发现：DiscoRL（2025）
• 6. RLHF：Reinforcement Learning from Human Feedback
  • 6.1 RLHF 流水线
  • 6.2 DPO：Direct Preference Optimization
  • 6.3 GRPO：Group Relative Policy Optimization
  • 6.4 LLM 对齐的最新动态（2025～2026）
• 7. 主要应用案例
  • 7.1 AlphaGo / AlphaZero / AlphaFold
  • 7.2 机器人技术
  • 7.3 游戏 AI
  • 7.4 推荐系统与其他应用
• 8. PyTorch 代码示例
  • 8.1 DQN 实现（CartPole）
  • 8.2 PPO 实现（CartPole）
• 9. 主要论文参考
• 10. RL 的现状局限与未来展望
  • 10.1 现状局限
  • 10.2 未来展望
• 结语

1. 强化学习概述

强化学习（Reinforcement Learning，RL）是机器学习三大支柱之一，与有监督学习（Supervised Learning）、无监督学习（Unsupervised Learning）有着根本不同的范式。有监督学习是从带标签的数据中学习模式，无监督学习是在没有标签的情况下把握数据结构，而强化学习则是通过与环境的交互，以试错（trial and error）的方式学习最优行动策略。

设想人类学骑自行车的过程。没有人会告诉你"把车把往左转 37 度，每秒踩 1.2 次踏板"。相反，摔倒时会受到疼痛的惩罚，保持平衡时会得到前进的奖励，人在这个过程中自行摸索出最优的平衡策略。这正是强化学习的本质。

1.1 核心构成要素

强化学习系统由以下核心要素构成。

Agent（智能体）： 在环境中执行行动的学习主体。游戏中的玩家、机器人、自动驾驶汽车等都属于智能体。

Environment（环境）： 智能体与之交互的外部世界。棋盘、物理仿真空间、真实道路环境等均属于此类。环境会针对智能体的行动返回下一个状态与奖励。

State（状态，$s \in \mathcal{S}$）： 表示环境当前状态的信息。国际象棋中的棋盘布局、机器人的关节角度、股价图当前的形态等都是状态。状态空间（State Space）$\mathcal{S}$ 是所有可能状态的集合。

Action（动作，$a \in \mathcal{A}$）： 智能体在每个状态下可以选择的行动。游戏中的摇杆方向、机械臂的扭矩值等都是动作。动作空间（Action Space）$\mathcal{A}$ 既可以是离散的（discrete），也可以是连续的（continuous）。

Reward（奖励，$r \in \mathbb{R}$）： 智能体在特定状态下采取特定行动后，从环境中获得的标量反馈信号。强化学习的目标是最大化长期累积奖励（cumulative reward），而不是最大化即时奖励。

Policy（策略，$\pi$）： 智能体的行动策略。它是一个把状态映射为行动（或行动的概率分布）的函数，是强化学习最终要学习的对象。

• 确定性策略（Deterministic Policy）：$a = \pi(s)$
• 随机性策略（Stochastic Policy）：$a \sim \pi(a|s)$

Value Function（价值函数，$V^\pi(s)$）： 遵循策略 $\pi$ 时，从状态 $s$ 出发所能期望获得的累积奖励。它把"这个状态有多好"这件事量化出来。

Action-Value Function（动作价值函数，$Q^\pi(s, a)$）： 在状态 $s$ 下先采取行动 $a$、之后遵循策略 $\pi$ 时所能期望获得的累积奖励。它把"在这个状态下采取这个行动有多好"这件事量化出来。

Discount Factor（折扣因子，$\gamma \in [0, 1]$）： 决定未来奖励在当下价值的折扣率。$\gamma = 0$ 时智能体只考虑即时奖励，$\gamma$ 越接近 1，对遥远未来奖励的重视程度就越接近当下。

1.2 强化学习的交互循环

强化学习的核心结构由以下反复的交互循环构成。

时刻 t：
  1. 智能体观测当前状态 s_t
  2. 依据策略 π 选择行动 a_t
  3. 环境执行该行动，返回奖励 r_{t+1} 与下一状态 s_{t+1}
  4. 智能体基于经验 (s_t, a_t, r_{t+1}, s_{t+1}) 更新策略
  5. t ← t + 1，重复

这个循环所产生的经验序列 $s_0, a_0, r_1, s_1, a_1, r_2, s_2, \ldots$ 被称为 Trajectory（轨迹）或 Episode（回合），它就是强化学习智能体的学习数据。

1.3 强化学习算法的分类

强化学习算法可以按多种标准分类。

2. 数学基础

2.1 Markov Decision Process（MDP）

强化学习的数学框架是 Markov Decision Process（MDP，马尔可夫决策过程）。MDP 是将序贯决策问题形式化的数学模型，由以下 5 元组定义。

• $\mathcal{S}$：状态空间（State Space）
• $\mathcal{A}$：动作空间（Action Space）
• $P(s'|s, a)$：状态转移概率（Transition Probability）—— 在状态 $s$ 下采取行动 $a$ 时转移到状态 $s'$ 的概率
• $R(s, a, s')$：奖励函数（Reward Function）—— 转移 $(s, a, s')$ 所对应的即时奖励
• $\gamma \in [0, 1)$：折扣因子（Discount Factor）

MDP 的核心是 Markov Property（马尔可夫性质）。未来状态只依赖于当前状态与当前行动，与过去所有的状态和行动历史无关。

正因为这一性质，我们才可以假设仅凭当前状态 $s_t$ 就足以包含决策所需的全部信息，这是让强化学习能够在数学上被处理的根本基础。

2.2 Return 与价值函数的定义

智能体的目标是最大化 Return（收益）。Return 定义为从时刻 $t$ 开始的折扣累积奖励。

Return 有一个重要的递归性质，如下所示。

这个递归关系正是后面 Bellman 方程的基础。

State-Value Function： 遵循策略 $\pi$ 时，从状态 $s$ 出发所能期望获得的 Return。

Action-Value Function： 遵循策略 $\pi$ 时，在状态 $s$ 下先采取行动 $a$ 之后所能期望获得的 Return。

两个函数之间的关系如下。

2.3 Bellman 方程的推导

Bellman Equation 是强化学习中最核心的数学工具。它利用 Return 的递归性质，把价值函数递归地表示出来。

State-Value Function 的 Bellman 方程推导：

代入 Return 的递归关系 $G_t = r_{t+1} + \gamma G_{t+1}$：

利用期望的线性性展开：

由于行动 $a$ 依策略 $\pi(a|s)$ 决定、下一状态 $s'$ 依转移概率 $P(s'|s,a)$ 决定，把整体期望展开成双重求和，就得到：

这就是 Bellman Expectation Equation for $V^\pi$。当前状态的价值，被表示为即时奖励与下一状态折扣价值的期望之和。

Action-Value Function 的 Bellman 方程：

用同样的方式也可以推导出 $Q^\pi$ 的方程。

2.4 Bellman Optimality Equation

最优策略 $\pi^*$ 是在所有状态下都能取得最高价值的策略。

最优价值函数 $V^*$ 与 $Q^*$ 定义如下。

Bellman Optimality Equation for $V^*$ 的推导：

在最优策略下，智能体在每个状态都会选择最优行动。因此，用最大化（max）取代由策略决定的期望。

代入 $Q^*$ 的 Bellman 方程：

Bellman Optimality Equation for $Q^*$：

这个方程的核心含义是：只要知道最优动作价值函数 $Q^*$，在每个状态下选择使 $Q^*$ 最大化的行动，就能得到最优策略。

2.5 Advantage Function

在这里定义之后在 Policy Gradient 系列算法中将发挥核心作用的 Advantage Function $A^\pi(s, a)$。

Advantage Function 表示"在状态 $s$ 下采取行动 $a$，相比平均水平的行动要好多少"。$A > 0$ 表示优于平均，$A < 0$ 表示劣于平均。对所有行动的 Advantage 求期望恒为 0。

3. 经典算法

3.1 Dynamic Programming（DP）

Dynamic Programming 是在已知环境的完整模型（转移概率 $P$ 与奖励函数 $R$）时可以使用的方法。现实中很少能精确知道环境模型，但 DP 是其他所有 RL 算法的理论基础。

Policy Evaluation（策略评估）： 计算给定策略 $\pi$ 的价值函数 $V^\pi$。通过反复应用 Bellman Expectation Equation 使其收敛。

Policy Improvement（策略改进）： 针对当前价值函数求出 greedy 策略。

Policy Iteration： 交替执行 Policy Evaluation 与 Policy Improvement，使其收敛到最优策略。

Value Iteration： 直接反复应用 Bellman Optimality Equation。

收敛后提取最优策略。可以把 Value Iteration 看作是 Policy Iteration 中，Policy Evaluation 只做一次 sweep 的特例。

3.2 Monte Carlo（MC）Methods

在不知道环境模型的 Model-free 情形下，Monte Carlo 方法通过真实经验（回合）来估计价值函数。核心思路很简单：运行多个回合，用每个状态（或状态-行动对）中观测到的 Return 的平均值作为价值函数的估计值。

其中 $N(s)$ 是状态 $s$ 被访问的次数，$G_t^{(i)}$ 是第 $i$ 次访问时的实际 Return。

MC 的优点： 不需要环境模型，能提供无偏（unbiased）的估计值。

MC 的缺点： 必须等到回合结束才能学习（只适用于 episodic 任务），且 Return 的方差（variance）较大。

3.3 Temporal-Difference（TD）Learning

TD Learning 结合了 DP 与 MC 各自的优点。既不需要环境模型（像 MC 一样），又能在回合结束之前每个时刻（step）都进行更新（像 DP 一样）。

TD(0) —— 最基本的 TD 方法：

这里 $\delta_t = r_{t+1} + \gamma V(s_{t+1}) - V(s_t)$ 称为 TD Error。更新幅度等于 TD Target（实际奖励 $r_{t+1}$ 加上下一状态的估计价值，即 $r_{t+1} + \gamma V(s_{t+1})$）与当前估计价值之间的差值。这被称为 Bootstrapping（自举）—— 用一个估计值去更新另一个估计值。

MC 与 TD 的比较：

TD($\lambda$)： 一种在 MC 与 TD(0) 之间插值的方法。$\lambda = 0$ 时等同于 TD(0)，$\lambda = 1$ 时等同于 MC。$\lambda$-Return 定义如下。

其中 $G_t^{(n)}$ 是 $n$-step Return。

3.4 SARSA（On-Policy TD Control）

SARSA 是一种 on-policy TD 控制算法，其名字来源于更新时所用的经验元组 $(S_t, A_t, R_{t+1}, S_{t+1}, A_{t+1})$。

SARSA 用实际执行的下一个行动 $a_{t+1}$ 的 Q 值来更新。由于这反映了当前策略（通常是 $\varepsilon$-greedy）实际会采取的行动的价值，因此也会把探索（exploration）过程中可能出现的危险行动纳入考虑。

3.5 Q-Learning（Off-Policy TD Control）

Q-Learning 是 Watkins（1989）提出的 off-policy TD 控制算法，是强化学习历史上最重要的算法之一。

与 SARSA 的决定性区别在于，Q-Learning 在下一状态使用的不是实际采取的行动，而是能给出最大 Q 值的行动（greedy action）。正因如此，Q-Learning 是 off-policy 的——无论智能体为了探索采取了什么行动，它总是朝着最优 Q 值收敛。

# Q-Learning 伪代码
import numpy as np

def q_learning(env, num_episodes, alpha=0.1, gamma=0.99, epsilon=0.1):
    Q = np.zeros((env.observation_space.n, env.action_space.n))

    for episode in range(num_episodes):
        state = env.reset()
        done = False

        while not done:
            # ε-greedy 行动选择
            if np.random.random() < epsilon:
                action = env.action_space.sample()  # 探索（exploration）
            else:
                action = np.argmax(Q[state])         # 利用（exploitation）

            next_state, reward, done, _ = env.step(action)

            # Q-Learning 更新：max over next actions
            td_target = reward + gamma * np.max(Q[next_state]) * (1 - done)
            td_error = td_target - Q[state, action]
            Q[state, action] += alpha * td_error

            state = next_state

    return Q

Q-Learning 的收敛条件： 已经证明，只要所有状态-行动对都被无限次访问，并且学习率满足 Robbins-Monro 条件（$\sum \alpha_t = \infty$，$\sum \alpha_t^2 < \infty$），Q-Learning 就会收敛到 $Q^*$。

4. Deep RL 革命

经典 RL 算法使用表格形式的价值函数，因此无法应用于状态空间庞大的问题。仅以 Atari 游戏为例，屏幕像素就是状态，状态空间达到 $256^{210 \times 160 \times 3}$，是一个天文数字。为了解决这个问题，把深度神经网络当作函数近似器（Function Approximator）使用的 Deep RL 应运而生。

4.1 DQN：Deep Q-Network（2013/2015）

论文： "Playing Atari with Deep Reinforcement Learning"（Mnih 等，2013）、"Human-level control through deep reinforcement learning"（Mnih 等，2015，Nature）

DQN 是开启 Deep RL 时代的里程碑式论文。它用 CNN（卷积神经网络）取代 Q-Learning 的 Q 表，直接从原始像素输入中估计动作价值。

其中 $\theta$ 是网络参数。学习目标是最小化以下损失函数。

但如果只是简单地用神经网络逼近 Q 函数，学习会变得极度不稳定。DQN 用两项关键创新解决了这个问题。

创新一：Experience Replay

连续的经验 $(s_t, a_t, r_{t+1}, s_{t+1})$ 在时间上具有很强的相关性，这违反了随机梯度下降（SGD）所假设的 i.i.d.（独立同分布）条件。Experience Replay 把经验存入 Replay Buffer $\mathcal{D}$，训练时再抽取随机小批量（mini-batch）使用，从而打破数据之间的相关性。

from collections import deque
import random

class ReplayBuffer:
    def __init__(self, capacity):
        self.buffer = deque(maxlen=capacity)

    def push(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))

    def sample(self, batch_size):
        batch = random.sample(self.buffer, batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        return states, actions, rewards, next_states, dones

    def __len__(self):
        return len(self.buffer)

创新二：Target Network

在更新 Q 值时，如果目标值（$r + \gamma \max_{a'} Q(s', a'; \theta)$）与预测值（$Q(s, a; \theta)$）都依赖同一网络的参数 $\theta$，目标值就会不断变动，可能导致学习发散。Target Network 会创建一个拥有独立参数 $\theta^-$ 的复制网络，并定期（例如每 10,000 步）把主网络的参数复制过去，从而稳定目标值。

也可以使用 soft update 方式：$\theta^- \leftarrow \tau \theta + (1 - \tau) \theta^-$

Atari 结果： DQN 在 49 款 Atari 2600 游戏中的 29 款上达到或超过了人类水平，尤其在 Breakout、Pong 等游戏中自主学会了令人惊讶的策略。

4.2 DQN 的改进变体

DQN 之后出现了大量改进。下面来看主要的几种变体。

Double DQN（van Hasselt 等，2016）： 标准 DQN 由于 max 运算符的存在，往往会高估（overestimation）Q 值。Double DQN 通过分离行动选择与行动评估来解决这个问题。

行动选择用在线网络（$\theta$）完成，行动评估用目标网络（$\theta^-$）完成。

Dueling DQN（Wang 等，2016）： 通过改变网络架构，把 Q 函数分解为 State-Value $V(s)$ 与 Advantage $A(s, a)$。

得益于这种分解，在行动选择无关紧要的状态下，只需准确学习 $V(s)$ 即可，因此效率更高。

Prioritized Experience Replay（Schaul 等，2016）： 不再以相同概率采样所有经验，而是更频繁地采样 TD Error 较大的经验，也就是让对学习更有用的经验获得优先权。

使用 importance sampling weight 来修正偏差：$w_i = \left( \frac{1}{N \cdot P(i)} \right)^\beta$

Noisy DQN（Fortunato 等，2018）： 不使用 $\varepsilon$-greedy，而是在网络权重上加入可学习的噪声来进行探索。

Categorical DQN / C51（Bellemare 等，2017）： 一种 Distributional RL 方法，不学习 Q 值的期望值，而是学习整个 Return 的分布。

Rainbow（Hessel 等，2018）： 把上述 6 项改进全部结合在一起的智能体。它的表现远远优于任何单一技巧。

4.3 Policy Gradient：REINFORCE

Value-based 方法（如 DQN）先学习 Q 函数，再以 greedy 方式选择行动。但这种方式有其局限。

1. 在连续动作空间（Continuous Action Space）中，很难求出 $\max_a Q(s, a)$。
2. 无法直接表示随机性策略（Stochastic Policy）。
3. Q 函数的微小变化可能导致策略发生剧烈变化。

Policy Gradient 方法直接对策略 $\pi_\theta$ 进行参数化，并直接优化策略的参数 $\theta$。

Policy Gradient Theorem 的推导：

先定义目标函数如下。

其中 $\tau = (s_0, a_0, r_0, s_1, a_1, r_1, \ldots)$ 是一条 trajectory，$R(\tau)$ 是该 trajectory 的总 return。

为了求 $J(\theta)$ 的梯度，先把 trajectory 的概率表示为：

求梯度：

在这里应用 Log-Derivative Trick $\nabla_\theta p_\theta(\tau) = p_\theta(\tau) \nabla_\theta \log p_\theta(\tau)$：

展开 $\log p_\theta(\tau)$：

由于环境动力学 $\rho_0$ 与 $P$ 不依赖于 $\theta$，求梯度时会消失。

因此 Policy Gradient Theorem 如下。

这个结果的核心含义是：即使不知道环境模型（转移概率 $P$），也能估计策略的梯度。

REINFORCE 算法（Williams，1992）：

REINFORCE 是 Policy Gradient Theorem 最直接的实现。它以 Monte Carlo 方式收集 trajectory，用观测到的 Return 来估计梯度。

利用 Baseline 降低方差：

REINFORCE 最大的问题是方差过高。从 Return $R(\tau)$ 中减去一个 baseline $b(s)$，并不会改变梯度的期望值（偏差），却能大幅降低方差。

最常用的 baseline 是状态价值函数 $b(s_t) = V(s_t)$，此时 $G_t - V(s_t)$ 就成为 Advantage Function 的估计值。

4.4 Actor-Critic：A2C、A3C

Actor-Critic 方法同时学习 Policy Gradient（Actor）与 Value Function（Critic）。

• Actor：学习策略 $\pi_\theta(a|s)$ —— 决定行动
• Critic：学习价值函数 $V_\phi(s)$ —— 评估行动

REINFORCE 存在必须等回合结束才能学习、Return 方差过大的问题。Actor-Critic 用 Critic 提供的价值估计作为 baseline，做到每个时刻都能更新，同时降低方差。

Actor 更新：

其中 Advantage 用 TD Error 来估计：$\hat{A}(s_t, a_t) = r_{t+1} + \gamma V_\phi(s_{t+1}) - V_\phi(s_t)$

Critic 更新：

A3C：Asynchronous Advantage Actor-Critic（Mnih 等，2016）

A3C 通过并行化大幅提升了学习的稳定性与速度。核心思路是：

1. 多个 Worker 各自在自己的环境副本中独立收集经验。
2. 每个 Worker 用自己的经验计算梯度，异步地更新全局参数。
3. 异步更新自然带来了探索的多样性，即使没有 Experience Replay，也能缓解数据相关性问题。

A2C：Advantage Actor-Critic

A2C 是 A3C 的同步（synchronous）版本。所有 Worker 同时收集经验后，把梯度汇总，一次性更新。由于不存在异步更新带来的 stale gradient 问题，实际上 A2C 往往表现出与 A3C 相当甚至更好的性能。

4.5 TRPO 与 PPO

Policy Gradient 的核心难题是学习率（step size）的设定很困难。太大会导致策略剧烈变化、性能崩溃；太小又会导致学习缓慢。TRPO 与 PPO 正是为解决这个问题而生的核心算法。

TRPO：Trust Region Policy Optimization（Schulman 等，2015）

TRPO 明确限制了策略更新的幅度。它使用 KL Divergence，把新旧策略之间的距离限制在一个 Trust Region（信赖域）内，只在这个区域内进行更新。

TRPO 理论上能保证性能单调提升，但为了求解带约束的最优化问题，需要用到 Conjugate Gradient 与 Line Search，实现非常复杂。

PPO：Proximal Policy Optimization（Schulman 等，2017）

PPO 在保持 TRPO 稳定性的同时，实现要简单得多。它是当今使用最广泛的 Policy Gradient 算法，也被用于 OpenAI 的 ChatGPT 训练。

PPO-Clip 目标函数的推导：

先定义策略比率。

TRPO 的 surrogate objective 是 $L^{CPI}(\theta) = \mathbb{E}_t[r_t(\theta) \hat{A}_t]$。如果不加约束地直接最大化这个目标函数，比率 $r_t(\theta)$ 可能会变得过大，导致策略剧烈变化。

PPO 的核心思路是，把比率裁剪（clip）到 $[1 - \varepsilon, 1 + \varepsilon]$ 范围内，从而限制策略变化的幅度。（$\varepsilon$ 通常取 0.1～0.2）

分情况分析这个目标函数是如何工作的：

情况一：$\hat{A}_t > 0$（好的行动）：

• 若 $r_t(\theta) > 1 + \varepsilon$（新策略远比原来更倾向于选择这个行动）：被裁剪限制为 $(1 + \varepsilon) \hat{A}_t$，从而消除继续朝该方向移动策略的激励。
• 若 $r_t(\theta) < 1 + \varepsilon$：不裁剪，直接使用 $r_t(\theta) \hat{A}_t$。

情况二：$\hat{A}_t < 0$（坏的行动）：

• 若 $r_t(\theta) < 1 - \varepsilon$（新策略远比原来更少选择这个行动）：被裁剪限制为 $(1 - \varepsilon) \hat{A}_t$。
• 若 $r_t(\theta) > 1 - \varepsilon$：不裁剪，直接使用 $r_t(\theta) \hat{A}_t$。

在这两种情况下，只要策略已经充分朝正确方向移动，就会切断进一步的激励。这正是 PPO 稳定性的关键所在。

PPO 的完整目标函数：

实际实现中会把 Policy Loss、Value Loss、Entropy Bonus 结合在一起。

• $L_t^{VF}$：Value Function 的 MSE Loss
• $S[\pi_\theta]$：策略的 Entropy（鼓励探索）
• $c_1, c_2$：权重系数

GAE（Generalized Advantage Estimation）：

PPO 通常使用 GAE（Schulman 等，2016）来估计 Advantage。GAE 可以看作是 TD($\lambda$) 的 Advantage 版本。

其中 $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$ 是 TD Error。$\lambda = 0$ 时对应 1-step TD 估计，$\lambda = 1$ 时对应 MC 估计。

4.6 SAC：Soft Actor-Critic

论文： "Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor"（Haarnoja 等，2018）

SAC 是一种基于 Maximum Entropy RL 框架的 off-policy actor-critic 算法。它是连续动作空间中最成功的算法之一，在机器人领域表现尤为出色。

Maximum Entropy 目标函数：

与标准 RL 只最大化 Return 不同，SAC 同时最大化 Return 与 Entropy。

其中 $\mathcal{H}(\pi(\cdot|s_t)) = -\mathbb{E}_{a \sim \pi}[\log \pi(a|s_t)]$ 是策略的 Entropy，$\alpha > 0$ 是调节 Entropy 重要程度的 Temperature（温度）参数。

Entropy 正则化带来的好处如下。

1. 促进探索： 让策略在最大化奖励的同时尽可能保持随机性，从而防止陷入局部最优。
2. 鲁棒的策略： 由于同时保留多个接近最优的行动，对环境变化更具鲁棒性。
3. 更快的学习： 在早期进行更广泛的探索，能更快发现有用的行动。

Soft Bellman Equation：

SAC 的三个网络：

1. Soft Q-Function $Q_\phi(s, a)$：使用两个 Q 网络以防止高估（Clipped Double Q）
2. Policy $\pi_\theta(a|s)$：Gaussian 策略（输出均值与方差）
3. Temperature $\alpha$：自动调节（entropy constraint 方式）

Q 函数更新：

这里 $\tilde{a}' \sim \pi_\theta(\cdot|s')$。

策略更新：

使用 Reparameterization Trick 使其可微：$a = f_\theta(\varepsilon; s) = \mu_\theta(s) + \sigma_\theta(s) \odot \varepsilon$，其中 $\varepsilon \sim \mathcal{N}(0, I)$。

Temperature 自动调节：

其中 $\bar{\mathcal{H}}$ 是目标 Entropy（通常取 $-\dim(\mathcal{A})$）。

4.7 DDPG 与 TD3：连续动作空间

DDPG：Deep Deterministic Policy Gradient（Lillicrap 等，2015）

DQN 只能应用于离散动作空间。DDPG 是把 DQN 的思路扩展到连续动作空间的 off-policy actor-critic 算法，可以看作是"用 DQN 做连续控制"。

• Deterministic Actor： $\mu_\theta(s)$ 直接输出连续动作
• Critic： $Q_\phi(s, a)$ 评估动作价值
• 沿用 DQN 的 Experience Replay 与 Target Network
• 为了探索，会在动作上加入 Ornstein-Uhlenbeck 噪声

Actor 更新（Deterministic Policy Gradient）：

TD3：Twin Delayed DDPG（Fujimoto 等，2018）

DDPG 存在 Q 值高估与训练不稳定的问题。TD3 用三种技巧解决了这些问题。

1. Twin Q-networks： 使用两个 Q 网络中较小的一个作为目标值 → 缓解高估

2. Delayed Policy Updates： Actor 更新的频率低于 Critic（例如 Critic 每更新 2 次，Actor 才更新 1 次）→ 基于更准确的 Q 值来更新策略

3. Target Policy Smoothing： 在目标动作上加入被裁剪的噪声 → 平滑目标 Q 值

5. Model-based RL

到目前为止讨论的算法都是 Model-free 方法——在不知道环境模型的情况下，直接通过经验学习。Model-based RL 则学习环境的动力学模型，并利用它来更高效地学习。

5.1 Model-based 的优势与挑战

优势：

• 样本效率（Sample Efficiency）： 能大幅减少与真实环境交互的次数，因为可以在学到的模型内部通过仿真（"imagination"）生成大量虚拟经验。
• Planning： 可以在真正行动之前"仿真"未来，探索最优的行动序列。
• Transfer： 学到的模型可以在多种任务之间复用。

挑战：

• 一旦模型不准确（Model Error），这种误差会在规划（planning）过程中累积，导致性能大幅下降。
• 准确学习复杂环境的动力学本身就很困难。

5.2 World Models（Ha & Schmidhuber，2018）

World Models 是一项开创性研究，它把环境建模在由 VAE（变分自编码器）压缩得到的潜在空间（Latent Space）中。

• Vision Model（V）： 用 VAE 把高维观测编码为低维潜在向量 $z$
• Memory Model（M）： 用 RNN（MDN-RNN）预测潜在空间中的动力学：$P(z_{t+1}|z_t, a_t, h_t)$
• Controller（C）： 一个简单的线性模型，输入 $z_t$ 与 $h_t$ 来决定行动

其核心创新在于，Controller 可以在"梦境"中进行学习。在 V 与 M 学到的世界模型内部生成虚拟回合，Controller 用这些虚拟经验来学习。

5.3 MuZero（Schrittwieser 等，2020）

MuZero 是 DeepMind 在 AlphaZero 基础上的延续，把它扩展为即使不知道环境规则也能学习的 model-based RL 算法。

AlphaZero 必须事先知道游戏规则（完美的模拟器）。MuZero 则学习以下三个函数。

1. Representation Function $h_\theta$：把观测 $o$ 映射为潜在状态 $s$：$s^0 = h_\theta(o_1, \ldots, o_t)$
2. Dynamics Function $g_\theta$：预测潜在状态下的转移：$r^k, s^k = g_\theta(s^{k-1}, a^k)$
3. Prediction Function $f_\theta$：从潜在状态预测策略与价值：$p^k, v^k = f_\theta(s^k)$

利用这三个函数，在潜在空间中执行 Monte Carlo Tree Search（MCTS）。即使不知道环境真实的转移规则，也能用学到的动力学函数来仿真未来。

MuZero 在围棋、国际象棋、将棋上达到了与 AlphaZero 相当的性能，同时在 Atari 游戏上也取得了 SOTA 性能。

5.4 Dreamer（Hafner 等，2020、2021、2023）

Dreamer 系列的做法是，在潜在空间中学习世界模型（World Model），并在这个模型内部通过想象（imagination）来学习策略。

Dreamer v3（Hafner 等，2023） 展示了通用性——用同一套算法和超参数，成功学习了 150 多种不同任务（Atari、DMC、Minecraft 等）。

核心构成要素：

• RSSM（Recurrent State Space Model）： 结合确定性状态与随机性状态的世界模型
• Actor-Critic in Imagination： 在学到的世界模型内部"想象"trajectory，并在这种想象中执行 actor-critic 学习
• Symlog Predictions： 一种正则化技巧，使学习不受奖励尺度的影响

5.5 自主算法发现：DiscoRL（2025）

2025 年发表于 Nature 的 DeepMind 研究，开启了 RL 的新范式。它证明了机器可以自主发现 SOTA RL 算法。这项被命名为 DiscoRL（Discovered RL）的发现规则，以神经网络的形式表示，比传统数学公式形式的算法更加灵活，在多种基准测试中超越了人工设计的算法。

6. RLHF：Reinforcement Learning from Human Feedback

RLHF 是强化学习最具影响力的最新应用。它是 ChatGPT、Claude、Gemini 等现代 LLM 的核心训练流水线，把人类的偏好用作奖励信号来对齐（Alignment）模型。

6.1 RLHF 流水线

RLHF 流水线由三个阶段构成。

阶段一：Supervised Fine-Tuning（SFT）

用人工撰写的高质量对话数据对预训练 LLM 进行微调。在这个阶段，模型获得遵循指令的基本能力。

阶段二：Reward Model（RM）训练

针对同一个提示词，SFT 模型生成多个回答，由人工标注者对其进行比较、排出偏好顺序。用这些偏好数据来训练奖励模型。

对于偏好对 $(y_w, y_l)$（其中 $y_w$ 比 $y_l$ 更受偏好），使用基于 Bradley-Terry 模型的损失函数。

其中 $r_\psi$ 是奖励模型，$\sigma$ 是 sigmoid 函数。

阶段三：RL Optimization（PPO 微调）

把训练好的奖励模型当作奖励函数，用 PPO 算法优化 LLM 策略。为了防止模型偏离 SFT 模型太远，会额外加入 KL Penalty。

其中 $\beta$ 是调节 KL 惩罚强度的系数。如果没有这个 KL 项，模型可能会"作弊"（hack）奖励模型，生成不自然的输出（Reward Hacking）。

6.2 DPO：Direct Preference Optimization

论文： "Direct Preference Optimization: Your Language Model is Secretly a Reward Model"（Rafailov 等，2023）

DPO 是一种大幅简化 RLHF 复杂度的创新方法。其核心洞见是：可以把"单独训练奖励模型"与"执行 RL"这两个阶段合并为一个阶段。

推导 KL 约束最优化问题的最优策略：

反过来对 $r$ 求解：

把这个关系代入 Bradley-Terry 模型（配分常数 $Z(x)$ 会被消去）：

DPO 的优点：

• 不需要单独训练奖励模型
• 不需要复杂的 PPO 训练循环
• 实现简单，训练稳定
• 大幅节省内存与计算成本

6.3 GRPO：Group Relative Policy Optimization

论文： 最早在 DeepSeek-R1 中使用的 GRPO，是 2025～2026 年最受关注的 RL 对齐技巧。

GRPO 去掉了 PPO 核心的低效环节——Value Network（Critic）。取而代之的是，针对同一个提示词以组为单位生成多个回答，用组内的相对奖励统计量来估计 Advantage。

其中 $G$ 是组的大小，$r_i$ 是第 $i$ 个回答的奖励。这种方式的优点是：

• 完全消除 Value Network 的内存与计算开销
• 组内相对比较使学习不受奖励尺度影响
• 在数学、编程等答案可验证（Verifiable Rewards）的任务上尤其有效

RLVR（Reinforcement Learning with Verifiable Rewards）：

DeepSeek-R1 成功之后，RLVR 范式迅速兴起。它不使用人类主观偏好，而是使用数学题是否答对、代码是否通过测试等可客观验证的奖励。这种方式的能力/成本比非常高，正在从数学、编程扩展到化学、生物学等其他领域。

6.4 LLM 对齐的最新动态（2025～2026）

2025～2026 年 LLM 对齐方向的主要进展如下。

• OpenAI GPT-5（2025 年 8 月）：通过 RLHF 精炼，大幅减少幻觉（hallucination），提升事实准确性
• Anthropic Claude Opus 4.5（2025 年 11 月）：结合 Constitutional AI 与 RLHF 进行训练，公开了长达 80 页的详细 Constitution（宪法）
• RLAIF（RL from AI Feedback）： 由 AI 而非人类来提供偏好反馈，可扩展性大幅提升
• Hybrid 方式： 根据任务有选择地组合 PPO + DPO + GRPO，正成为一种趋势

7. 主要应用案例

7.1 AlphaGo / AlphaZero / AlphaFold

AlphaGo（Silver 等，2016）：

以 4:1 战胜人类世界冠军李世石的 AlphaGo，向全世界展示了强化学习的潜力。围棋的状态空间约为 $10^{170}$，远超宇宙中原子的数量（$10^{80}$）。

AlphaGo 的训练流水线：

1. SL Policy Network： 用 16 万局人类棋谱做有监督学习（57% → 达到职业水准）
2. RL Policy Network： 通过自我对弈（Self-play）进行强化学习
3. Value Network： 预测对局结果，评估局面
4. Monte Carlo Tree Search（MCTS）： 结合 Policy Network 与 Value Network 进行搜索

AlphaGo Zero（Silver 等，2017）：

完全不使用人类棋谱，纯粹只靠 Self-play RL，仅用三天就以 100:0 击败了 AlphaGo。这个结果戏剧性地展示了 RL 的潜力。

AlphaZero（Silver 等，2018）：

AlphaGo Zero 的通用版本，用同一套算法在围棋、国际象棋、将棋（Shogi）上都超越了此前最强的程序。它的核心构成只有两个：深度神经网络 + MCTS。

AlphaFold（Jumper 等，2021）/ AlphaFold 3（Abramson 等，2024）：

虽然并非直接的 RL，但这套蛋白质三维结构预测系统从 RL 的搜索策略中汲取了灵感，解决了生物学 50 年的难题。AlphaFold 3 不仅能预测蛋白质，还能预测 DNA、RNA、配体等所有生物分子的相互作用结构。

7.2 机器人技术

强化学习正在机器人领域创造着颠覆性的成果。

Sim-to-Real Transfer： 把在仿真环境中通过 RL 学到的策略迁移到真实机器人上的技术。通过 Domain Randomization 随机改变仿真环境的物理参数，学到能在真实环境中也稳定工作的鲁棒策略。

主要成果：

• OpenAI 魔方（2019）： 成功用机械手解开魔方
• Quadruped Locomotion： 四足步行机器人在各种地形上稳定移动
• Dexterous Manipulation： 学会达到人类水平的物体操作技巧
• Google DeepMind Gemini Robotics（2025）： 推出基于 RL 的机器人操作模型，大幅提升了与物理世界交互的能力

7.3 游戏 AI

强化学习在游戏领域展现出了最具戏剧性的成果。

• Atari Games（DQN，2015）： 在 49 款游戏中达到人类水平
• StarCraft II（AlphaStar，2019）： 表现优于 99.8% 以上的人类玩家
• Dota 2（OpenAI Five，2019）： 以 2:0 击败世界冠军战队
• Gran Turismo（GT Sophy，2022）： 在赛车游戏中达到职业车手级别的表现
• Minecraft（Dreamer v3，2023）： 首次成功挖到钻石

7.4 推荐系统与其他应用

推荐系统： 学习能最大化用户长期满意度的序贯推荐。被 Netflix、YouTube、TikTok 等广泛使用，优化目标是长期用户参与度（engagement），而非短期点击率。

金融： RL 被用于投资组合优化、高频交易、最优订单执行等场景。

自动驾驶： Waymo、Tesla 等公司正在决策模块中探索基于 RL 的方法。

医疗健康： RL 正被研究用于慢性病的动态治疗方案（Dynamic Treatment Regimes）、加速药物发现、资源分配优化等领域。

网络/系统优化： 在数据中心冷却优化（Google）、网络路由、芯片设计（Google TPU 布局优化）等方面取得了实际成果。

8. PyTorch 代码示例

8.1 DQN 实现（CartPole）

在 CartPole 环境中实现 DQN 的完整代码。包含 Experience Replay、Target Network、$\varepsilon$-greedy 探索的全部内容。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import gymnasium as gym
from collections import deque
import random

# ============================================================
# Q-Network 定义
# ============================================================
class QNetwork(nn.Module):
    def __init__(self, state_dim, action_dim, hidden_dim=128):
        super(QNetwork, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, action_dim)
        )

    def forward(self, x):
        return self.network(x)

# ============================================================
# Replay Buffer
# ============================================================
class ReplayBuffer:
    def __init__(self, capacity=10000):
        self.buffer = deque(maxlen=capacity)

    def push(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))

    def sample(self, batch_size):
        batch = random.sample(self.buffer, batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        return (
            np.array(states),
            np.array(actions),
            np.array(rewards, dtype=np.float32),
            np.array(next_states),
            np.array(dones, dtype=np.float32)
        )

    def __len__(self):
        return len(self.buffer)

# ============================================================
# DQN Agent
# ============================================================
class DQNAgent:
    def __init__(self, state_dim, action_dim, lr=1e-3, gamma=0.99,
                 epsilon_start=1.0, epsilon_end=0.01, epsilon_decay=500,
                 target_update=10, buffer_size=10000, batch_size=64):
        self.action_dim = action_dim
        self.gamma = gamma
        self.epsilon_start = epsilon_start
        self.epsilon_end = epsilon_end
        self.epsilon_decay = epsilon_decay
        self.target_update = target_update
        self.batch_size = batch_size
        self.steps_done = 0

        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

        # 主网络与目标网络
        self.q_network = QNetwork(state_dim, action_dim).to(self.device)
        self.target_network = QNetwork(state_dim, action_dim).to(self.device)
        self.target_network.load_state_dict(self.q_network.state_dict())
        self.target_network.eval()

        self.optimizer = optim.Adam(self.q_network.parameters(), lr=lr)
        self.buffer = ReplayBuffer(buffer_size)

    def get_epsilon(self):
        """通过 Exponential decay 降低 epsilon"""
        eps = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \
              np.exp(-1.0 * self.steps_done / self.epsilon_decay)
        return eps

    def select_action(self, state):
        """ε-greedy 行动选择"""
        self.steps_done += 1
        epsilon = self.get_epsilon()

        if random.random() < epsilon:
            return random.randrange(self.action_dim)  # 探索
        else:
            state_t = torch.FloatTensor(state).unsqueeze(0).to(self.device)
            with torch.no_grad():
                q_values = self.q_network(state_t)
            return q_values.argmax(dim=1).item()      # 利用

    def update(self):
        """从 Experience Replay 中采样小批量以更新 Q-Network"""
        if len(self.buffer) < self.batch_size:
            return

        states, actions, rewards, next_states, dones = self.buffer.sample(self.batch_size)

        states_t = torch.FloatTensor(states).to(self.device)
        actions_t = torch.LongTensor(actions).to(self.device)
        rewards_t = torch.FloatTensor(rewards).to(self.device)
        next_states_t = torch.FloatTensor(next_states).to(self.device)
        dones_t = torch.FloatTensor(dones).to(self.device)

        # 当前 Q 值：Q(s, a; θ)
        current_q = self.q_network(states_t).gather(1, actions_t.unsqueeze(1)).squeeze(1)

        # 目标 Q 值：r + γ * max_a' Q(s', a'; θ⁻)
        with torch.no_grad():
            next_q = self.target_network(next_states_t).max(dim=1)[0]
            target_q = rewards_t + self.gamma * next_q * (1 - dones_t)

        # 计算损失并反向传播
        loss = nn.MSELoss()(current_q, target_q)
        self.optimizer.zero_grad()
        loss.backward()
        # 用 Gradient Clipping 提升稳定性
        nn.utils.clip_grad_norm_(self.q_network.parameters(), max_norm=1.0)
        self.optimizer.step()

        return loss.item()

    def update_target_network(self):
        """把目标网络同步为主网络的参数"""
        self.target_network.load_state_dict(self.q_network.state_dict())

# ============================================================
# 训练循环
# ============================================================
def train_dqn(num_episodes=500, render=False):
    env = gym.make("CartPole-v1")
    state_dim = env.observation_space.shape[0]
    action_dim = env.action_space.n

    agent = DQNAgent(state_dim, action_dim)
    episode_rewards = []

    for episode in range(num_episodes):
        state, _ = env.reset()
        total_reward = 0
        done = False

        while not done:
            action = agent.select_action(state)
            next_state, reward, terminated, truncated, _ = env.step(action)
            done = terminated or truncated

            agent.buffer.push(state, action, reward, next_state, done)
            agent.update()

            state = next_state
            total_reward += reward

        # 定期更新目标网络
        if episode % agent.target_update == 0:
            agent.update_target_network()

        episode_rewards.append(total_reward)

        if (episode + 1) % 50 == 0:
            avg_reward = np.mean(episode_rewards[-50:])
            print(f"Episode {episode+1}, Avg Reward (last 50): {avg_reward:.1f}, "
                  f"Epsilon: {agent.get_epsilon():.3f}")

    env.close()
    return agent, episode_rewards

if __name__ == "__main__":
    agent, rewards = train_dqn()

8.2 PPO 实现（CartPole）

PPO-Clip 算法的完整实现。包含 Actor-Critic 网络、GAE、Clipped Surrogate Objective。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Categorical
import numpy as np
import gymnasium as gym

# ============================================================
# Actor-Critic 网络
# ============================================================
class ActorCritic(nn.Module):
    def __init__(self, state_dim, action_dim, hidden_dim=64):
        super(ActorCritic, self).__init__()

        # Actor（策略网络）
        self.actor = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, action_dim),
            nn.Softmax(dim=-1)
        )

        # Critic（价值网络）
        self.critic = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, 1)
        )

    def forward(self, state):
        action_probs = self.actor(state)
        state_value = self.critic(state)
        return action_probs, state_value

    def act(self, state):
        """行动选择（采样）"""
        action_probs, state_value = self.forward(state)
        dist = Categorical(action_probs)
        action = dist.sample()
        return action.item(), dist.log_prob(action), state_value

    def evaluate(self, states, actions):
        """评估存储的经验批次"""
        action_probs, state_values = self.forward(states)
        dist = Categorical(action_probs)
        log_probs = dist.log_prob(actions)
        entropy = dist.entropy()
        return log_probs, state_values.squeeze(-1), entropy

# ============================================================
# PPO Agent
# ============================================================
class PPOAgent:
    def __init__(self, state_dim, action_dim, lr=3e-4, gamma=0.99,
                 lam=0.95, clip_epsilon=0.2, epochs=10, batch_size=64,
                 entropy_coef=0.01, value_coef=0.5):
        self.gamma = gamma
        self.lam = lam
        self.clip_epsilon = clip_epsilon
        self.epochs = epochs
        self.batch_size = batch_size
        self.entropy_coef = entropy_coef
        self.value_coef = value_coef

        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.policy = ActorCritic(state_dim, action_dim).to(self.device)
        self.optimizer = optim.Adam(self.policy.parameters(), lr=lr)

        # 经验存储
        self.states = []
        self.actions = []
        self.log_probs = []
        self.rewards = []
        self.dones = []
        self.values = []

    def select_action(self, state):
        state_t = torch.FloatTensor(state).to(self.device)
        with torch.no_grad():
            action, log_prob, value = self.policy.act(state_t)
        return action, log_prob.item(), value.item()

    def store_transition(self, state, action, log_prob, reward, done, value):
        self.states.append(state)
        self.actions.append(action)
        self.log_probs.append(log_prob)
        self.rewards.append(reward)
        self.dones.append(done)
        self.values.append(value)

    def compute_gae(self, next_value):
        """计算 Generalized Advantage Estimation（GAE）"""
        advantages = []
        gae = 0
        values = self.values + [next_value]

        for t in reversed(range(len(self.rewards))):
            delta = self.rewards[t] + self.gamma * values[t + 1] * (1 - self.dones[t]) - values[t]
            gae = delta + self.gamma * self.lam * (1 - self.dones[t]) * gae
            advantages.insert(0, gae)

        advantages = torch.FloatTensor(advantages).to(self.device)
        returns = advantages + torch.FloatTensor(self.values).to(self.device)
        return advantages, returns

    def update(self, next_value):
        """执行 PPO-Clip 更新"""
        advantages, returns = self.compute_gae(next_value)

        # 转换为张量
        states_t = torch.FloatTensor(np.array(self.states)).to(self.device)
        actions_t = torch.LongTensor(self.actions).to(self.device)
        old_log_probs_t = torch.FloatTensor(self.log_probs).to(self.device)

        # Advantage 归一化（降低方差）
        advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)

        # PPO 多轮迭代
        for _ in range(self.epochs):
            # 用全部数据做小批量学习
            indices = np.arange(len(self.states))
            np.random.shuffle(indices)

            for start in range(0, len(self.states), self.batch_size):
                end = start + self.batch_size
                batch_idx = indices[start:end]

                # 用当前策略重新评估
                new_log_probs, values, entropy = self.policy.evaluate(
                    states_t[batch_idx], actions_t[batch_idx]
                )

                # 策略比率：r_t(θ) = π_θ(a|s) / π_θ_old(a|s)
                ratio = torch.exp(new_log_probs - old_log_probs_t[batch_idx])

                # PPO-Clip 目标函数
                surr1 = ratio * advantages[batch_idx]
                surr2 = torch.clamp(ratio, 1 - self.clip_epsilon,
                                    1 + self.clip_epsilon) * advantages[batch_idx]
                policy_loss = -torch.min(surr1, surr2).mean()

                # Value Loss（MSE）
                value_loss = nn.MSELoss()(values, returns[batch_idx])

                # Entropy Bonus（鼓励探索）
                entropy_loss = -entropy.mean()

                # 总损失
                loss = (policy_loss
                        + self.value_coef * value_loss
                        + self.entropy_coef * entropy_loss)

                self.optimizer.zero_grad()
                loss.backward()
                nn.utils.clip_grad_norm_(self.policy.parameters(), max_norm=0.5)
                self.optimizer.step()

        # 清空经验缓冲区
        self.states.clear()
        self.actions.clear()
        self.log_probs.clear()
        self.rewards.clear()
        self.dones.clear()
        self.values.clear()

# ============================================================
# 训练循环
# ============================================================
def train_ppo(num_episodes=500, update_interval=2048):
    env = gym.make("CartPole-v1")
    state_dim = env.observation_space.shape[0]
    action_dim = env.action_space.n

    agent = PPOAgent(state_dim, action_dim)
    episode_rewards = []
    total_steps = 0

    state, _ = env.reset()
    current_episode_reward = 0

    for step in range(1, 200001):
        action, log_prob, value = agent.select_action(state)
        next_state, reward, terminated, truncated, _ = env.step(action)
        done = terminated or truncated

        agent.store_transition(state, action, log_prob, reward, done, value)
        current_episode_reward += reward
        total_steps += 1

        if done:
            episode_rewards.append(current_episode_reward)
            current_episode_reward = 0
            state, _ = env.reset()

            if len(episode_rewards) % 50 == 0:
                avg = np.mean(episode_rewards[-50:])
                print(f"Episode {len(episode_rewards)}, "
                      f"Avg Reward (last 50): {avg:.1f}, "
                      f"Total Steps: {total_steps}")
        else:
            state = next_state

        # 每隔一定步数执行一次 PPO 更新
        if step % update_interval == 0:
            with torch.no_grad():
                state_t = torch.FloatTensor(state).to(agent.device)
                _, next_value = agent.policy(state_t)
                next_value = next_value.item()
            agent.update(next_value)

    env.close()
    return agent, episode_rewards

if __name__ == "__main__":
    agent, rewards = train_ppo()