从《飞翔的小鸟》到大模型：一篇讲透强化学习的来龙去脉

用两个能跑起来的真实项目，把强化学习六十年的历史串成一条线。

• 一个让 AI 学会玩 Flappy Bird 的 DQN（rl_games/flappy_bird_app）
• 一个让大语言模型学会做数学题的 GRPO（MathGPT 项目）

前者是 2013 年点燃深度强化学习的那把火，后者是 2024 年让 DeepSeek、OpenAI 们封神的同一把火——只不过烧到了语言模型上。本文不堆术语，我们顺着"一个矛盾催生一个方法"的逻辑走一遍。

引子：两个看起来毫不相关的项目，内核完全一样

先看两段我手头真实跑过的代码。

第一段，让一只像素小鸟学会自己穿管道（flappy_bird_torch_dqn.py）：

# 小鸟看到屏幕画面，神经网络输出"扇翅膀"还是"不动"两个动作的价值
current_q_values = self.model(states).gather(1, actions.unsqueeze(1))
next_q_values    = self.model(next_states).max(1)[0]
target_q_values  = rewards + (1 - dones) * self.gamma * next_q_values
loss = self.criterion(current_q_values, target_q_values)

第二段，让一个大语言模型学会做小学数学应用题（MathGPT 的 train_rl.py）：

# 模型对一道数学题生成 N 个答案，答对给 1 分答错给 0 分
advantages = rewards - rewards.mean()
# 然后提高"得分高的答案"被生成的概率
logp   = -model(inputs, targets, loss_reduction='none')
pg_obj = (logp * advantages.unsqueeze(-1)).sum()
loss   = -pg_obj

一个在玩游戏，一个在解数学题；一个处理像素，一个处理文字。但它们都在干同一件事：

在没有"标准答案"告诉你"每一步该怎么做"的情况下，仅凭一个最终的"好/坏"信号（奖励），让 AI 自己摸索出一套行为策略。

这就是强化学习（Reinforcement Learning, RL）。它和我们熟悉的"监督学习"有本质区别——监督学习是有老师手把手教（这张图是猫、那句话翻译成这样），强化学习是没有老师，只有一个最终打分的考官。

一句话先看懂:大模型其实是在"玩文字游戏"

如果上面还有点抽象,这里有个特别好用的类比——你完全可以这么理解这两个项目:

DQN 是在玩游戏:看着画面,一帧一帧地决定"上飞还是不动",目标是活得久。 大模型是在玩"文字游戏":看着上文,一个字一个字地决定"下一个字写啥",目标是答得对。

是不是一下子就通了?写一段话,本质上就是一局"一步步做选择"的游戏——每蹦出一个字,就相当于游戏里走了一步。小鸟在像素世界里选动作,大模型在文字世界里选词,玩法一模一样:

两者都是同一个循环:看情况 → 做选择 → 拿反馈 → 变得更会选。同一台发动机,一个开在游戏里,一个开在文字里。

(后面我们会看到,它俩有两个有意思的不同:小鸟的动作只有 2 个、大模型每步要从几万个字里挑;小鸟每一帧都有反馈、而数学题要整段答完才知道对错。正是这两点差异,催生了从 DQN 到 GRPO 的整条进化路线。)

理解了这一点，我们就能从头讲起了。

第一幕：史前时代——RL 的思想比深度学习老得多

强化学习的核心思想，可以追溯到心理学的行为主义：动物通过"试错"和"奖惩"来学习。狗做对动作给骨头，做错了不给——多来几次，狗就学会了。这套"trial and error + reward"的范式，就是 RL 的哲学源头。

数学化的奠基发生在上世纪：

• 1950s,贝尔曼方程（Bellman Equation）：理查德·贝尔曼提出"动态规划",给出了"当前决策的价值 = 即时回报 + 未来价值的折扣"这个递归结构。你在上面两段代码里看到的 rewards + gamma * next_q_values，本质上就是贝尔曼方程。gamma(折扣因子,代码里是 0.99)代表"未来的奖励要打个折"——眼前的一分钱比明年的一分钱更值钱。

• 1980s,时序差分学习（Temporal Difference, TD）：Sutton 提出 TD 学习，让 agent 不必等到一局游戏结束，每走一步就能更新自己的估计。

• 1989 年,Q-Learning：Watkins 提出了 Q-Learning。所谓 "Q"，就是 Q(状态, 动作)——在某个状态下做某个动作，长远来看到底有多大价值。如果我们能学到一张精确的 Q 表，那策略就很简单了：每一步都选 Q 值最大的动作。

但 Q-Learning 有个致命问题：状态空间一大就爆炸。Flappy Bird 的画面有多少种可能?如果用一张表格记录每个画面下每个动作的 Q 值，宇宙的原子都不够用。这个矛盾,卡了强化学习二十多年。

第二幕：2013，深度学习点火——DQN 与那只小鸟

2013 年,DeepMind 发表了一篇改变历史的论文:用深度神经网络去逼近那张大到不可能存下的 Q 表。这就是 DQN(Deep Q-Network)。他们让一个 AI 仅凭屏幕像素,在 Atari 游戏上打到了超越人类的水平。深度强化学习(Deep RL)由此诞生。

我们的 Flappy Bird 项目,就是 DQN 最朴素、最经典的实现。它把 DQN 的几个关键创新都用上了:

1. 用神经网络代替 Q 表

不再为每个状态存一个值,而是训练一个网络,输入状态、输出每个动作的 Q 值:

class DQN(nn.Module):
    def __init__(self, input_shape, n_actions):
        self.conv = nn.Sequential(   # 卷积层"看懂"游戏画面
            nn.Conv2d(input_shape[0], 32, kernel_size=8, stride=4), nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=4, stride=2), nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, stride=1), nn.ReLU())
        self.fc = nn.Sequential(     # 全连接层输出每个动作的价值
            nn.Linear(conv_out_size, 512), nn.ReLU(),
            nn.Linear(512, n_actions))

输入是小鸟看到的画面((3, 高, 宽) 的 RGB 图),输出是两个数:不扇翅膀的价值、扇翅膀的价值。哪个大就做哪个。这正是 DeepMind"仅凭像素玩游戏"的原汁原味复现。

项目里还有一个更轻量的版本(dqn.py),不读像素,直接读取游戏状态(小鸟的 y 坐标、最近管道的位置)。这说明:DQN 的思想和"用什么神经网络""喂什么状态"是解耦的——卷积网络处理图像,简单的全连接网络处理结构化数据,内核完全一样。

2. 经验回放(Experience Replay)

人不会学一次就忘,DQN 也一样。它把每一步的经历 (状态,动作,奖励,下一状态) 存进一个"记忆库",训练时随机抽一批出来学:

self.memory = deque(maxlen=10000)         # 记忆库,最多存一万条
def remember(self, state, action, reward, next_state, done):
    self.memory.append((state, action, reward, next_state, done))
# 训练时随机采样,打破数据间的时间相关性
batch = random.sample(self.memory, self.batch_size)

为什么要随机采样?因为连续几帧画面高度相似,如果按顺序学,网络会"钻牛角尖"。打乱顺序能让训练更稳定。这是 DQN 能 work 的关键技巧之一。

3. 探索与利用的平衡(ε-greedy)

这是 RL 永恒的难题:该按现有经验稳妥行事(利用),还是冒险尝试新动作以发现更好的策略(探索)?

DQN 用一个简单优雅的办法 ε-greedy:以概率 ε 随机乱试,其余时间选当前最优动作。而且 ε 随训练衰减——一开始什么都不会,就大胆乱试;越到后面越相信自己的判断:

def get_action(self, state):
    if random.random() < self.epsilon:        # 以 ε 的概率随机探索
        return random.randint(0, self.n_actions - 1)
    q_values = self.model(state)              # 否则选 Q 值最大的动作
    return torch.argmax(q_values).item()

def update_epsilon(self):                     # ε 从 1.0 慢慢衰减到 0.01
    self.epsilon = max(self.epsilon_final, self.epsilon * self.epsilon_decay)

小结这一幕:DQN 是"基于价值(value-based)"的方法。它不直接学"该做什么",而是学"每个动作值多少分",再间接地选最高分。这条路在游戏、机器人控制上大放异彩。但它有个先天局限——

DQN 只擅长"动作有限且离散"的场景(扇翅膀/不动,上/下/左/右)。可一旦动作空间是连续的(机械臂转多少度),或者大到天文数字(语言模型每一步要从几万个词里选一个),"遍历所有动作找最大 Q 值"就行不通了。

这个矛盾,把我们推向了另一条技术路线。

第三幕:另一条路——直接学"该怎么做"(策略梯度)

这一幕有三个看着唬人的词:策略、策略网络、策略梯度。别慌,我们先用大白话把它们拆开,你会发现它们简单到家。

先搞懂"策略"是什么

"策略"说白了就是"遇到某个情况,该怎么做"的习惯。

• 你过马路看到红灯就停、绿灯就走——这套"看到什么、就做什么"的反应,就是你的策略。
• 那只小鸟"看到管道快撞上了就扇翅膀"——这也是一套策略。

注意它和第二幕 DQN 的区别。DQN 是个纠结的人:每一步它要先在心里给每个动作打分("扇翅膀值 8 分,不动值 3 分"),再挑分高的做。而"策略"是个爽快的人:看一眼情况,直接告诉你"该扇翅膀",不报分数、不纠结。

DQN:先算每个选择值多少分,再挑最高分的。(绕一道弯) 策略:看一眼,直接说该干嘛。(一步到位)

为什么要"一步到位"?回想第二幕的矛盾:语言模型每一步要从几万个词里挑一个。让 DQN 那样"给几万个词逐个打分再挑最大"太慢太难了;而"看一眼上文、直接说出下一个词最可能是哪几个",反而自然得多。动作越多,"直接学怎么做"就越划算。

"策略网络"和"策略梯度"

把这套"看情况、说该干嘛"的本事,装进一个神经网络里,这个网络就叫策略网络——名字唬人,其实就是"决策大脑"。

那它怎么变聪明?靠一条朴素到家的规则:

做完一件事,如果结果好,就调整大脑、让它下次更容易这么做;如果结果差,就让它下次别这么做。

这个"根据结果好坏,反过来调整决策大脑"的过程,就是策略梯度(梯度 = 神经网络调整参数的方向,你可以直接理解成"往变好的方向拧一下")。

就这么简单。一句话总结这三个词:

策略 = 遇事怎么办的习惯;策略网络 = 装着这套习惯的大脑;策略梯度 = 根据结果好坏去拧这个大脑的旋钮。

它最早的样子:REINFORCE(1992)

最经典的策略梯度算法叫 REINFORCE,它把上面那条规则写成了一行式子:

loss = - log(这个动作被选中的概率) × 这个动作最终拿到的回报

不用怕这行公式,它说的就是大白话那句话:回报高的动作,被"按"着提高概率;回报低甚至倒扣分的,被压低概率。做得多了,这个"决策大脑"就越来越偏向高回报的做法了。

但 REINFORCE 有个老毛病:方差太大,训练不稳定。同一个策略,这局运气好拿 100 分,下局运气差拿 10 分,信号忽上忽下,网络无所适从。

解决办法是引入一个基线(baseline):不看绝对得分,而看"比平均水平高多少"。这个"比平均高多少"就叫优势(Advantage):

优势 = 这次的回报 - 平均回报

记住"优势 = 回报 - 平均回报"这个式子,它就是后面 GRPO 的灵魂。

到这里,我们手上已经有了两条路:

• 基于价值(第二幕 DQN):学"每个动作值多少分",擅长离散小动作;
• 基于策略(第三幕 REINFORCE):直接学"该怎么做",能应付更大的动作空间。

接下来这一幕,这两条路第一次合二为一,并诞生了强化学习历史上最出圈的事件。

第四幕:2016,AlphaGo——两条路的合流,与"自己跟自己下棋"

DQN 征服了 Atari,但那些都是反应类游戏。真正的圣杯是围棋。

围棋为什么难?它的合法局面约有 10 的 170 次方种——比可观测宇宙的原子总数还多得多。"遍历所有可能"在围棋面前是个笑话;高手下棋靠的是难以言传的"棋感"和"大局观"。几十年来,围棋一直被认为是 AI "至少还要二十年"才能攻克的堡垒。

结果 2016 年,DeepMind 的 AlphaGo 以 4:1 击败世界冠军李世石,举世震动。这是深度强化学习第一次真正进入大众视野。

AlphaGo 的精妙,恰恰在于它同时用上了前两幕的两条路:

1. 两个网络:策略网络 + 价值网络

策略网络(决策大脑):看着当前棋盘,直接说"下一手该下在哪里"
                     —— 这就是第三幕的"策略":看一眼,说该干嘛
价值网络(打分大脑):看着当前棋盘,说"现在这个局面,我方赢面有多大"
                     —— 这就是第二幕的"价值":给局面打个分

一个管"该怎么走",一个管"走完之后局面好不好"。第二幕的"打分"和第三幕的"决策",在 AlphaGo 这里第一次握手言和、协同作战。

2. 蒙特卡洛树搜索(MCTS):让 AI 学会"深思熟虑"

光有直觉(网络的瞬时判断)还不够,高手会"往后多想几步"。AlphaGo 用 蒙特卡洛树搜索(MCTS),在策略网络和价值网络的指引下,在脑子里推演"如果我下这里、对手会怎么应、然后我再……",只在最有希望的分支上深入搜索。

这是一个关键升级:前面的 DQN、REINFORCE 都是"看一眼就出手",而 AlphaGo 是"先在脑内模拟推演,再落子"。 这种"行动前先思考"的思想,和今天大模型的"思维链(Chain-of-Thought)、推理时计算(test-time compute)"一脉相承。

3. 训练三部曲:先模仿人类,再自我对弈进化

最值得玩味的是 AlphaGo 的训练流程,它和今天的大模型训练惊人地相似:

第一步:监督学习  —— 喂给它几十万局人类高手的棋谱,先学会"像高手一样下"
                     (对应大模型的 SFT:模仿人类示范)
第二步:强化学习  —— 让它自己跟自己下千万局棋,用策略梯度强化"能赢的下法"
                     (对应大模型的 RL 微调:超越模仿,自我提升)

看出来了吗?"先模仿、再用 RL 超越模仿"——这条路线,正是后来 ChatGPT、MathGPT 走的路线。 AlphaGo 在 2016 年就把这个范式跑通了,只是当时跑在棋盘上,今天跑在语言上。

4. AlphaGo Zero:把人类老师也扔掉

2017 年的 AlphaGo Zero 更激进:它完全不看任何人类棋谱,从随机乱下开始,纯靠"自己跟自己下棋(self-play)"从零摸索,几天之内就碾压了击败李世石的初代 AlphaGo。后来的 AlphaZero 更把这套方法推广到国际象棋、将棋,通用得吓人。

这里藏着一个对今天至关重要的思想——自我对弈(self-play):AI 自己生成训练数据,自己跟自己博弈,自己变强,不再依赖人类标注。

请记住这个思想。因为当我们走到第六幕 GRPO 时会发现:让大模型对一道数学题自己生成一组答案、自己评判对错、自己强化正确的那个——这本质上就是 AlphaGo "自我对弈" 在语言模型上的回声。

小结这一幕:AlphaGo 是"游戏强化学习"的复杂度巅峰——它把价值、策略、树搜索、自我对弈缝合成一个系统,堪称工程艺术品。但它高度依赖"围棋有明确规则、能自动判胜负、状态完全可见"这些特性。当我们想把 RL 用到更开放、更主观的语言任务上时,需要一种既保留"自我生成、自我提升"精髓、又更轻量通用的方法。这就要先解决"如何稳定地做策略梯度"——下一幕的 PPO。

第五幕:工业级的策略梯度——PPO,与它的复杂代价

策略梯度还有个隐患:每次更新如果步子迈太大,策略可能突然"学崩",再也回不来。

2017 年 OpenAI 提出的 PPO(Proximal Policy Optimization,近端策略优化) 解决了这个问题。它的核心是给更新"上一道保险":每次策略只允许在旧策略附近小幅改动(通过一个 clip 裁剪机制),不准一步跳太远。PPO 稳定、好用,成了之后很多年的"默认选项"。

后来轰动世界的 ChatGPT,背后的 RLHF(基于人类反馈的强化学习) 用的就是 PPO。它的流程是:

1. 人类对模型的多个回答排序,标出"哪个更好";
2. 用这些偏好数据训练一个奖励模型(Reward Model),让它学会给回答打分;
3. 用 PPO,以奖励模型的打分作为奖励,去优化语言模型。

这套方法让 GPT 从"会续写"变成了"会帮忙、懂分寸"。但它又重又复杂:

• 要额外训练一个奖励模型;
• PPO 训练时,内存里要同时塞下四个模型(策略模型、参考模型、奖励模型、价值模型),显存吃紧;
• 工程链路长,调参困难。

这个"太重"的矛盾,催生了 2024 年的主角。

第六幕:2024,GRPO——把策略梯度做到极简,然后封神

DeepSeek 在训练其数学/推理模型时提出了 GRPO(Group Relative Policy Optimization,组相对策略优化)。它的洞察非常聪明:

在数学题、代码题这类"答案能自动判对错"的任务上,我们根本不需要训练一个奖励模型——对照标准答案,答对给 1 分、答错给 0 分就行了。也不需要单独的价值网络——让模型对同一道题生成一组(group)答案,用这组答案的平均分当基线就行了。

省掉了奖励模型,省掉了价值网络,PPO 那"四个模型"瘦身成基本上"一个模型"。这就是 GRPO "组相对"三个字的含义:优势不靠额外网络估计,而是靠"组内相对比较"算出来。

而这,正是我们 MathGPT 项目里跑的东西。看 train_rl.py 的核心,你会发现它干净得像教科书:

第一步:对同一道题,采样一组答案(Rollout)

# 对一道 GSM8K 数学题,生成 num_samples 个候选答案
seqs_batch, masks_batch = engine.generate_batch(
    tokens, num_samples=args.device_batch_size,
    max_tokens=args.max_new_tokens, temperature=args.temperature)

同一道题让模型答 8 遍、16 遍,有的对有的错——这"一组"就是 GRPO 里的 group。这一步,就是第四幕 AlphaGo "自我对弈"在语言模型上的回声:没有人给标准解题过程,模型自己生成一堆候选,自己跟自己博弈,从中分出高下。

第二步:用标准答案自动打分(无需奖励模型)

# 答对 reward=1.0,答错 reward=0.0,直接和标准答案比对
for sample_tokens in generated_seqs:
    generated_text = tokenizer.decode(sample_tokens[prefix_length:])
    rewards.append(train_task.reward(conversation, generated_text))

这就是 GRPO 在数学题上的精髓:奖励是规则算出来的,不是另一个网络猜出来的,干净、零成本、无偏差。

第三步:组内算优势(无需价值网络)

rewards    = torch.tensor(rewards, ...)
advantages = rewards - rewards.mean()   # 优势 = 自己的分 - 这一组的平均分

看到没?还是第三幕那个"优势 = 回报 - 平均回报"的式子。只不过这里的"平均"是"同一道题这一组答案的平均分"。一道题如果模型答 8 次对了 2 次,那这 2 个正确答案的优势为正(高于平均),会被鼓励;6 个错误答案优势为负,会被抑制。

第四步:策略梯度更新(还是那个 REINFORCE)

# 提高"高优势答案"被生成的概率,这就是策略梯度
logp   = -model(inputs, targets, loss_reduction='none').view_as(inputs)
pg_obj = (logp * advantages.unsqueeze(-1)).sum()
loss   = -pg_obj
loss.backward()

logp × advantage——这正是第三幕 REINFORCE 的更新公式!GRPO 本质上就是"带组内基线的 REINFORCE"。MathGPT 的实现是它最纯粹的形态:没有 KL 正则、没有 PPO 的 clip,采用 DAPO 风格的 token 级归一化,一条干净的策略梯度。

MathGPT 在 A800 上完成了从零预训练 → SFT → GRPO 的完整链路:一个约 700M 参数的小模型,经过 GRPO 在 GSM8K 上训练后,数学推理从"基本全错"提升到了能解出复杂应用题(Pass@1 约 14.75%)。模型甚至学会了在该算的地方调用计算器工具(<|python_start|>16*7<|python_end|>)做精确计算。

第七幕:为什么大模型时代,RL 突然又火了?

这里要补一个关键背景:为什么大语言模型需要 RL?光靠监督学习(SFT)不够吗?

大模型的训练通常是三步:

1. 预训练:在海量文本上学"预测下一个词",学会的是"像人一样说话",但不知道什么是"有用的回答"。
2. SFT(监督微调):用人写的优质问答示范,教模型"该怎么回答"。但 SFT 的本质是模仿——它只会复刻示范数据的模式,有个天花板:它无法"自我评价对错",对数学这种要求精确的任务尤其吃力(允许小概率蹦出一个错 token,答案就崩了)。
3. RL 微调:这就是 GRPO 登场的地方。它让模型自己生成、自己被打分、自己改进,突破了"只能模仿"的天花板。模型不再是背答案,而是真正学会了"什么样的推理路径更容易得到正确结果"。

这正好呼应了开头那只小鸟:Flappy Bird 没有"标准飞法"示范给小鸟看,数学题的"正确推理路径"也无法穷举地写给模型看。两者都只能靠"试错 + 奖励"自己摸索。 这就是 RL 不可替代的价值所在,也是它在大模型时代第二次爆发的根本原因。

DQN vs GRPO:同一个内核,不同的假设

讲到这里,我们把全文的两个主角拉到一起做个正面对比——这是理解强化学习最快的方式:它们的内核完全一样,区别只在于"对环境做了什么假设"。

先说"完全一样"的内核,一句话:

拿一个神经网络当大脑,让它去试;试出来好的(奖励高),就调参数让这种行为更容易发生;试出来差的,就让它更不容易发生。反复循环,网络就变强了。

DQN 和 GRPO 都在做这一件事,一个字不差。它们的差异,全部来自任务环境长得不一样,于是各自做了不同的简化假设:

读这张表的正确姿势是:从左往右看,你会发现没有一处是"GRPO 发明了全新原理",全都是"换了个假设、做了个适配"。

• 因为大模型动作太多(几万个词),没法像 DQN 那样"挑 Q 值最大的",所以走了策略路线;
• 因为数学题只有最后才知道对错,奖励天然稀疏,所以干脆"整段答完再打一个分";
• 因为没有现成的价值网络去降方差,所以用"同一道题的一组答案取平均"这个最省事的基线——这就是"组相对(Group Relative)"的由来。

一句话收束这张表:

DQN 是"动作少、奖励密、能精确比价值"时的最优解;GRPO 是"动作海量、奖励稀疏、只能整体打分"时的最优解。环境的假设变了,方法就跟着变——但底层那台"试错 + 奖励 + 调参"的发动机,从那只小鸟到大模型,一台都没换过。

理解了这张表,你就不会再把 DQN 和 GRPO 当成两个孤立的"黑话";它们是同一条河的上游和下游。

一张图看懂这条历史主线

心理学:试错与奖惩
        │
   贝尔曼方程(1950s) ── "价值 = 即时回报 + 未来价值的折扣"
        │
   Q-Learning(1989) ── 学 Q(状态,动作),但状态一多就爆炸
        │
   ┌────┴─────────────────────────────────┐
   │                                       │
基于价值(Value-based)                基于策略(Policy-based)
   │                                       │
 DQN(2013) ★Flappy Bird            REINFORCE(1992)
 用神经网络逼近 Q 表                 直接学策略,但方差大
 经验回放 + ε-greedy                     │
 擅长离散小动作空间                  +基线 → 优势 = 回报 - 平均
   │                                       │
   └───────────────┬───────────────────────┘
                   │  两条路合流
          AlphaGo(2016) ── 策略网络 + 价值网络 + 蒙特卡洛树搜索
                   │        "先模仿人类、再自我对弈超越"
          AlphaGo Zero(2017) ── 纯自我对弈(self-play),抛弃人类数据
                   │        ★ 自己生成数据、自己变强
                   │
             PPO(2017) ── clip 稳定更新
                   │
             RLHF(ChatGPT) ── PPO + 奖励模型,但太重(四个模型)
                   │
             GRPO(2024) ★MathGPT
               去掉奖励模型(规则打分)
               去掉价值网络(组内平均当基线)
               本质 = 带组内基线的 REINFORCE + 自我对弈精神

结语:同一团火,烧了两个时代

回到开头那两段代码。

那只学飞的像素小鸟(DQN),和那个学做数学题的大模型(GRPO),相隔十一年,处理的数据天差地别,但它们共享着完全相同的灵魂:

没有人手把手教每一步,只有一个最终的好坏信号;AI 通过一遍遍试错,自己把"什么行为能带来好结果"刻进了神经网络的权重里。

从贝尔曼方程到 Q-Learning,从 DQN 到策略梯度,从 AlphaGo 到 PPO/RLHF,再到 GRPO——六十年里,方法从简单到复杂、再回归极简,但每一次进化的逻辑都一样:前一个方法留下一个矛盾,后一个方法去解决它。

• 状态太多,Q 表存不下 → DQN 用神经网络逼近(2013,Flappy Bird);
• DQN 处理不了海量/连续动作 → 策略梯度直接学策略(REINFORCE);
• 价值与策略各有所长,围棋两者都要 → AlphaGo 合二为一 + 树搜索 + 自我对弈(2016);
• 策略梯度方差大、易学崩 → 优势基线 + PPO 裁剪(2017);
• 给语言模型对齐,但 RLHF 太重(四个模型) → GRPO 用规则打分 + 组内基线极致瘦身(2024)。

特别值得回味的是最后一步:GRPO 不是更复杂了,而是更简单了。 AlphaGo 把系统堆到了复杂度的顶峰,而 GRPO 把它精炼回一条干净的策略梯度——却继承了 AlphaGo 最珍贵的那个思想:让 AI 自己生成数据、自己评判、自己变强。 从围棋盘上的自我对弈,到数学题上的"一组答案里挑出对的强化它",是同一种智慧的两次绽放。

理解了这条主线,你就理解了今天 DeepSeek、OpenAI 们训练推理模型的核心引擎。而最好的理解方式,永远是亲手跑一遍:先让那只小鸟飞起来,再让大模型算对一道数学题。

两个项目,一条主线,一团从未熄灭的火。

本文基于两个开源实践项目写成: - Flappy Bird DQN:rl_games/flappy_bird_app(PyTorch 实现的经典深度 Q 网络) - MathGPT GRPO:从零预训练 → SFT → GRPO 的完整大模型强化学习链路(基于 nanochat)