第 12 章 · 学习是怎么发生的

强化学习:试错里学策略

第二部分一路走到这里,我们讲的几乎都是监督学习:每道题旁边都贴着标准答案, 模型照着把损失降下来就行(第 4 章损失、第 6 章反传)。 但“学习”不止这一种。下棋、打游戏、机器人走路、甚至日后对齐大模型(RLHF)——这些任务 没有逐条的标准答案,只有“这一步做得好不好”的反馈(奖励)。 这一章用大白话搭起强化学习(Reinforcement Learning, RL)的骨架, 让你日后读到 RLHF、PPO(第 20 章)时,不再觉得它们是凭空冒出来的黑魔法。 配套仓库里还有一个可运行的井字棋 Q-learning demo(src/bin/rl_tictactoe),本章多处会对照它的源码讲。

1. 监督学习之外:只有“好不好”,没有“标准答案”

回忆第 0 章:监督学习像有老师批改作业——输入一封邮件,标签告诉你“垃圾/正常”; MNIST 给你一张图,标签告诉你“这是数字 7”。每一步都有明确的正确答案, 损失函数就是在量“离正确答案有多远”。

可很多事情压根没有逐步的标准答案。教小孩骑车,你没法在每一瞬间告诉他“车把该左转 3.7 度”; 你能做的,是让他自己蹬、自己试,摔了(负反馈)就少来点、稳住往前(正反馈)就多来点。 强化学习就是把这种“试错 + 奖惩”写成算法。

它的设定是:一个智能体(agent)在环境里不断做选择, 环境不告诉你“唯一正确答案”,只在你做完之后给一个奖励(reward)——可能是 +1(吃到金币)、−1(撞墙)、 或者拖到最后才揭晓的终局分(棋赢了 +1、输了 −1)。你的目标不是拟合某个标签,而是学一套出招习惯, 让长期累积的奖励尽量大。

2. 一个贯穿全章的例子:老鼠走迷宫

抽象的词先放一放。我们用一个最小的例子把所有概念串起来:一只小老鼠在一条四格走廊里找奶酪。

老鼠一开始什么都不懂,只会乱走。但每次它偶然摸到奶酪、拿到那 +10,就会稍微记住“刚才那条路好像不错”。 反复试很多回合,它就慢慢学会了:不管在哪个格子,一直往右走准没错。 这套“在每个格子该往哪走”的习惯,就是我们要学的东西。

3. 智能体与环境:一个不停转的循环

强化学习的一切,都发生在智能体和环境之间这个循环里:

数学家把这类“状态—动作—奖励”的循环形式化成马尔可夫决策过程(MDP)。别被名字唬住,拆开就是五个直觉概念, 全能在迷宫里找到对应:

“马尔可夫”只是说:下一步去哪,只取决于“现在这一格”,和你之前怎么绕过来的没关系。迷宫正好满足。

回合、轨迹与时间步

上面那个循环会重复很多次,直到环境说“结束了”。从起点到终点的这一整趟,叫一个回合(episode); 其中每一步留下的“状态—动作—奖励”序列,叫轨迹(trajectory)。强化学习通常不是只训一步, 而是让智能体跑完许多回合,从大量轨迹里统计“什么习惯长期更赚”。

稀疏奖励:为什么 RL 常常很难训

我们的迷宫里,只有到奶酪才给 +10,中间全是 0——这叫稀疏奖励(sparse reward)。 智能体在摸到奶酪之前,几乎收不到“你走对了”的信号,只能靠随机乱撞偶然碰运气;价值要从终点倒灌很多步才能传到起点(第 7 节)。 若改成每往右一步就给 +1,就是密集奖励(dense reward),学起来会快得多,但也可能学到“绕圈刷分”的歪路。 真实任务(下棋赢一局才 +1、对话写完才由裁判打分)往往更接近稀疏奖励,这也是 RL 比监督学习更“费样本、费调参”的原因之一。

4. 回报:为什么要给未来“打折”

强化学习优化的从来不是“眼前这一步的奖励”,而是从现在起、一路加下去的总奖励,叫回报(return)。 但直接把未来所有奖励原样相加有两个毛病:游戏可能无限长(和会发散),而且“眼前的 10 分”通常比“十步之后的 10 分”更值钱。 解决办法是给未来的奖励逐步打折:

γ 就像“利率的反面”。取 γ = 0.9:下一步的奖励只算 0.9 倍,两步后算 0.81 倍…… 于是老鼠会倾向尽快拿到奶酪,而不是绕远路——因为绕得越久,那 +10 被折得越狠。 γ 越接近 1 越“有耐心、看长远”;越接近 0 越“只顾眼前”。

手算一笔回报

仍用老鼠走廊、γ=0.9。假设某次轨迹是:在格子 0 往右(r=0) → 格子 1 往右(r=0) → 格子 2 往右(r=+10,回合结束)。 从格子 0 出发这一刻算起的回报是:

强化学习要学的,正是“从每个状态出发,按当前策略走下去,预期能拿多少 G”——这就是下一节的价值。

5. 策略与价值:到底在学什么

RL 里有两个核心量,别混淆:

• 策略 π:在状态 s 下该怎么出招,记作 π(a|s)。这是我们最终想要的“习惯手册”——比如“在任何格子都往右”。
• 价值 V / Q:一个状态(或“状态+动作”)到底值多少,也就是从这里出发、按当前策略走下去,预期能拿到多少回报。
  V(s) 问“待在 s 有多好”;Q(s,a) 更细,问“在 s 先做动作 a 有多好”。

直觉上,离奶酪越近的格子越“值钱”。设 γ=0.9,一个学好的老鼠对“往右”这个动作的价值大概是这样(离终点越近,价值越高):

贝尔曼方程:把“长远”拆成“眼前一步 + 下一步”

价值不是拍脑袋填的,它满足一条递推关系,叫贝尔曼方程(Bellman equation)。 对动作价值 Q 而言,在最优策略下可以写成:

右边正是 Q-learning 更新公式里方括号中的目标值。算法并不知道真值 Q*,而是用每次试错得到的 r + γ·max Q(s′,·) 去逼近它——这叫时序差分(TD)学习: 不必等整局下完(像蒙特卡洛那样把 G 全加起来),每走一步就能用“下一步的估计”修正“这一步的估计”。

6. 探索与利用:走老路,还是试新路?

这里有个绕不开的两难。老鼠已经发现“往右能吃到奶酪”,那它是该一直走这条已知的路(利用 exploitation), 还是偶尔试试没走过的方向(探索 exploration),万一有更近的近道?

• 只利用:稳,但可能永远发现不了更好的路(也许左边有个传送门直达奶酪);
• 只探索:一直乱试,永远不安分,拿不到稳定的高分。

最常用的平衡办法叫 ε-greedy:大部分时候(概率 1−ε)走当前最优,偶尔(概率 ε)随机试一个。 就像去餐厅:多数时候点你爱吃的招牌菜(利用),偶尔手一抖点个没吃过的(探索)——万一发现新宠呢。 训练前期把 ε 调大(多探索),后期慢慢调小(多利用),是常见套路。

if (explore && config_.epsilon > 0.0) {
  double sample = random.CreateRandom() / 1000000.0;
  if (sample < config_.epsilon)                                    1
    return TicTacToeEnv::ChooseRandomAction(legal_actions, ...);   // 探索
}
return ArgmaxQ(state_key, legal_actions);                          2

7. Q-learning:用一张表,把价值从终点倒灌回起点

上面那张漂亮的价值表,老鼠怎么自己算出来?这就是 Q-learning 干的事。 它维护一张 Q(s,a) 表(一开始全填 0),每走一步就用这条更新公式修一下对应的格子。 Q-learning 是离策略(off-policy)的:更新时方括号里用的是“下一步理论上最好的动作” (maxa′ Q(s′,a′)),不必等于你实际会走的动作——所以表学的是最优价值,和当前乱探索的策略可以脱钩。

公式可以读成三句话:① r + γ·max Q(s′,·) 是走完这一步后对价值的新估计(目标); ② 减去旧的 Q(s,a) 得到误差 δ; ③ 用学习率 α 把旧值往目标挪一点。 这和第 6 章里“预测 − 标签 = 误差,再反传”是同一套逻辑,只是这里的“标签”来自环境和自己对未来的估计,不是人工标注。

double old_q = QRow(state_key)[action];
double target = reward;
if (!terminal)
  target += config_.gamma * MaxQ(next_state_key, legal_actions_next);  1
QRow(state_key)[action] = old_q + config_.alpha * (target - old_q);    2

初始 Q 表长什么样

四格走廊、每格两个动作(左/右),表只有 4×2=8 个格子。训练开始前通常全 0(表示“还不知道好不好”):

手算:从终点往回渗

设 α=0.5、γ=0.9,表全是 0。下面按时间顺序看几次关键更新(老鼠每次都碰巧选对了“往右”):

第 1 次——在格子2 往右,一步到奶酪, r=+10。格子3 是终点,之后没得走, max Q(格子3,·)=0:

第 2 次——又在格子2 往右(旧 Q 已是 5):

第 3 次——在格子1 往右,到格子2, r=0。此时 max Q(格子2,·) 已是 10:

第 4 次——在格子0 往右,到格子1, r=0, max Q(格子1,·)=9:

精彩之处在于:没有人给过任何一格“标准答案”,全是试错 + 贝尔曼式更新自己算出来的。 若老鼠偶尔往左绕远,只要最终还能到奶酪,终点附近的 Q 仍会先涨起来,再慢慢纠正中间格子的估计。

收敛后的 Q 表与策略

SARSA:若下一步按“实际会走的动作”来更新

与 Q-learning 几乎并列的还有 SARSA。差别只在方括号里:不用 max Q(s′,·), 而用下一步真正采取的动作 a′ 的 Q 值:

走廊例子太简单,两者差别不大;遇到探索有风险的环境,SARSA 往往更稳,Q-learning 往往更激进。知道这对概念,读论文时就不会被 on/off-policy 绊住。

8. 状态太多怎么办:用神经网络近似(DQN)

四格走廊只有 4 个状态,一张表绰绰有余。可要是状态是一整屏雅达利游戏画面呢?可能的画面近乎无穷,表根本存不下。 办法很自然:别存表了,训一个神经网络 Q_θ(s,a)——输入状态(像素),输出每个动作的 Q 值。这就是 DQN(Deep Q-Network)。

训练目标和 Q-learning 一样,只是把表上的 TD 误差换成网络的均方误差:

注意:这里用的还是第 3 章的网络、第 6 章的反向传播,没有发明新优化器。 区别只在于“标签”从人工标注换成了自己试错算出来的 TD 目标 r + γ·max Q(s′,·)。

经验回放(experience replay)

智能体连续玩游戏的相邻帧高度相关(这一帧和下一帧几乎一样),若每步都立刻拿来训网络,梯度会严重偏、训练不稳。 DQN 把每次转移 (s,a,r,s′) 存进一个回放缓冲区,训练时随机抽一批旧经验来算损失—— 相当于把轨迹打碎、混洗,让样本更接近独立同分布,和第 11 章里打乱 minibatch 是同一精神。

目标网络(target network)

若 TD 目标里的 Q(s′,·) 和正在更新的 Q_θ 是同一个网络,目标会跟着参数一起动, 像“追自己的影子”,容易发散。DQN 复制一份目标网络 θ⁻,每隔固定步数才从主网络同步一次; 算目标时用 θ⁻,算预测时用 θ——目标在一段时间内保持相对稳定,训练就稳得多。

DeepMind 2015 年用这套办法让 AI 仅看像素就学会玩几十种雅达利游戏,是深度强化学习的里程碑。

9. 动作太多怎么办:直接学策略(策略梯度 / Actor-Critic / PPO)

Q-learning 每步都要 max Q(s′,·)——把所有动作比一遍挑最大。动作只有“左/右”时没问题; 可要是动作空间大得吓人呢?比如语言模型每一步要从几万个 token 里挑一个(第 19 章), 为每个 token 维护 Q 并取 max,代价和存储都难以接受。

这时换个思路:不去估每个动作的价值,直接学“出招习惯” π_θ(a|s)—— 一个网络输入状态,输出动作概率分布(语言模型里就是下一个 token 的 softmax)。

策略梯度:回报高,就加大该动作概率

最朴素的 REINFORCE 算法:跑完一整局,若总回报 G 高,就对轨迹里每个 (s,a) 增大 π_θ(a|s);回报低就减小。梯度里会出现 log π,直觉是“在概率空间里往高回报方向挪”。 缺点:要等一局结束才有 G,方差大、学得慢。

Actor-Critic:演员出招,评论家打分

Actor-Critic 把两个网络拆开:Actor(演员) 就是策略 π_θ,负责选动作; Critic(评论家) 估计价值 V(s) 或 Q(s,a),负责告诉演员“这一步比平均好还是差”。 用优势 A = G − V(s)(或 TD 残差) 代替裸回报 G,方差小很多,也不必等整局结束—— Critic 用 TD 更新,Critic 的反馈指导 Actor 更新。DQN 只有“评论家味”;Actor-Critic 是策略 + 价值双头并进。

PPO:别一次更新迈太大

纯策略梯度容易“步子迈太大”——一次更新就把好不容易学到的策略带偏。PPO(近端策略优化) 在 Actor-Critic 上加两道保险:

• 裁剪(clipping):新策略相对旧策略的概率比若偏离 1 太远,就把梯度截断,单次更新幅度受限;
• KL 惩罚:显式惩罚新策略与旧策略的 KL 散度,别让分布一夜之间面目全非。

正因为实现简单、训练相对稳定,PPO 成了第 20 章 RLHF 与许多大模型后训练里的默认选项之一。 语言场景里,动作是离散 token,策略网络就是语言模型本身,输出层 softmax 即 π(·|s)。

10. 一条典型的 RL 训练循环

把前面散落的步骤收成一张“流水线”,大多数 Q-learning / DQN / PPO 代码都是这个壳子:

初始化 策略 π 或 Q 网络、环境 env
重复很多个回合:
  s = env.reset()                          // 回到起点           1
  重复直到回合结束:
    用 ε-greedy 或 π 采样动作 a            // 探索或按策略出招   2
    s′, r, done = env.step(a)              // 环境反馈           3
    存 (s,a,r,s′) 到回放缓冲区(若用 DQN)   4
    用 TD 目标或策略梯度更新参数           // 核心学习步         5
    s = s′
  可选: 衰减 ε、同步目标网络、记录回报曲线

与第 6 章监督训练对比:那里 epoch 遍历固定数据集;这里数据是智能体自己玩出来的, 分布随策略变化(非平稳),所以更依赖回放、目标网络、PPO 裁剪这类稳定技巧。

上面是通用壳子。仓库里 TabularQLearning::RunEpisode 把“智能体走一步 → 对手走一步 → 更新 Q”直接写进了一个函数:

env.Reset();
while (!env.IsTerminal()) {
  int state_key = env.AgentStateKey();
  int action = SelectAction(state_key, env.LegalActions(), true);     1
  env.StepAgent(action, agent_step);
  if (agent_step.done) {
    Update(state_key, action, agent_step.reward, -1, {}, true);      2
    break;
  }
  env.StepOpponentRandom(opponent_action, opponent_step);            3
  if (opponent_step.done) {
    Update(state_key, action, opponent_step.reward, -1, {}, true);
    break;
  }
  Update(state_key, action, 0.0, opponent_step.agent_state_key,
         env.LegalActions(), false);                                  4
}

11. 回到大模型:RLHF 就是一次强化学习

绕了一圈,回到本书主线。你在第 20 章会读到,大模型训练的最后一步 RLHF(基于人类反馈的强化学习), 用的正是本章这套语言——只要把五个概念对号入座,它立刻就不神秘了:

最近火的推理模型(如 o1、DeepSeek-R1)也沿用这套:对数学、代码这类有标准答案的题, 用“答对给正奖励、答错给负奖励”的强化学习,让模型自己摸索出好的推理套路(第 20 章)。可见强化学习这套“靠奖励试错”的思想,正越来越深地嵌进大模型。

12. 对照真实代码:井字棋环境怎么拼起来

第 2 节的老鼠走廊是纸上例子;配套项目用井字棋把同一套 MDP 五件套落到代码里。 下面是与源码的简要对照;完整逐行导读见实战部分的 第 25 章(与第 23 章 MNIST、 第 24 章 mini-LM 同一写法)。

int TicTacToeEnv::EncodeBoardKey(const std::array<Cell, 9> &board) {
  int key = 0, base = 1;
  for (int i = 0; i < 9; i++) {
    key += static_cast<int>(board[i]) * base;   // 空=0, X=1, O=2   1
    base *= 3;
  }
  return key;
}

board_[action] = player;
result_ = CheckResult();
out.done = IsTerminal();

if (result_ == GameResult::X_WIN)      out.reward = 1.0;              1
else if (result_ == GameResult::O_WIN)   out.reward = -1.0;
else if (result_ == GameResult::DRAW)    out.reward = 0.0;

if (!out.done) {
  agent_turn_ = !agent_turn_;
  out.agent_state_key = agent_turn_ ? AgentStateKey() : -1;           2
}

TabularQLearning agent;
agent.Init(config);                              // α, γ, ε 等超参     1
TicTacToeEnv env;

for (int episode = 0; episode < option.episodes; episode++) {
  agent.RunEpisode(env, train_opponent, stats);  // 第 10 节内循环       2
  agent.DecayEpsilon();
}
auto eval = agent.Evaluate(env, OpponentType::RANDOM, eval_games); 3

动手与思考

两大学习范式都认识了。下一部分换个视角:不同的数据,适合不同结构的网络—— 我们去认识处理图像的 CNN 和处理序列的 RNN,先从卷积开始。