大模型训练——强化学习篇

前言：强化学习（Reinforcement Learning，RL）是机器学习三大范式之一，与监督学习、无监督学习并列。与监督学习不同，强化学习不依赖标注数据，而是通过"试错"与环境交互，学习在给定状态下采取最优动作。本篇文章系统讲解强化学习核心概念、主要算法（从基础到深度），以及在大模型训练中的应用（RLHF）。

1. 强化学习基本概念

1.1 智能体-环境交互框架

强化学习的核心框架是智能体（Agent）与环境（Environment）的交互：

         状态 Sₜ
           │
           ▼
    ┌─────────────┐
    │   智能体    │──动作 Aₜ──▶
    │   Agent     │◀──奖励 Rₜ+1──
    └─────────────┘
           │
           ▼
         环境（Environment）

交互过程：

1. 智能体观察到当前状态 Sₜ（State）
2. 根据策略 π（Policy）选择一个动作 Aₜ（Action）
3. 环境接收动作，返回奖励 Rₜ₊₁（Reward）和下一状态 Sₜ₊₁
4. 智能体用这个经验更新策略
5. 重复以上步骤，直到训练结束

目标：智能体学会选择一个最大化长期累积奖励的动作序列。

1.2 核心要素

要素	符号	说明
状态空间	S	所有可能状态的集合
动作空间	A	智能体可以采取的所有动作
策略	π(a|s)	在状态 s 下选择动作 a 的概率分布
奖励函数	R(s,a)	采取动作后获得的奖励
状态转移	P(s’|s,a)	在状态 s 采取动作 a 后转移到 s’ 的概率
折扣因子	γ	未来奖励的重要性折扣（0≤γ≤1）

1.3 强化学习与其他学习的区别

【监督学习】
输入 X ──▶ 标签 Y ──▶ 学习映射 f(X)=Y
            ▲
         需要标注数据

【无监督学习】
输入 X ──▶ 无标签 ──▶ 发现数据内在结构（聚类、降维）
            ▲
         不需要标签

【强化学习】
智能体 ──▶ 动作 A ──▶ 环境反馈奖励 R ──▶ 学习最优策略
            ▲
         不需要标注，通过"试错"学习

1.4 回合制与序贯决策

• 回合制任务（Episodic）：有明确起点和终点，如游戏、机器人走迷宫
• 序贯决策任务（Continuing）：没有终止状态，持续与环境交互，如自动驾驶、推荐系统

---

2. 马尔可夫决策过程（MDP）

2.1 什么是马尔可夫性

马尔可夫性：未来只与当前状态有关，与过去无关。即：

P(Sₜ₊₁ | Sₜ, Sₜ₋₁, ..., S₀) = P(Sₜ₊₁ | Sₜ)

这意味着：只要知道当前状态，就可以做决策，不需要记住完整历史。

马尔可夫链：满足马尔可夫性的随机过程序列。

2.2 MDP 五元组

MDP（Markov Decision Process）由五元组 (S, A, P, R, γ) 定义：

S：状态空间
A：动作空间
P(s'|s,a)：状态转移概率函数
R(s,a)：奖励函数
γ：折扣因子

例子：机器人走迷宫

状态空间 S：每个格子位置（共 N×N 个状态）
动作空间 A：上、下、左、右（4个动作）
转移 P：机器人移动到相邻格子（假设确定性的，概率=1）
奖励 R：
  - 到达目标格子：+10
  - 每走一步：-0.1（鼓励走最短路径）
  - 撞墙：-1
折扣因子 γ=0.9

2.3 价值函数

为了衡量"某个状态或状态-动作对有多好"，引入价值函数：

状态价值函数 V(s)：从状态 s 出发，按照策略 π 行动的期望累积奖励：

Vπ(s) = Eπ[ Gₜ | Sₜ = s ]

动作价值函数 Q(s,a)：从状态 s 出发，采取动作 a 之后按照策略 π 行动的期望累积奖励：

Qπ(s,a) = Eπ[ Gₜ | Sₜ = s, Aₜ = a ]

两者的关系：

Vπ(s) = Σₐ π(a|s) · Qπ(s,a)

某状态的价值 = 所有动作价值的加权和（按策略概率）

累积奖励 Gₜ：

Gₜ = Rₜ₊₁ + γ·Rₜ₊₂ + γ²·Rₜ₊₃ + ...
    = Σₖ₌₀^∞ γᵏ · Rₜ₊ₖ₊₁

2.4 贝尔曼方程

贝尔曼方程是强化学习最核心的公式，它将价值函数递归分解：

状态价值函数的贝尔曼方程：

Vπ(s) = Σₐ π(a|s) · Σₛ' P(s'|s,a) · [ R(s,a) + γ·Vπ(s') ]

贝尔曼最优方程（当策略是最优策略 π* 时）：

V*(s) = maxₐ Σₛ' P(s'|s,a) · [ R(s,a) + γ·V*(s') ]
Q*(s,a) = Σₛ' P(s'|s,a) · [ R(s,a) + γ·maxₐ' Q*(s',a') ]

直观理解：

V(s) = 做最优选择得到的（当前奖励 + 未来奖励的折扣）
     = maxₐ [ R(s,a) + γ · V(s') ]

2.5 最优策略

强化学习的最终目标是找到最优策略 π*，使任意状态的价值都是最大的：

π* = argmaxπ Vπ(s), ∀s

核心性质：

• 最优策略不一定唯一
• 最优策略下，Vπ*(s) = V*(s)
• 贪婪策略（每次选 max Q 的动作）不一定是最优的（需要 Exploration）

---

3. 基于模型的强化学习（Model-Based RL）

3.1 概述

基于模型的强化学习：智能体先学习一个环境模型（状态转移 + 奖励函数），再利用这个模型进行规划或模拟。

【基于模型的方法】
数据 ──▶ 学习环境模型 P(s'|s,a), R(s,a) ──▶ 用模型规划最优策略

【无模型的方法】
数据 ──▶ 直接从经验中学习 Q(s,a) 或 π(a|s)（不建模型）

模型的价值：模型可以让智能体在模拟环境中" dreaming"，低成本获取大量经验。

3.2 学习环境模型

状态转移模型：从数据中学习 P(s’|s,a)

学习方式：监督学习
训练数据：(s, a, s') 元组
目标：训练一个神经网络预测 s'
输出：s' 的分布或期望值

奖励模型：学习 R(s,a)

训练方式：同上
目标：预测采取动作后的即时奖励

3.3 模型规划：Monte Carlo Tree Search（MCTS）

蒙特卡洛树搜索是基于模型规划的经典算法，被用于 AlphaGo。

MCTS 四个步骤（反复迭代）：

1. Selection（选择）
   从根节点开始，用 UCB 公式选择最优子节点
   UCB = Q(s,a) + C · √(ln(N(s)) / N(s,a))
   → 平衡"探索"和"利用"

2. Expansion（扩展）
   如果没到终止状态，创建新的子节点

3. Simulation（模拟）
   从新节点出发，随机 rollout 到终止状态
   得到一个"模拟"的奖励

4. Backpropagation（回传）
   将模拟结果回传，更新路径上所有节点的统计量

直观理解：

模拟下棋：
- 每次走一步 → 扩展一个子节点
- 快速模拟到终局 → 得到胜负奖励
- 多次模拟后，哪个分支胜率最高就选哪个

3.4 Dreamer：基于模型的深度RL

Dreamer 是 BEHAVIOR 提出的基于模型的深度强化学习算法：

核心思想：训练一个世界模型（World Model），在模型的"想象"中进行规划学习。

Dreamer 三步走：

1. 收集经验数据（与环境交互）
   π(a|s) → 采取动作 → 得到 r, s'

2. 学习世界模型（自编码器 + 动力学模型）
   s' = f(s, a)  ← 预测下一步状态
   r = g(s)      ← 预测奖励

3. 在想象轨迹中反向传播学习策略
   在"梦"里做很多 rollout
   用 actor-critic 方法学习最优 π

优点：样本效率极高，不需要真实交互也能学习。

---

4. 无模型强化学习（Model-Free RL）

当环境模型未知时，只能通过与真实环境交互来学习策略。主要分为两大类：基于价值（Value-Based） 和 基于策略（Policy-Based）。

4.1 基于价值的强化学习：Q-Learning

Q-Learning 是最经典的基于价值的无模型算法，直接学习动作价值函数 Q(s,a)，并通过贪婪策略选择动作。

Q(s,a) 的更新公式：

Q(s,a) ← Q(s,a) + α · [ r + γ·maxₐ' Q(s',a') - Q(s,a) ]
                                   ↑
                        真实奖励 + 未来价值（TD目标）

术语解释：

• α：学习率（控制更新步长）
• γ：折扣因子
• TD误差：r + γ·max Q(s’,a’) - Q(s,a)，即"预测与真实价值的差距"

算法流程：

初始化 Q(s,a) = 0（表格或网络）

重复（每个 episode）：
  初始化状态 s
  重复（每个时间步）：
    ε-贪婪选择动作 a
    执行动作 a，获得奖励 r，到达状态 s'
    更新 Q(s,a) ← Q(s,a) + α·[r + γ·maxₐ' Q(s',a') - Q(s,a)]
    s ← s'
  直到 s 是终止状态

ε-贪婪策略：

以 ε 的概率：随机选择动作（探索）
以 1-ε 的概率：选择 argmax Q(s,a)（利用）

ε 随着学习逐渐减小（前期多探索，后期多利用）

4.2 DQN（Deep Q-Network）

当状态空间和动作空间很大时（如 Atari 游戏），Q 表无法存储，用神经网络来近似 Q(s,a)，即为 DQN。

DQN 的两个关键技巧：

技巧1：经验回放（Experience Replay）

将经验 (s, a, r, s') 存入 replay buffer
每次更新时随机采样一个 batch
打破数据的时间相关性，使更新更稳定

技巧2：目标网络（Target Network）

DQN 的更新目标使用单独的 target network：
y = r + γ·maxₐ' Q_target(s', a'; θ⁻)

每隔 C 步，把在线网络 θ 复制给目标网络 θ⁻
→ 使 TD 目标更稳定，避免振荡

DQN 算法图解：

输入：当前状态 s（游戏画面）
   │
   ▼
卷积网络（提取图像特征）
   │
   ▼
全连接层 → 输出每个动作的 Q(s,a)
   │
   ▼
ε-贪婪选择动作 a
   │
   ▼
与环境交互，获得 (s, a, r, s')
   │
   ▼
存入 Replay Buffer
   │
   ▼
随机采样 batch
   │
   ▼
计算 Loss = [r + γ·max Q_target(s',a') - Q(s,a)]²
   │
   ▼
梯度反向传播更新网络

4.3 策略梯度（Policy Gradient）

核心思想：不学习 Q 值，而是直接学习策略 π(a|s)，通过梯度上升直接最大化期望累积奖励。

策略梯度定理：

∇θ J(θ) = Eπθ[ ∇θ log πθ(a|s) · Qπ(s,a) ]

直观理解：

- 如果某个动作 Q 值高 → 增加选择它的概率（梯度上升）
- 如果某个动作 Q 值低 → 减少选择它的概率
- 用采样来估计期望值

REINFORCE 算法：

1. 用当前策略 πθ 收集一个完整 episode：
   τ = (s₀, a₀, r₁, s₁, a₁, r₂, ..., s_T)

2. 计算每个时间步的回报：
   Gₜ = rₜ + γ·rₜ₊₁ + γ²·rₜ₊₂ + ...

3. 策略梯度更新：
   θ ← θ + α · Σₜ ∇θ log πθ(aₜ|sₜ) · Gₜ

策略梯度的优势：

• 可以处理连续动作空间（输出动作分布的参数，而非离散 Q 值）
• 收敛更平滑（不像 Q-Learning 可能有振荡）

缺点：方差较高，收敛慢（可用 baseline 来改进）。

4.4 Actor-Critic（演员-评论家）

Actor-Critic 结合了策略梯度（Actor）和价值函数（Critic），用 Critic 估计的价值来降低策略梯度的方差。

两个网络：

Actor（策略网络）：输入状态 s，输出动作分布 π(a|s)
Critic（价值网络）：输入状态 s，输出 V(s)（状态价值）

优势：

• 用 V(s) 作为 baseline，降低策略梯度的方差
• Critic 可以用 TD 学习，比蒙特卡洛回报更稳定

更新过程：

Critic 更新：TD error = r + γ·V(s') - V(s)
            更新价值网络使 TD error 变小

Actor 更新：∇θ J ≈ Σₜ ∇θ log πθ(aₜ|sₜ) · A(sₜ,aₜ)
其中 Advantage A(sₜ,aₜ) = rₜ + γ·V(sₜ₊₁) - V(sₜ)
                     = TD error（单步）

直观理解：

Actor = 演员（根据 Critic 的评价来学习怎么演戏）
Critic = 影评人（给电影打分，让演员知道演得好不好）

---

5. 深度强化学习算法

5.1 DDPG（深度确定性策略梯度）

用于连续动作空间。同时学习确定性策略 μ(s) 和 Q 网络。

确定性策略：a = μ(s)，直接输出动作而非概率分布

双网络结构：

Actor 网络 μ(s|θμ)：输出连续动作
Target Actor 网络 μ'(s|θμ')
Critic 网络 Q(s,a|θQ)：输出 Q 值
Target Critic 网络 Q'(s,a|θQ')

更新公式：

Critic：最小化 TD 误差
  y = r + γ·Q'(s', μ'(s'))
  Loss = MSE(Q(s,a), y)

Actor：最大化 Q 值
  ∇θμ J ≈ ∇θμ Q(s, μ(s)) · ∇μ(s)μ(s)
  即：调整策略使 Critic 给出更高的 Q 值

5.2 PPO（近端策略优化）

PPO（Proximal Policy Optimization） 是目前最流行的深度强化学习算法之一，核心思想是在提高样本效率的同时保证策略更新的稳定性。

为什么需要 PPO？

策略梯度的一个核心问题：两次更新之间策略变化太大，导致策略崩溃（如从很好突然变得很差）。

PPO 用裁剪（Clipping） 限制策略更新的幅度。

PPO 损失函数：

L^CLIP(θ) = E[ min( rt(θ) · A, clip(rt(θ), 1-ε, 1+ε) · A ) ]

其中：
  rt(θ) = πθ(a|s) / πθ_old(a|s)  ← 概率比（策略变化程度）
  A = Advantage（优势函数）
  clip(rt, 1-ε, 1+ε) ← 将概率比裁剪到 [1-ε, 1+ε]
  ε 通常取 0.1 或 0.2

PPO 核心逻辑图解：

【概率比 rt(θ) = π新(a|s) / π旧(a|s)】

情况1：动作 a 是好动作（A > 0）
  rt > 1：策略更倾向于选这个动作 → 鼓励
  rt < 1：策略更不倾向于选这个动作 → 惩罚
  但 PPO 裁剪后，rt 超过 1+ε 就不再增加了

情况2：动作 a 是坏动作（A < 0）
  裁剪防止 rt 降到 1-ε 以下，大幅降低惩罚幅度

→ 结果：策略更新幅度被限制，不会崩溃

PPO 算法流程：

1. 用旧策略 πθ_old 收集数据（rollout）
2. 计算 Advantage 估计 A（GAE）
3. 用 PPO 损失函数更新策略（多轮 epoch）
   θ_new = argmaxθ L^CLIP(θ)
4. 令 θ_old ← θ_new
5. 重复

5.3 SAC（软策略迭代）

SAC（Soft Actor-Critic） 是一种最大熵强化学习算法，在最大化累积奖励的同时鼓励策略的随机性（最大熵）。

最大熵目标：

J(π) = Σₜ E_{(s,a)~π} [ r(sₜ,aₜ) + α · H(π(·|sₜ)) ]
                                          ↑
                                    熵项（鼓励随机性）

最大熵的作用：

• 鼓励探索，避免陷入局部最优
• 在不确定的环境中，更多随机性通常更好
• 策略更鲁棒，测试时表现更稳定

三个网络：

Actor（策略网络）：输出动作分布（均值 + 标准差）
Critic × 2（价值网络 × 2）：输出 Q 值（用两个网络减少过估计）
熵系数 α：自动调整（自动平衡探索与利用）

---

6. 强化学习在大模型训练中的应用

6.1 为什么大模型需要强化学习

预训练语言模型学到了丰富的语言知识，但面临两个核心问题：

1. 如何与人类意图对齐（Alignment）？
   预训练目标（预测下一个词）≠ 人类期望（有帮助、诚实、无害）

2. 如何实现复杂推理？
   监督学习只能教模型"模仿答案"，无法教"推理过程"

强化学习提供了一种通过奖励信号引导模型学习目标行为的方式。

6.2 RLHF（基于人类反馈的强化学习）

RLHF（Reinforcement Learning from Human Feedback） 是 ChatGPT、InstructGPT 等模型训练的核心技术。

RLHF 三步走：

第一步：监督微调 SFT
  用人类标注的"问答对"微调预训练模型
  模型学会：给定指令 → 生成符合格式的优质回答

第二步：训练奖励模型 RM
  收集人类对同一问题不同回答的偏好数据
  训练一个 Reward Model：预测"人类更喜欢哪个回答"
  输出：标量奖励分数

第三步：PPO 强化学习微调
  用 PPO 算法，以 RM 的奖励信号优化 SFT 模型
  模型学会：生成人类更偏好、更有帮助的回答

RLHF 流程图解：

【Step 1: SFT 监督微调】
人类标注数据
   │
   ▼
预训练模型 ──▶ 微调 ──▶ SFT 模型（具备基础对话能力）

【Step 2: 训练 Reward Model】
问题 ──▶ SFT 模型生成多个回答 A, B, C
          │
          ▼
      人类打分（哪个最好）
          │
          ▼
      训练 RM（奖励模型）
      输入：回答文本 → 输出：奖励分数

【Step 3: PPO 强化学习】
问题 ──▶ RL 策略模型（从 SFT 初始化）
          │
          ▼
      生成回答 ──▶ RM 打分
          │                  │
          │                  ▼
          │              更新策略（PPO）
          │                  ▲
          └──────────────────┘
         反复迭代，奖励越来越高

6.3 Reward Model（奖励模型）

Reward Model 的作用：用神经网络模拟人类偏好，给生成的回答打分。

训练数据格式：

Prompt: "解释量子力学"
Response A: "量子力学是描述微观粒子行为的物理学分支..."
Response B: "量子力学是一个很难的物理概念..."

人类偏好: A > B

训练目标：RM(A) > RM(B)

训练目标：

L = - log σ( r_A - r_B )
其中：
  r_A = RM(prompt, Response A)
  r_B = RM(prompt, Response B)
  σ = sigmoid 函数

目标：让 RM 给更好的回答更高的分数

6.4 PPO 在 LLM 中的应用

InstructGPT/ChatGPT 的 PPO 训练：

PPO 强化学习阶段的目标函数：

L = E[ r(x,y) ] - β · D_KL( π_RL(y|x) || π_SFT(y|x) )
          │                         │
          │                         └─ KL 惩罚项
          │                            限制 RL 策略不要偏离 SFT 太远
          └── 奖励信号（来自 RM）

为什么需要 KL 惩罚？

• 没有 KL 约束，PPO 可能找到一个 RM 容易"欺骗"的高分回答，但质量很低
• KL 惩罚保证 RL 策略不会完全偏离有监督微调的基础能力

6.5 GRPO（Group Relative Policy Optimization）

GRPO 是 DeepSeek 在 2025 年提出的新型强化学习算法，用于替代 PPO。

PPO 的问题：需要训练 Critic（价值网络），计算和内存开销大。

GRPO 的核心思想：用同题群组相对排序替代 Critic。

GRPO 核心逻辑：

给定问题 x，RL 策略生成 G 个回答 {y₁, y₂, ..., y_G}
  ↓
RM 给每个回答打分：{r₁, r₂, ..., r_G}
  ↓
计算相对优势：
  A_i = r_i - mean({r₁, ..., r_G})
  → 跟群组平均水平比，高于均值=正优势，低于=负优势
  ↓
用 PPO-style 的裁剪损失更新策略
  → 不需要 Critic 网络，更高效

GRPO 优势：

• 节省约 50% 的显存（不用存 Critic 网络）
• 在 DeepSeek-Math 等数学推理任务上超过 PPO
• 训练更稳定，超参数更少

6.6 DPO（Direct Preference Optimization）

DPO 是一种更简单的对齐方法，直接在偏好数据上微调策略，绕过显式的 Reward Model 和 PPO。

DPO 的核心：将偏好学习转化为简单的分类问题。

训练目标：

L = - log σ( log π(y₁|x) / π(y₂|x) 的差美化 )
   = - log σ( β · (log πθ(y₁|x) - log πθ(y₂|x)) - log πref(y₁|x) + log πref(y₂|x) )

其中：
  y₁ = 人类偏好的回答
  y₂ = 人类不喜欢的回答
  πθ = 当前要优化的策略
  πref = 参考模型（SFT 模型，不更新参数）
  β = KL 权重系数

DPO vs PPO：

方面	PPO	DPO
需要 RM	✅ 是	❌ 否（隐式）
需要 PPO 训练	✅ 是	❌ 否（简单微调）
稳定性	中等	更好
显存需求	高（需要 Critic）	低（不需要 Critic）
训练速度	较慢	快

---

7. 实战案例：CartPole 任务

7.1 任务描述

CartPole 是 OpenAI Gym 最经典的入门任务：

目标：让杆子保持平衡
状态：4 维向量 [x, ẋ, θ, θ̇]（位置、速度、角度、角速度）
动作：0 = 左推，1 = 右推
奖励：每一步 +1（活着就得分）
终止：|x| > 2.4 或 |θ| > 15°

7.2 DQN 解决 CartPole

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

# 经验回放缓冲区
class ReplayBuffer:
    def __init__(self, capacity=10000):
        self.buffer = deque(maxlen=capacity)
    
    def push(self, s, a, r, s', done):
        self.buffer.append((s, a, r, s', done))
    
    def sample(self, batch_size):
        return random.sample(self.buffer, batch_size)

# Q 网络
class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim)
        )
    
    def forward(self, x):
        return self.net(x)

# 参数
gamma = 0.99        # 折扣因子
epsilon = 1.0       # 探索率
epsilon_min = 0.01
epsilon_decay = 0.995
alpha = 1e-3        # 学习率
batch_size = 64
target_update = 10  # 目标网络更新频率

# 初始化
env = gym.make('CartPole-v1')
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n

q_net = DQN(state_dim, action_dim)
target_net = DQN(state_dim, action_dim)
target_net.load_state_dict(q_net.state_dict())  # 同步参数

optimizer = torch.optim.Adam(q_net.parameters(), lr=alpha)
replay = ReplayBuffer()

# 训练
for episode in range(500):
    s, _ = env.reset()
    total_reward = 0
    
    while True:
        # ε-贪婪选择动作
        if random.random() < epsilon:
            a = env.action_space.sample()
        else:
            with torch.no_grad():
                a = q_net(torch.FloatTensor(s)).argmax().item()
        
        s', r, done, _, _ = env.step(a)
        replay.push(s, a, r, s', done)
        s = s'
        total_reward += r
        
        # 经验回放更新
        if len(replay.buffer) >= batch_size:
            batch = replay.sample(batch_size)
            states, actions, rewards, next_states, dones = zip(*batch)
            
            states = torch.FloatTensor(np.array(states))
            actions = torch.LongTensor(actions)
            rewards = torch.FloatTensor(rewards)
            next_states = torch.FloatTensor(np.array(next_states))
            dones = torch.FloatTensor(dones)
            
            # Q 值
            q_values = q_net(states).gather(1, actions.unsqueeze(1)).squeeze()
            
            # TD 目标
            with torch.no_grad():
                max_q = target_net(next_states).max(1).values
                td_target = rewards + gamma * max_q * (1 - dones)
            
            # 优化
            loss = nn.MSELoss()(q_values, td_target)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        if done:
            break
    
    # 更新目标网络
    if episode % target_update == 0:
        target_net.load_state_dict(q_net.state_dict())
    
    # 衰减探索率
    epsilon = max(epsilon_min, epsilon * epsilon_decay)
    
    if episode % 20 == 0:
        print(f"Episode {episode:3d} | Reward: {total_reward:3.0f} | ε: {epsilon:.3f}")

训练结果：正常情况下，DQN 能在 200-300 个 episode 内达到 500 分（杆子平衡 500 步）。

---

8. 常见问题与解决方案

8.1 探索-利用困境（Exploration vs Exploitation）

问题：智能体只选择已知最优动作，错过更优解。

解决方案：

ε-贪婪：前期高 ε 探索，后期低 ε 利用
          ε
    1.0 ┤■■■■■■■■■■■■■■■■
        └──────────────────▶ 时间
       1.0                0.01

噪声探索：在动作或参数上加噪声（NoisyNet）
随机策略：直接用概率分布而非确定性输出
         π(a|s) = softmax(Q(s,a) / τ)
         τ = 温度参数（越大越随机）

8.2 价值过估计（Overestimation）

问题：Q-Learning 中的 max 操作会系统性地高估 Q 值。

解决方案：Double DQN

普通 DQN：
  y = r + γ·maxₐ' Q_target(s', a')

Double DQN（用在线网络选动作，目标网络评价）：
  y = r + γ·Q_target(s', argmaxₐ' Q_online(s', a'))

8.3 训练不稳定

问题：策略梯度方差大，训练过程振荡或发散。

解决方案：

1. 梯度裁剪（Gradient Clipping）：
   grad_norm = torch.nn.utils.clip_grad_norm_(parameters, max_norm=1.0)

2. 目标网络（Target Network）：
   定期同步，TD 目标更稳定

3. 熵正则化（Entropy Bonus）：
   L = L_policy + β · H(π)
   → 鼓励策略保持一定随机性

4. 学习率调度：
   配合 warmup + 余弦衰减

8.4 样本效率低

问题：与环境交互需要大量样本，成本高。

解决方案：

1. 经验回放（Experience Replay）：重复利用历史经验
2. 优先经验回放（PER）：优先重用高 TD 误差的经验
3. 模型预测（Model-Based RL）：在"想象"中学习
4. 离线强化学习（Offline RL）：从静态数据集中学习，不需实时交互

---

9. 总结

9.1 算法选择指南

【任务类型 × 算法选择】

连续动作 + 连续状态：
  → DDPG（简单连续任务）
  → SAC（最大熵，更稳定）
  → PPO（最常用，效果好）

离散动作 + 高维状态（图像）：
  → DQN + 经验回放（Atari 游戏）
  → RainBow/DQN 变体（综合优化）

需要高样本效率：
  → 基于模型的方法（Dreamer）
  → 离线强化学习（CQL）

大模型对齐：
  → PPO + RLHF（ChatGPT/InstructGPT）
  → GRPO（DeepSeekMath，更高效）
  → DPO（更简单，无需 RM）

9.2 记忆口诀

MDP 五元组：S A P R γ
贝尔曼方程：V = max_a (R + γ·V')
Q-Learning：Q ← Q + α·(r + γ·max Q' - Q)
DQN 两件宝：经验回放 + 目标网络
策略梯度：∇J = E[∇log π · Q]
Actor-Critic：Actor 演戏，Critic 评分
PPO：clip 限制更新步幅
GRPO：不用 Critic，用组内相对排序
DPO：绕过 RM，直接微调策略
RLHF：SFT 打底 → RM 打分 → PPO 优化

9.3 未来趋势

1. 离线强化学习（Offline RL）
   从固定数据集中学习，不需实时交互
   适合真实世界应用（自动驾驶、医疗）

2. 多模态强化学习
   结合视觉、语言等模态
   如 RT-2（机器人的视觉-语言-动作）

3. 推理时的 RL（Test-time RL）
   边推理边学习，用搜索来改进生成

4. 自我改进的 AI（Self-Improving）
   模型生成数据 → 用 RLHF 自我提升
   代表：AlphaProof、DeepSeek-R1

---

参考资料：

• Sutton & Barto, Reinforcement Learning: An Introduction（强化学习圣经）
• Mnih et al., Playing Atari with Deep Reinforcement Learning（DQN 原始论文）
• Schulman et al., Proximal Policy Optimization Algorithms（PPO）
• Ouyang et al., Training language models to follow instructions with human feedback（InstructGPT/RLHF）
• DeepSeek, DeepSeek-R1: Incentivizing Reasoning Capability in RL（GRPO）
• Rafailov et al., Direct Preference Optimization（DPO）