Skip to content
←

필사 모드: 强化学习完全精通：从 DQN、PPO 到 RLHF、DPO 的 LLM 对齐

中文
0%
정확도 0%
💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

引言

强化学习（Reinforcement Learning, RL）是一种机器学习范式，智能体通过与环境交互，自主学习能够最大化奖励的策略。从 AlphaGo 制霸围棋界，到 ChatGPT 的 RLHF 对齐，它已经成为现代 AI 的核心技术。

本文将从 MDP 数学基础到最新的 DPO，一次性为你梳理清楚。

1. 强化学习基础：MDP

马尔可夫决策过程（Markov Decision Process）

强化学习被形式化为 MDP。MDP 由五元组 (S,A,P,R,γ)(S, A, P, R, \gamma) 定义：

  • SS：状态空间（State space）
  • AA：动作空间（Action space）
  • P(s′∣s,a)P(s'|s, a)：转移概率（Transition probability）
  • R(s,a,s′)R(s, a, s')：奖励函数（Reward function）
  • γ∈[0,1)\gamma \in [0, 1)：折扣因子（Discount factor）

马尔可夫性质：未来状态仅由当前状态决定。

P(st+1∣st,at,st−1,at−1,…)=P(st+1∣st,at)P(s_{t+1} | s_t, a_t, s_{t-1}, a_{t-1}, \ldots) = P(s_{t+1} | s_t, a_t)

策略（Policy）

策略 π\pi 是从状态到动作的映射：

  • 确定性策略：a=π(s)a = \pi(s)
  • 随机性策略：a∼π(a∣s)a \sim \pi(a|s)

价值函数（Value Function）

状态价值函数：遵循策略 π\pi 时，状态 ss 的期望累积奖励

Vπ(s)=Eπ[∑t=0∞γtrt ∣ s0=s]V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \,\Big|\, s_0 = s \right]

动作价值函数（Q 函数）：在状态 ss 采取动作 aa 之后再遵循策略 π\pi 时的期望奖励

Qπ(s,a)=Eπ[∑t=0∞γtrt ∣ s0=s,a0=a]Q^\pi(s, a) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \,\Big|\, s_0 = s, a_0 = a \right]

贝尔曼方程（Bellman Equation）

价值函数的递归分解：

Vπ(s)=∑aπ(a∣s)∑s′P(s′∣s,a)[R(s,a,s′)+γVπ(s′)]V^\pi(s) = \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma V^\pi(s') \right]

贝尔曼最优方程：

V∗(s)=max⁡a∑s′P(s′∣s,a)[R(s,a,s′)+γV∗(s′)]V^*(s) = \max_a \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma V^*(s') \right]

Q∗(s,a)=∑s′P(s′∣s,a)[R(s,a,s′)+γmax⁡a′Q∗(s′,a′)]Q^*(s, a) = \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma \max_{a'} Q^*(s', a') \right]

2. 无模型强化学习

Q-Learning（异策略）

Q-Learning 是异策略（off-policy）方法。TD 更新规则：

Q(st,at)←Q(st,at)+α[rt+γmax⁡a′Q(st+1,a′)−Q(st,at)]Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha \left[ r_t + \gamma \max_{a'} Q(s_{t+1}, a') - Q(s_t, a_t) \right]

目标：rt+γmax⁡a′Q(st+1,a′)r_t + \gamma \max_{a'} Q(s_{t+1}, a')（使用贪心策略）

SARSA（同策略）

SARSA 是同策略（on-policy）方法：

Q(st,at)←Q(st,at)+α[rt+γQ(st+1,at+1)−Q(st,at)]Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha \left[ r_t + \gamma Q(s_{t+1}, a_{t+1}) - Q(s_t, a_t) \right]

目标：rt+γQ(st+1,at+1)r_t + \gamma Q(s_{t+1}, a_{t+1})（使用实际的下一个动作 at+1a_{t+1}）

项目Q-LearningSARSA
策略类型异策略同策略
更新基准greedy 动作实际动作
悬崖探索最优路径安全路径

DQN（Deep Q-Network）

DQN 用神经网络来近似 Q 函数。有两项关键的稳定化技术：

  1. 经验回放（Experience Replay）：从缓冲区中采样小批量数据
  2. 目标网络（Target Network）：定期复制得到的独立网络，用于提供稳定的目标
import torch
import torch.nn as nn
import numpy as np
from collections import deque
import random

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)

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 (
            torch.FloatTensor(np.array(states)),
            torch.LongTensor(actions),
            torch.FloatTensor(rewards),
            torch.FloatTensor(np.array(next_states)),
            torch.FloatTensor(dones)
        )

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

def train_dqn_step(online_net, target_net, optimizer, buffer, batch_size=64, gamma=0.99):
    if len(buffer) < batch_size:
        return
    states, actions, rewards, next_states, dones = buffer.sample(batch_size)

    # 当前 Q 值
    current_q = online_net(states).gather(1, actions.unsqueeze(1)).squeeze(1)

    # 目标 Q 值（使用目标网络）
    with torch.no_grad():
        max_next_q = target_net(next_states).max(1)[0]
        target_q = rewards + gamma * max_next_q * (1 - dones)

    loss = nn.MSELoss()(current_q, target_q)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item()

Double DQN

解决 DQN 的过高估计（overestimation）问题：分离动作选择与价值评估：

Q(st,at)←rt+γQtarget ⁣(st+1,  arg⁡max⁡a′Qonline(st+1,a′))Q(s_t, a_t) \leftarrow r_t + \gamma Q_{\text{target}}\!\left(s_{t+1},\; \arg\max_{a'} Q_{\text{online}}(s_{t+1}, a')\right)

Dueling DQN

把 Q 值分解为价值函数 V(s)V(s) 与优势函数 A(s,a)A(s,a)：

Q(s,a)=V(s)+A(s,a)−1∣A∣∑a′A(s,a′)Q(s, a) = V(s) + A(s, a) - \frac{1}{|A|} \sum_{a'} A(s, a')

class DuelingDQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.feature = nn.Sequential(
            nn.Linear(state_dim, 128), nn.ReLU()
        )
        self.value_stream = nn.Sequential(
            nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, 1)
        )
        self.advantage_stream = nn.Sequential(
            nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, action_dim)
        )

    def forward(self, x):
        feat = self.feature(x)
        value = self.value_stream(feat)
        advantage = self.advantage_stream(feat)
        return value + advantage - advantage.mean(dim=1, keepdim=True)

3. 策略梯度法（Policy Gradient）

REINFORCE

直接对策略进行参数化并估计梯度：

∇θJ(θ)=Eτ∼πθ[∑t=0T∇θlog⁡πθ(at∣st)⋅Gt]\nabla_\theta J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{T} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot G_t \right]

其中 Gt=∑k=tTγk−trkG_t = \sum_{k=t}^{T} \gamma^{k-t} r_k 是从时间 tt 开始的累积奖励。

Actor-Critic

为了解决 REINFORCE 高方差的问题，使用价值函数作为基线：

∇θJ(θ)=E[∇θlog⁡πθ(at∣st)⋅A(st,at)]\nabla_\theta J(\theta) = \mathbb{E} \left[ \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot A(s_t, a_t) \right]

优势函数：A(st,at)=Q(st,at)−V(st)A(s_t, a_t) = Q(s_t, a_t) - V(s_t)

用 TD 误差近似：A(st,at)≈rt+γV(st+1)−V(st)A(s_t, a_t) \approx r_t + \gamma V(s_{t+1}) - V(s_t)

A3C / A2C

A3C（Asynchronous Advantage Actor-Critic）：多个 worker 异步并行学习

A2C（Advantage Actor-Critic）：同步地对所有 worker 的梯度取平均后再更新

PPO（Proximal Policy Optimization）

当前应用最广泛的策略梯度算法。核心思想：通过限制策略更新幅度来实现稳定训练。

裁剪目标函数：

LCLIP(θ)=Et[min⁡ ⁣(rt(θ)At,  clip(rt(θ),1−ϵ,1+ϵ)At)]L^{CLIP}(\theta) = \mathbb{E}_t \left[ \min\!\left( r_t(\theta) A_t,\; \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) A_t \right) \right]

其中 rt(θ)=πθ(at∣st)πθold(at∣st)r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{old}}(a_t|s_t)} 是概率比。

PPO 的完整目标函数：

L(θ)=LCLIP(θ)−c1LVF(θ)+c2H[πθ]L(\theta) = L^{CLIP}(\theta) - c_1 L^{VF}(\theta) + c_2 H[\pi_\theta]

  • LVFL^{VF}：价值函数损失（MSE）
  • H[πθ]H[\pi_\theta]：熵奖励（鼓励探索）
from stable_baselines3 import PPO
import gymnasium as gym

env = gym.make("CartPole-v1")
model = PPO(
    "MlpPolicy",
    env,
    learning_rate=3e-4,
    n_steps=2048,
    batch_size=64,
    n_epochs=10,
    gamma=0.99,
    gae_lambda=0.95,
    clip_range=0.2,       # epsilon：裁剪比例
    ent_coef=0.01,        # 熵奖励系数
    verbose=1
)
model.learn(total_timesteps=100_000)

obs, _ = env.reset()
for _ in range(1000):
    action, _ = model.predict(obs, deterministic=True)
    obs, reward, terminated, truncated, info = env.step(action)
    if terminated or truncated:
        obs, _ = env.reset()

4. 高级方法

SAC（Soft Actor-Critic）

SAC 是一种最大熵强化学习框架，同时追求奖励最大化与熵最大化：

π∗=arg⁡max⁡πE[∑tγt(rt+αH[π(⋅∣st)])]\pi^* = \arg\max_\pi \mathbb{E} \left[ \sum_t \gamma^t \left( r_t + \alpha \mathcal{H}[\pi(\cdot|s_t)] \right) \right]

α\alpha 是温度参数，用来调节探索的程度。

软 Q 函数贝尔曼方程：

Q(st,at)=rt+γEst+1[V(st+1)]Q(s_t, a_t) = r_t + \gamma \mathbb{E}_{s_{t+1}} \left[ V(s_{t+1}) \right]

V(st)=Ea∼π[Q(st,a)−αlog⁡π(a∣st)]V(s_t) = \mathbb{E}_{a \sim \pi} \left[ Q(s_t, a) - \alpha \log \pi(a|s_t) \right]

SAC 在连续动作空间问题上表现出色，并通过自动温度调节降低了对超参数的敏感度。

from stable_baselines3 import SAC
import gymnasium as gym

env = gym.make("HalfCheetah-v4")
model = SAC(
    "MlpPolicy", env,
    learning_rate=3e-4,
    buffer_size=1_000_000,
    learning_starts=10_000,
    batch_size=256,
    tau=0.005,
    gamma=0.99,
    train_freq=1,
    gradient_steps=1,
    verbose=1
)
model.learn(total_timesteps=1_000_000)

TD3（Twin Delayed Deep Deterministic）

解决 DDPG 过高估计问题的三项技术：

  1. Twin Critics：选取两个 Q 网络中的最小值
  2. Delayed Policy Updates：以低于 critic 的频率更新 actor
  3. Target Policy Smoothing：向目标动作添加噪声

y=r+γmin⁡i=1,2Qθi′(s′,a~′),a~′=clip(πϕ′(s′)+ϵ,alow,ahigh)y = r + \gamma \min_{i=1,2} Q_{\theta_i'}(s', \tilde{a}'), \quad \tilde{a}' = \text{clip}(\pi_{\phi'}(s') + \epsilon, a_{low}, a_{high})

HER（Hindsight Experience Replay）

在稀疏奖励（sparse reward）环境中，把失败的经验也重新利用起来：将目标事后替换为实际到达的状态来进行学习：

  • 原始经验：(st,at,rt,st+1,g)(s_t, a_t, r_t, s_{t+1}, g) — 未能达成目标 gg
  • HER 变换：(st,at,rt′,st+1,g′)(s_t, a_t, r'_t, s_{t+1}, g') — g′=sTg' = s_T（实际到达的最终状态）

目标替换策略：

  • future：从同一回合的未来状态中随机选择（默认值）
  • episode：同一回合中的任意状态
  • final：回合的最后一个状态
from stable_baselines3 import HerReplayBuffer, SAC

env = gym.make("FetchReach-v2")
model = SAC(
    "MultiInputPolicy",
    env,
    replay_buffer_class=HerReplayBuffer,
    replay_buffer_kwargs=dict(
        n_sampled_goal=4,
        goal_selection_strategy="future",
    ),
    verbose=1,
)
model.learn(total_timesteps=100_000)

5. RLHF：用强化学习对齐 LLM

InstructGPT 流水线

作为 ChatGPT 核心技术的 RLHF（Reinforcement Learning from Human Feedback），由三个阶段构成：

阶段 1：SFT（Supervised Fine-Tuning）

  • 用高质量的示范数据对基础模型进行微调
  • 用人类专家撰写的理想回答进行学习

阶段 2：奖励模型训练（Reward Model Training）

  • 人类在两个回答中选出更好的一个（收集偏好数据）
  • 用偏好数据训练奖励模型

LRM=−E(x,yw,yl)[log⁡σ ⁣(rϕ(x,yw)−rϕ(x,yl))]\mathcal{L}_{RM} = -\mathbb{E}_{(x, y_w, y_l)} \left[ \log \sigma\!\left( r_\phi(x, y_w) - r_\phi(x, y_l) \right) \right]

ywy_w 是被偏好的回答，yly_l 是未被偏好的回答。

阶段 3：用 PPO 微调 LLM

  • 把奖励模型当作环境、LLM 当作智能体来应用 PPO
  • 用 KL 惩罚项控制模型不要偏离原始模型太远

reward(x,y)=rϕ(x,y)−β⋅KL ⁣[πθ(y∣x) ∥ πref(y∣x)]\text{reward}(x, y) = r_\phi(x, y) - \beta \cdot \text{KL}\!\left[\pi_\theta(y|x) \,\|\, \pi_{ref}(y|x)\right]

import torch
import torch.nn as nn

class RewardModel(nn.Module):
    def __init__(self, base_model_name="gpt2"):
        super().__init__()
        from transformers import AutoModel
        self.backbone = AutoModel.from_pretrained(base_model_name)
        hidden_size = self.backbone.config.hidden_size
        self.reward_head = nn.Linear(hidden_size, 1)

    def forward(self, input_ids, attention_mask):
        outputs = self.backbone(input_ids=input_ids, attention_mask=attention_mask)
        last_hidden = outputs.last_hidden_state[:, -1, :]
        return self.reward_head(last_hidden).squeeze(-1)

def compute_reward_model_loss(reward_model, chosen_ids, chosen_mask,
                               rejected_ids, rejected_mask):
    """基于 Bradley-Terry 模型的偏好损失"""
    chosen_reward = reward_model(chosen_ids, chosen_mask)
    rejected_reward = reward_model(rejected_ids, rejected_mask)
    loss = -torch.log(torch.sigmoid(chosen_reward - rejected_reward)).mean()
    return loss

用 TRL 库对 LLM 进行 PPO 微调：

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer

ppo_config = PPOConfig(
    model_name="gpt2",
    learning_rate=1.41e-5,
    batch_size=128,
    mini_batch_size=16,
    gradient_accumulation_steps=4,
    target_kl=0.1,
    kl_penalty="kl",
)

model = AutoModelForCausalLMWithValueHead.from_pretrained(ppo_config.model_name)
tokenizer = AutoTokenizer.from_pretrained(ppo_config.model_name)
ppo_trainer = PPOTrainer(ppo_config, model, ref_model=None, tokenizer=tokenizer)

for batch in dataloader:
    query_tensors = batch["input_ids"]
    response_tensors = ppo_trainer.generate(query_tensors, max_new_tokens=200)
    rewards = [reward_model(q, r) for q, r in zip(query_tensors, response_tensors)]
    stats = ppo_trainer.step(query_tensors, response_tensors, rewards)

DPO（Direct Preference Optimization）

DPO 无需奖励模型，直接用偏好数据对 LLM 进行对齐，把 PPO 复杂的强化学习循环替换为简单的分类损失：

LDPO(πθ;πref)=−E(x,yw,yl)[log⁡σ ⁣(βlog⁡πθ(yw∣x)πref(yw∣x)−βlog⁡πθ(yl∣x)πref(yl∣x))]\mathcal{L}_{DPO}(\pi_\theta; \pi_{ref}) = -\mathbb{E}_{(x, y_w, y_l)} \left[ \log \sigma\!\left( \beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)} \right) \right]

import torch.nn.functional as F

def dpo_loss(pi_logps_chosen, pi_logps_rejected,
             ref_logps_chosen, ref_logps_rejected, beta=0.1):
    """
    DPO 损失函数
    Args:
        pi_logps_chosen:    学习模型对偏好回答的 log-prob
        pi_logps_rejected:  学习模型对非偏好回答的 log-prob
        ref_logps_chosen:   参考模型对偏好回答的 log-prob
        ref_logps_rejected: 参考模型对非偏好回答的 log-prob
        beta: KL 惩罚强度
    """
    pi_log_ratio = pi_logps_chosen - pi_logps_rejected
    ref_log_ratio = ref_logps_chosen - ref_logps_rejected
    # 隐式奖励差异
    logits = beta * (pi_log_ratio - ref_log_ratio)
    loss = -F.logsigmoid(logits).mean()
    return loss

DPO 与 RLHF 的比较：

项目RLHF + PPODPO
奖励模型需要单独训练不需要
所需模型数量Actor + Critic + RM + 参考模型学习模型 + 参考模型
训练稳定性存在 RL 不稳定性达到监督学习级别的稳定
实现复杂度高低

6. 多智能体强化学习

环境类型

环境类型说明示例
完全合作共享奖励，团队目标机器人团队协作
完全竞争零和博弈国际象棋、围棋
混合合作+竞争足球、MOBA

MADDPG（Multi-Agent DDPG）

去中心化执行 + 中心化训练（CTDE）范式：

  • 执行时：每个智能体仅根据自身的观测来决定动作
  • 训练时：critic 会利用所有智能体的观测与动作

Qiμ(x,a1,…,aN)Q_i^\mu(x, a_1, \ldots, a_N)

x=(o1,…,oN)x = (o_1, \ldots, o_N) 是全局观测，aia_i 是智能体 ii 的动作。

class MADDPGCritic(nn.Module):
    """利用所有智能体信息的中心化 critic"""
    def __init__(self, n_agents, obs_dim, action_dim):
        super().__init__()
        input_dim = n_agents * (obs_dim + action_dim)
        self.net = nn.Sequential(
            nn.Linear(input_dim, 256), nn.ReLU(),
            nn.Linear(256, 256), nn.ReLU(),
            nn.Linear(256, 1)
        )

    def forward(self, all_obs, all_actions):
        x = torch.cat([all_obs, all_actions], dim=-1)
        return self.net(x)

OpenSpiel

Google DeepMind 的多智能体强化学习框架：

import pyspiel

game = pyspiel.load_game("tic_tac_toe")
state = game.new_initial_state()

while not state.is_terminal():
    legal_actions = state.legal_actions()
    action = legal_actions[0]  # 实际中应通过策略来选择
    state.apply_action(action)

returns = state.returns()
print(f"玩家 0 奖励：{returns[0]}")
print(f"玩家 1 奖励：{returns[1]}")

7. 实战环境

Gymnasium（OpenAI Gym 的后继者）

import gymnasium as gym
import numpy as np

class NormalizedObsWrapper(gym.ObservationWrapper):
    """把观测值归一化到 [-1, 1] 的包装器"""
    def __init__(self, env):
        super().__init__(env)
        self.obs_low = env.observation_space.low
        self.obs_high = env.observation_space.high

    def observation(self, obs):
        normalized = (
            2.0 * (obs - self.obs_low)
            / (self.obs_high - self.obs_low + 1e-8)
            - 1.0
        )
        return normalized.astype(np.float32)

class RewardShapingWrapper(gym.RewardWrapper):
    """奖励缩放包装器"""
    def __init__(self, env, scale=0.01):
        super().__init__(env)
        self.scale = scale

    def reward(self, reward):
        return reward * self.scale

base_env = gym.make("LunarLander-v2")
env = RewardShapingWrapper(NormalizedObsWrapper(base_env))
obs, info = env.reset(seed=42)

MuJoCo

基于物理的连续控制环境，是机器人研究不可或缺的部分：

  • HalfCheetah-v4：猎豹机器人奔跑（17 维状态，6 维动作）
  • Humanoid-v4：类人机器人行走（376 维状态，17 维动作）
  • Ant-v4：四足步行机器人（111 维状态，8 维动作）

基准性能（1M 步）：

环境SACTD3PPO
HalfCheetah~12000~9000~3000
Ant~5500~4000~1500
Humanoid~5000~4500~600

Isaac Gym / Isaac Lab

NVIDIA 的 GPU 加速物理仿真器，可并行运行数千个环境：

  • 相比 CPU 仿真，训练速度快 2000 倍
  • 通过域随机化（Domain Randomization）提升 sim-to-real 迁移效果
  • 同时运行 4096 个环境，可在数小时内完成机器人训练
# Isaac Lab 示例（简化版）
from isaaclab.envs import DirectRLEnvCfg

class CartpoleEnvCfg(DirectRLEnvCfg):
    num_envs = 4096          # 4096 个并行环境
    episode_length_s = 5.0
    decimation = 2
    action_scale = 100.0

# 在 GPU 上并行运行 4096 个 CartPole
# obs.shape: [4096, obs_dim]

真实世界 RL 部署的考量事项

  1. 安全约束（Safe RL）：防止训练过程中出现危险动作，采用基于约束的优化方法（CPO、TRPO-Lagrangian）
  2. 样本效率：真实世界的数据昂贵且缓慢 — 可利用离线 RL、基于模型的 RL
  3. Sim-to-Real 迁移：通过域随机化、适配层（RMA）缩小 Reality Gap
  4. 离线 RL：仅用预先收集的数据进行学习 — Conservative Q-Learning（CQL）、IQL

测验：强化学习理解自查

Q1. 请说明 Q-Learning 与 SARSA 在同策略 vs 异策略上的差异。

答案：Q-Learning 是异策略，SARSA 是同策略

说明：Q-Learning 的更新目标是 r+γmax⁡a′Q(s′,a′)r + \gamma \max_{a'} Q(s', a')，无论实际采取的动作是什么，都使用贪心最大值。而 SARSA 在 r+γQ(s′,a′)r + \gamma Q(s', a') 中，a′a' 是实际采取的动作。在 CliffWalking 问题中，Q-Learning 会学到沿悬崖边缘的最优路径，但在探索过程中经常跌落；SARSA 则会学到更安全的绕行路径。

Q2. 在 PPO 中，clip ratio 超参数 epsilon 对训练稳定性起到什么作用？

答案：epsilon 控制策略更新的保守程度

说明：当 rt(θ)=πθ/πoldr_t(\theta) = \pi_\theta / \pi_{old} 超出 [1−ϵ,1+ϵ][1-\epsilon, 1+\epsilon] 范围时，梯度会被阻断。ϵ\epsilon 太小会导致学习变慢，容易陷入局部最小值；反之太大则会让策略剧烈变化而变得不稳定。通常 ϵ=0.2\epsilon = 0.2 是不错的默认值，在训练后期逐渐减小的调度策略也很有效。

Q3. 在 RLHF 中，奖励模型的训练数据是如何收集的？

答案：由人类评估者比较两个回答并标注偏好

说明：把针对同一提示词的两个回答 (y1,y2)(y_1, y_2) 展示给人类评估者，让其选出更好的一个。比起绝对评分（1-5 分），成对比较（pairwise comparison）更加一致、也更可靠。收集到的偏好数据 (x,yw,yl)(x, y_w, y_l) 用来训练 Bradley-Terry 模型。Anthropic 的 Constitutional AI 中，还使用了由 AI 直接充当评估者角色的 RLAIF。

Q4. 为什么 DPO 比基于 PPO 的 RLHF 实现起来更简单？

答案：不需要奖励模型，也不需要强化学习循环

说明：RLHF+PPO 需要三个阶段（SFT、奖励模型训练、PPO 微调），并且要同时把多个模型（actor、critic、奖励模型、参考模型）载入 GPU 显存。DPO 则把偏好数据中的隐式奖励直接整合进公式里，只用一个简单的交叉熵风格损失就能完成微调。只需要参考模型和学习模型这两个模型，也没有强化学习特有的不稳定性。

Q5. 在 Soft Actor-Critic 中，熵正则化起到什么作用？

答案：鼓励探索 + 学习多个最优策略

说明：在 SAC 的目标函数中加入熵项 αH[π(⋅∣s)]\alpha \mathcal{H}[\pi(\cdot|s)] 后，智能体在最大化奖励的同时，也会努力保持动作的随机性。这提供了一种自动的探索机制，有助于跳出局部最小值。此外，当存在多个同样好的动作时，策略会学习均匀地在它们之间进行选择，从而获得更鲁棒的策略。温度参数 α\alpha 会通过自动调优（automatic entropy tuning）根据目标熵进行调节。

算法对比汇总

算法策略类型动作空间特点
Q-Learning异策略离散简单，基于表
DQN异策略离散深度学习 + ER + TN
Double DQN异策略离散缓解过高估计
Dueling DQN异策略离散V + A 分离
REINFORCE同策略离散/连续高方差
A2C同策略离散/连续Actor-Critic
PPO同策略离散/连续稳定、通用
SAC异策略连续最大熵
TD3异策略连续SAC 的确定性版本
HER异策略目标导向稀疏奖励

结语

强化学习正在从单纯的游戏 AI，向机器人、LLM 对齐、自动驾驶、新药研发等领域爆发式扩展应用范围。尤其是 RLHF 与 DPO，作为 ChatGPT、Claude、Gemini 等 LLM 的核心对齐技术，理解强化学习已经成为现代 AI 研究者的必备能力。

推荐学习路径：

  1. 用 Gymnasium 亲自实现 Q-Learning/DQN
  2. 用 Stable-Baselines3 实验 PPO/SAC
  3. 用 TRL 库实践 RLHF/DPO
  4. 用 Isaac Lab 探索机器人强化学习

参考资料：

  • Sutton & Barto, "Reinforcement Learning: An Introduction" (2nd ed.)
  • Spinning Up in Deep RL (OpenAI)
  • Stable-Baselines3 官方文档
  • TRL (Transformer Reinforcement Learning) by Hugging Face
  • Isaac Lab 官方文档

현재 단락 (1/376)

强化学习（Reinforcement Learning, RL）是一种机器学习范式，智能体通过与环境交互，**自主学习能够最大化奖励的策略**。从 AlphaGo 制霸围棋界，到 ChatGPT 的 ...

작성 글자: 0자원문 글자: 14,130자작성 단락: 0/376