GSM8K数学任务
定义
GSM8K(Grade School Math 8K)是一个小学水平数学应用题数据集,每道题由英文题目与一段含 <<表达式=结果>> 工具调用标注的解题过程组成,最终答案写在 #### 之后;nanochat 的 tasks/gsm8k.py 把它封装成 GSM8K 类,提供三种能力:把参考答案解析成「文本 + 工具调用 + 工具返回值」的分片列表、用 #### 后的数值做字符串精确匹配判分、以及把该判分直接当作强化学习的奖励。
符号约定如下。
| 符号 | 含义 |
|---|---|
题目文本,数据集字段 question | |
参考答案文本,数据集字段 answer,含 <<expr=result>> 与 #### 数值 | |
| 模型生成的回复文本,由采样 token 解码得到 | |
参考答案中 #### 后的数值字符串,extract_answer 的输出 | |
生成回复中 #### 后的数值字符串 | |
| 奖励,,取值 | |
一道题的总采样条数,run_gsm8k_eval 中等于 device_batch_size | |
| 这 条采样中答对的条数, | |
| pass@k 中的 ,要求 | |
参与评测的题目数,--eval-examples=400 | |
| 第 个目标 token 的掩码,1 表示参与损失 |
术语说明。分片(part)指 get_example 返回的 content 列表中的元素,类型为 text、python 或 python_output。工具调用指 <<表达式=结果>> 这一段标注:表达式由模型生成,结果由计算器或数据集给出。生成式评测(generative eval)指需要模型完整生成回复再做判分的评测方式,与只比较候选字母 logits 的 categorical 评测相对。精确匹配(exact match)指字符串相等,不做数值容差。稀疏奖励指整条轨迹只有终止时刻一个非零奖励。pass@k 指每题采样 条、取前 条时至少一条正确的概率,用题目集合上的比例估计。
本篇只讨论 nanochat 对该数据集的使用;数据格式在 SFT 中的编码见 多选与工具使用数据,奖励如何进入策略梯度见 GRPO原理与实现,评测方法论见 GSM8K与HumanEval。
为什么重要
GSM8K 是 nanochat 中唯一同时出现在三个训练阶段的数据集。SFT 阶段它以 4 个 epoch 的过采样进入混合数据,目的是让模型学会「先写推理、再调计算器、最后写 #### 数值」这一格式;RL 阶段它是唯一的训练任务与唯一的奖励来源;评测阶段它是 ChatCORE 的 5 个任务之一,也是唯一带 pass@k 报告的任务。三个阶段共用同一个 evaluate,因此格式、判分与训练信号三者严格一致。
没有 GSM8K,本阶段的强化学习没有可用奖励。nanochat 不训练奖励模型,也不使用人类偏好数据;若把任务换成开放对话,奖励只能由另一个模型给出,成本与风险都回到 RLHF 的框架内。数学题的可用性来自一个性质:判分是确定性的字符串比较,不需要标注者、不需要模型、不产生训练成本。
判分的口径直接决定训练信号的性质。extract_answer 只认 #### 之后的数字,因此模型只要在末尾写出正确的数字就能得 1 分,中间的推理是否正确不可观测。这一性质有两个后果:好消息是奖励不会被「看似合理但错误」的推理欺骗;坏消息是模型可能学会跳过推理、直接猜数或只写答案。理解这一点是理解 RL对模型的影响 中「奖励黑客」一节的前提。
在「懂原理 / 能复现 / 懂工程」三条主线中,本篇主要落在复现与工程:一条样本如何变成 token 与掩码、一个数字如何变成奖励、 条采样如何变成一个 pass@k 数。这些换算的每一步都可以用几行代码核对,也可以在日志里找到对应字段。
原理与推导
1 数据集、划分与加载
GSM8K 由 Cobbe 等人在 2021 年发布,论文描述为约 8.5K 道小学应用题。Hugging Face 上的 openai/gsm8k 有两个子集:main 为常规题目,socratic 为苏格拉底式分步提问版本;main 的训练集约 7.5K 行、测试集约 1.3K 行。nanochat 只用 main,tasks/gsm8k.py 的构造器对子集与划分都有断言:
assert subset in ["main", "socratic"], "GSM8K subset must be main|socratic"
assert split in ["train", "test"], "GSM8K split must be train|test"
self.ds = load_hub_dataset("openai/gsm8k", subset, split=split).shuffle(seed=42)
load_hub_dataset 通过 hub 的 parquet 导出接口下载分片并缓存到 ~/.cache/nanochat/task_data/,shuffle(seed=42) 用固定置换打乱行序。Task.__getitem__ 在此之上再做逻辑切片:physical_index = start + index * step,因此 GSM8K(..., start=0, stop=420) 取的是打乱后的前 420 行,而不是原始数据的前 420 行。chat_sft.py 用 stop=420 构造验证集,理由是让验证集规模与训练混合的比例大致对应。
三个脚本对该数据集的使用方式不同。
| 脚本 | 划分 | 规模 | 用途 |
|---|---|---|---|
chat_sft.py | main/train | 4 个 epoch | 教格式与工具调用 |
chat_sft.py | main/test(stop=420) | 420 行 | 验证损失 |
chat_rl.py | main/train | 约 7.5K 行,一轮 467 步 | rollout 与奖励 |
chat_rl.py | main/test | 400 行(--eval-examples) | pass@k |
chat_eval.py | main/test | 全部 | ChatCORE 的 GSM8K 分量 |
GSM8K.eval_type 返回 'generative',因此 chat_eval.py 走 run_generative_eval 分支:逐题生成、解码、判分。ARC 与 MMLU 返回 'categorical',走只比较候选字母 logits 的分支。两者不能混用同一个评测循环。
2 答案格式与 #### 约定
一条 GSM8K 样本的 answer 字段形如
Weng earns 12/60 = $<<12/60=0.2>>0.2 per minute.
Working 50 minutes, she earned 0.2 x 50 = $<<0.2*50=10>>10.
#### 10
判分需要两件事:从参考答案中取出 10,从生成文本中取出 10。tasks/gsm8k.py 用一条正则完成:
GSM_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
def extract_answer(completion):
match = GSM_RE.search(completion)
if match:
match_str = match.group(1).strip()
match_str = match_str.replace(",", "")
return match_str
return None
逐项说明。#### 后必须有一个空格;\-? 允许负号;[0-9\.\,]+ 允许小数点与千位逗号;search 只取第一个匹配,因此回复中若出现多次 #### 以第一次为准;strip 去掉首尾空白;replace(",", "") 把 1,000 归一化为 1000。未匹配时返回 None,而不是空串或 0。
.strip() 的实际作用需要单独说明。字符类 [0-9\.\,] 不含任何空白,因此 group(1) 的两端不可能出现空白,.strip() 在这条正则下恒为空操作;它保留自官方实现,用于防御正则被改写后可能出现的首尾空白。真正需要注意的是分隔符的严格性:#### 后必须恰好一个空格,#### 10(两个空格)不匹配,extract_answer 返回 None,该条奖励为 0。这是模型输出中真实存在的格式,也是判分对空白敏感的唯一点。
归一化只做格式,不做数值。10.0 与 10 是两个不同的字符串,判为不等;1,000 与 1000 相等,因为逗号被删除;010 与 10 不等。这一选择与官方评分脚本一致,tasks/gsm8k.py 的 docstring 给出了对应的官方链接。
3 <<expr=result>> 的工具调用编码
get_example 把参考答案解析成分片列表。核心是一次带捕获组的拆分:
parts = re.split(r'(<<[^>]+>>)', answer)
for part in parts:
if part.startswith('<<') and part.endswith('>>'):
inner = part[2:-2]
if '=' in inner:
expr, result = inner.rsplit('=', 1)
else:
expr, result = inner, ""
assistant_message_parts.append({"type": "python", "text": expr})
assistant_message_parts.append({"type": "python_output", "text": result})
else:
assistant_message_parts.append({"type": "text", "text": part})
三个细节决定结果。第一,正则必须带括号:re.split 在无捕获组时丢弃分隔符,有捕获组时把分隔符按奇偶位置插入结果列表。去掉括号,<<12/60=0.2>> 会从分片列表中消失,表达式与结果都不会被编码,工具调用格式在训练数据中被静默删除。第二,[^>]+ 不允许内容含 >,因此表达式里不能出现比较运算;这是数据集本身的性质,不是通用解析器。第三,用 rsplit('=', 1) 而不是 split:只在最后一个等号处切分,表达式内部若含等号(例如链式赋值)仍能保留在 expr 一侧。
对上面的样本,拆分结果为 5 段:三段文本与两个工具标注。每个工具标注展开成 python 与 python_output 两个分片,故 content 列表共 项。渲染时每个工具标注占 6 个条目(python_start、表达式、python_end、output_start、结果、output_end),三段文本各占 1 个条目,共 个条目。
掩码在 render_conversation 中确定,规则与 SFT 阶段完全一致:
| 分片 | 渲染内容 | 掩码 | 理由 |
|---|---|---|---|
text(助手侧) | 文本本身 | 1 | 模型必须生成 |
python | 调用起始符 + 表达式 + 调用结束符 | 1 | 模型必须发起调用并写出表达式 |
python_output | 输出起始符 + 结果 + 输出结束符 | 0 | 结果由运行时产生,不是策略的动作 |
| 用户消息 | 用户起始符 + 题目 + 用户结束符 | 0 | 条件项 |
| 边界 | BOS 与助手起始符 | 0 | 由拼接代码注入 |
| 结束 | 助手结束符 | 1 | 模型必须学会停止 |
表中的「调用起始符」等指 python_start、python_end、output_start、output_end、user_start、user_end、assistant_start、assistant_end 这 8 个特殊 token,它们在词表中的位置与名称见 词表与特殊token。
python_output 的文本直接取自数据集,nanochat 不在训练时重新执行表达式。真正执行发生在推理与 RL 采样阶段:nanochat/engine.py 在检测到 <|python_end|> 后调用 use_calculator(expr),用 eval 在受限字符集与 3 秒超时下求值,再把结果强制注入。因此训练数据里的 result 与实际运行时的计算结果可能不一致(例如浮点格式差异),但掩码为 0 意味着模型不会被训练去复现它。
4 render_for_completion:把对话变成提示
RL 与 pass@k 评测都需要「以助手开头结尾的前缀」。nanochat/tokenizer.py 的 render_for_completion 做两步:
conversation = copy.deepcopy(conversation)
messages = conversation["messages"]
assert messages[-1]["role"] == "assistant"
messages.pop() # 删掉最后一条助手消息
ids, mask = self.render_conversation(conversation)
ids.append(self.encode_special("<|assistant_start|>"))
return ids
第一步删掉参考答案,第二步补上 <|assistant_start|>。返回的只有 ids,不返回 mask:RL 不需要「参考答案的掩码」,它需要的是「自己采样出的 token 的掩码」,后者由 Engine.generate_batch 在采样时逐 token 产生。chat_rl.py 记录 prefix_length = len(tokens),之后从 generate_batch 返回的完整序列中切掉前 prefix_length 个 token,剩下的就是生成部分。
这一步保证了训练与推理的分布对齐:模型看到的前缀与 chat_cli 中用户提问后的前缀完全相同,只是末尾没有终止符。若忘记删除参考答案,模型看到的前缀里已经含正确答案,采样退化为复述,奖励恒为 1,组内优势恒为 0。
5 evaluate 与 reward 的关系
两个方法只差一个类型转换:
def evaluate(self, conversation, assistant_response):
assistant_message = conversation['messages'][-1]
last_text_part = assistant_message['content'][-1]['text']
ref_num = extract_answer(last_text_part)
pred_num = extract_answer(assistant_response)
return int(pred_num == ref_num)
def reward(self, conversation, assistant_response):
is_correct = self.evaluate(conversation, assistant_response)
return float(is_correct)
evaluate 返回 int(0 或 1),reward 返回 float(0.0 或 1.0)。复用而不是重写,是一个有意的设计决定:训练奖励与评测判分若各写一份,任何一处改动都会让「训练时优化 1 分」与「评测时算 1 分」脱钩,而这种不一致在曲线上表现为「奖励上升、评测不变」。reward 的 docstring 也预留了扩展空间:「Later this could be made more complex (e.g. format matching etc.)」。
参考值的取法有一处隐含假设。代码取 assistant_message['content'][-1]['text'],即最后一个分片的 text 字段;三种分片都带该字段,因此不会报错,但只有在最后一段是 text 时,该字段才包含 #### 行。GSM8K 的所有答案都以 .\n#### 数值 结尾,因此该假设成立。若某条数据的最后一个分片是 python_output,extract_answer 会在计算结果文本上工作并很可能返回 None;此时若生成回复也没有 ####,两侧都是 None,int(None == None) 为 1,奖励被误判为正确。这是 int(pred == ref) 与 None 语义共同造成的边界情形。
6 为什么数学题适合强化学习
四个性质使 GSM8K 成为本阶段唯一可用的任务。
第一,判分廉价且确定。判分只需一次正则匹配与一次字符串比较,成本与模型规模无关;同样的判分可以跑 400 题 × 8 条采样而不产生额外开销。RLHF 的奖励模型则要对每条回复做一次前向。
第二,奖励无参数,因而没有「奖励模型被过优化」这一层风险。奖励函数本身可能设计得不好(例如只看答案),但它不会随策略变化而漂移,也不会在训练分布外给出外推值。这使 GRPO 在本场景下少了一个不稳定来源。
第三,难度可度量。答对率 可以从采样直接估计,而 决定组内优势是否为零(见 GRPO原理与实现 第 10 节)。这给出一个可操作的训练前置条件:。
第四,任务有唯一正确答案,因此「正确」不依赖评判者。这与开放对话的评测形成对照,也是 评测方法论 中把 GSM8K 归入可自动判分类的依据。
代价同样明确。奖励只看结果,因此过程正确性不可观测;模型可以通过猜数、只写答案、伪造工具调用等方式获得奖励。这些行为在奖励上无法与真正解题区分,只能靠人工抽检与格式统计发现。
7 pass@k 的定义与计算
设一道题采样 条回复,其中 条正确。pass@k 定义为:从这 条中取 条(不放回),至少一条正确的概率。当 条采样可交换时,该概率只依赖 、、:
推导: 条全错的取法有 种,总取法 种,两者之比是全错概率。当 时约定该组合数为 0,pass@k 为 1。
chat_rl.py 的实现不走组合数,而是直接对前 条取样:
for k in range(1, args.device_batch_size + 1):
passk[k - 1] = sum(any(o["is_correct"] for o in r["outcomes"][:k]) for r in records)
outcomes 是同一题 条采样的判分列表,顺序即生成顺序。固定 时,「前 条中至少一条正确」的概率恰好等于上式(超几何分布),因此前缀指示的平均值是 pass@k 的样本估计,与组合数公式同期望。区别只在方差:组合数公式直接用 ,前缀法只看前 条,后者在 时略多噪声。
表 1 给出 时的数值。
表 1 pass@k()
| 1 | 0.1250 | 0.2500 | 0.5000 | 1.0000 |
| 2 | 0.2500 | 0.4643 | 0.7857 | 1.0000 |
| 3 | 0.3750 | 0.6429 | 0.9286 | 1.0000 |
| 4 | 0.5000 | 0.7857 | 0.9857 | 1.0000 |
| 8 | 1.0000 | 1.0000 | 1.0000 | 1.0000 |
三条性质可直接读出。第一,pass@k 对 单调不减: 增大只会增加「至少一条正确」的机会。第二,pass@n 等于「这题是否被解出至少一次」,即 ,因此它度量的是覆盖率而不是稳定率。第三, 时 pass@1 等于 ,即单条采样的平均正确率。
在 nanochat 中读取这三个数要注意三处口径差异。其一,chat_rl.py 的 pass@k 用 temperature=1.0 采样, 是采样准确率而不是贪心准确率;chat_eval.py 默认 temperature=0.0 且 num_samples=1,报告的是贪心准确率。两者不可直接比较,通常贪心更高。其二,chat_eval.py 的 run_generative_eval 用 passed = any(outcomes) 汇总,若传入 -n 4,它报的是 pass@4 而不是 pass@1。其三,pass@k 的 上限是 device_batch_size(默认 8),因为评测复用同一个 generate_batch 调用,且 run_gsm8k_eval 里有 assert num_samples <= args.device_batch_size。
8 一条样本的完整 token 与奖励流程
以第 2 节的样本为例, 为提示长度, 为生成长度。流程如下。
[1] conversation = train_task[example_idx]
messages = [user: 题目, assistant: [text, python, python_output, text, python, python_output, text]]
[2] tokens = render_for_completion(conversation)
删除 assistant 消息,渲染后追加 <|assistant_start|>,得到长度 T_prompt 的 id 列表
[3] generated, masks = engine.generate_batch(tokens, num_samples=8, max_tokens=256,
temperature=1.0, top_k=50)
返回长度 T_prompt + T_gen 的 id 列表与等长掩码;终止符 <|assistant_end|> 被丢弃
[4] text = tokenizer.decode(generated[0][T_prompt:])
masks 中提示段全为 0;采样文本与表达式为 1;<|output_start|> 与结果为 0
[5] reward = train_task.reward(conversation, text)
extract_answer(text) 与 extract_answer(参考答案最后一个分片) 比较
[6] 16 条采样得到 16 个 0/1;advantages = rewards - mean(rewards)
[7] pad 到 max_length(补 <|assistant_end|>,掩码 0);targets[mask=0] = -1
[8] logp = -model(inputs, targets, loss_reduction='none');pg_obj = (logp * A).sum() / num_valid
第 3 步的掩码有三个来源,必须分别核对。提示段由 generate_batch 初始化为 0;采样 token 由 generate 在每个解码步按「是否来自 forced_tokens 队列」赋 1 或 0;pad 段由 get_batch 补 0。第 7 步的 pad 使用 <|assistant_end|> 作为填充值,代码注释说明这是「only for padding and isn't used in the loss」,因为对应的掩码为 0、targets 被置为 。
第 3 步还有一个容易忽略的后果:generate_batch 丢弃终止 token,因此 <|assistant_end|> 不会出现在 RL 的 targets 中。SFT 阶段它是被监督的(掩码 1),RL 阶段它不产生梯度。这意味着 RL 只能强化「答案内容」,不能强化「在该停时停」;停止行为完全由 SFT 决定。若 SFT 模型不会停,RL 会在 256 token 处被截断,截断文本仍可能包含 ####,于是奖励照常给出。
9 在 nanochat 中的落地
| 位置 | 语句 | 作用 | 去掉会怎样 |
|---|---|---|---|
tasks/gsm8k.py | load_hub_dataset("openai/gsm8k", subset, split=split) | 下载并缓存 parquet | 无数据 |
| 同上 | .shuffle(seed=42) | 固定行序 | 每次运行的题目顺序不同,pass@k 不可复现 |
| 同上 | re.split(r'(<<[^>]+>>)', answer) | 拆出工具标注 | 工具调用格式从训练数据中消失 |
| 同上 | rsplit('=', 1) | 分隔表达式与结果 | 表达式含等号时被切错 |
| 同上 | GSM_RE.search | 取 #### 后的数值 | 无法判分 |
| 同上 | replace(",", "") | 千位逗号归一化 | 1,000 类答案全部判错 |
| 同上 | evaluate / reward | 判分与奖励 | RL 无信号 |
tokenizer.py | render_for_completion | 构造以助手开头结尾的提示 | 参考答案泄漏进提示 |
engine.py | generate_batch | 并行采样并返回掩码 | 无 rollout |
engine.py | use_calculator | 执行表达式并强制注入结果 | 工具调用变成纯文本,结果不可信 |
chat_rl.py | run_gsm8k_eval | 400 题 × 8 条的 pass@k | 无法观察训练效果 |
chat_eval.py | GSM8K(subset="main", split="test") | ChatCORE 的数学分量 | 成绩单少一项 |
关键直觉
GSM8K 的奖励只传递一个比特:最后一个数字是否与参考相等。因此 RL 优化的对象是「最终数值的命中率」,不是「推理的正确性」;推理过程只是模型自行选择的手段,奖励函数对它完全不可见。这一性质与定义一致:, 由
####后的字符串给出,中间 token 不进入 。由此可以推出两个可检验的预测。其一,若模型能以非零概率猜中答案,那么「只写答案、不写推理」在奖励上与完整解答等价,而前者的 token 数更少,因此在策略梯度下会被优先强化(短序列在 token 级归一化下权重较低,但单条概率上升更快)。其二,若模型完全不会做某题,奖励恒为 0,组内优势恒为 0,该题对训练没有贡献;RL 只在「已经能以非零概率做对」的题目上起作用。这两个预测分别对应 RL对模型的影响 中的奖励黑客与能力边界两节。
例子与代码
第一段复刻 get_example 的分片逻辑并核对判分,不依赖 nanochat 环境。
"""GSM8K 的分片、渲染条目与奖励(与 tasks/gsm8k.py 等价)。"""
import re
answer = ("Weng earns 12/60 = $<<12/60=0.2>>0.2 per minute.\n"
"Working 50 minutes, she earned 0.2 x 50 = $<<0.2*50=10>>10.\n"
"#### 10")
parts = re.split(r'(<<[^>]+>>)', answer)
items = []
for part in parts:
if part.startswith('<<') and part.endswith('>>'):
inner = part[2:-2]
expr, result = inner.rsplit('=', 1) if '=' in inner else (inner, "")
items += [("python", expr), ("python_output", result)]
else:
items.append(("text", part))
rendered = []
for kind, text in items:
if kind == "text":
rendered.append((text, 1))
elif kind == "python":
rendered += [("<|python_start|>", 1), (text, 1), ("<|python_end|>", 1)]
else:
rendered += [("<|output_start|>", 0), (text, 0), ("<|output_end|>", 0)]
print("分片数", len(parts), "内容项", len(items), "渲染条目", len(rendered))
print("监督条目", sum(m for _, m in rendered))
GSM_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
def extract(s):
m = GSM_RE.search(s)
return m.group(1).strip().replace(",", "") if m else None
ref = extract(items[-1][1])
print("ref", ref)
for completion in ["... #### 10", "... #### 10.0", "... #### 1,000", "最终答案是 10"]:
pred = extract(completion)
print(f"{completion!r} -> pred {pred} reward {int(pred == ref)}")
预期输出如下。
分片数 5 内容项 7 渲染条目 15
监督条目 9
ref 10
'... #### 10' -> pred 10 reward 1
'... #### 10.0' -> pred 10.0 reward 0
'... #### 1,000' -> pred 1000 reward 0
'最终答案是 10' -> pred None reward 0
这段代码在做什么:re.split 的捕获组把两个 <<...>> 保留在结果中,循环把它们拆成 python 与 python_output 两个内容项;渲染时按掩码表展开成 15 个条目,其中 9 个掩码为 1;最后在四个补全上调用 extract 并与参考值比较。
为什么这样看:内容项 7 与 渲染条目 15 的差来自工具标注的展开(每个 2 项变 6 条目);监督条目 9 由三段文本加两组「起止符 + 表达式」构成,恰好排除了所有 python_output 条目。第三、四行说明判分是字符串比较:10.0 与 1,000 都判错,后者是因为逗号删除后变成 1000 而非 10。把 answer 中 rsplit 改为 split 在本例不改变结果,但对含多个等号的表达式会切错。
第二段核对 pass@k 的两种算法与 的单调性。
"""pass@k:组合数公式与前缀指示在同一组采样上的取值。"""
from math import comb
n = 8
for c in (1, 2, 4):
row = []
for k in (1, 2, 4, 8):
p = 1.0 if n - c < k else 1.0 - comb(n - c, k) / comb(n, k)
row.append(f"k={k}:{p:.4f}")
print(f"c={c}", " ".join(row))
outcomes = [[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1]]
for k in (1, 2, 4, 8):
vals = [any(o[:k]) for o in outcomes]
print(f"prefix k={k} pass@k={sum(vals) / len(vals):.4f}")
预期输出如下。
c=1 k=1:0.1250 k=2:0.2500 k=4:0.5000 k=8:1.0000
c=2 k=1:0.2500 k=2:0.4643 k=4:0.7857 k=8:1.0000
c=4 k=1:0.5000 k=2:0.7857 k=4:0.9857 k=8:1.0000
prefix k=1 pass@k=0.0000
prefix k=2 pass@k=0.3333
prefix k=4 pass@k=0.3333
prefix k=8 pass@k=0.6667
这段代码在做什么:上半部分用组合数公式计算 时不同 与 的 pass@k;下半部分给定三条采样的判分序列,用前缀指示重复 chat_rl.py 的计算。
为什么这样看:第一行 时 给出 ,与「单条采样命中率」一致; 时任何非零 都给出 1。下半部分的结果不是单调的等步长上升( 与 都是 ),因为第二条采样的正确项在第 8 位, 之前看不到;这正是 pass@k 依赖采样顺序的原因——前缀法只用前 条,而组合数公式使用全部 。
第三段是运行入口与评测命令。
# RL 训练期间的 pass@k 由脚本内置,无需单独命令
torchrun --standalone --nproc_per_node=8 -m scripts.chat_rl -- --run=rl-d24
# 训练结束后对 RL 检查点做 5 任务评测(含 GSM8K 与 ChatCORE)
python -m scripts.chat_eval -i rl -a GSM8K
python -m scripts.chat_eval -i rl
# 若要复现 greedy pass@1,显式指定温度为 0、采样数为 1
python -m scripts.chat_eval -i rl -a GSM8K -t 0.0 -n 1
易错点
以下六条均可在判分结果、训练日志或张量检查中定位。
1. 把
10.0当作10。extract_answer只做字符串比较,没有数值容差;模型输出10.0时奖励为 0。若改成float比较,训练奖励与官方评测口径同时改变,必须在两处一起改。2. 两侧都为
None时判为正确。int(None == None)为 1;当参考答案的最后一个分片不是text、或生成文本完全没有####时,可能出现两侧都没有匹配到数值而奖励为 1 的情形。3. 用
re.split时丢掉捕获组。re.split(r'<<[^>]+>>', answer)会把工具标注从结果中删除,训练数据退化为纯文本,模型学不会发起调用;症状是 SFT 损失正常下降而工具调用率接近零。4. 用
split('=')而不是rsplit('=', 1)。表达式含多个等号时(数据集中的链式写法),split会切出多于两段,expr, result = ...直接抛ValueError,或在解包为两段时截断。5. 忘记
render_for_completion会删除最后一条助手消息。若直接用render_conversation构造提示,参考答案被编码进前缀,采样退化为复现,奖励恒为 1,优势恒为 0,训练完全不动而日志显示「奖励 1.0」。6. 把
chat_eval的-n当成 pass@1 的重复次数。run_generative_eval用any(outcomes)汇总,-n 4报的是 pass@4;-t默认 0.0,与chat_rl.py评测时的temperature=1.0也不同。7. 用
stop=420的验证切片当作 RL 评测集。chat_rl.py的val_task是完整的main/test,max_examples=400只是从中取前 400 行;两者题目集合不同,数值不可直接对比。
关联笔记
- 前置 多选与工具使用数据:
render_mc、GSM8K 分片与掩码表在该篇首次出现,本篇只补充get_example的实现细节与判分口径。 - 前置 有监督微调SFT:GSM8K 以 4 个 epoch 进入 SFT 混合数据,决定初始答对率是否越过 GRPO 的信号门限。
- 后续 GRPO原理与实现:奖励函数 在该篇被代入策略梯度,掩码、归一化与退化条件都在那里展开。
- 后续 RL对模型的影响:只看答案的奖励如何导致「跳过推理」「只写答案」等行为,在该篇讨论。
- 后续 GSM8K与HumanEval:08 阶段评测方法论的展开,包含执行沙箱与生成式评测的统计口径。
- 跨库 模型评估矩阵:pass@k 与其他生成式指标的关系,以及指标选择的一般框架。
达标检测
- [ ] 写出
GSM_RE并说明\-?、[0-9\.\,]+、search与replace(",", "")各自的作用。 - [ ] 手算样本答案的分片数、内容项数与渲染条目数,并列出 9 个监督条目。
- [ ] 解释
re.split为什么必须带捕获组,去掉后的症状是什么。 - [ ] 说明
render_for_completion的两步操作,以及不删除助手消息的后果。 - [ ] 写出 pass@k 的组合数公式并证明它等于超几何概率;说明前缀法与它的关系。
- [ ] 用表 1 验证 、 时 pass@k 为 ,并解释为什么 与 可能相同。
- [ ] 画出第 8 节的八步流程,标出每一步中掩码的取值来源。
- [ ] 运行第一段代码,把
rsplit('=', 1)改成split('=')并在表达式中加入a=b=1,观察会发生什么。 - [ ] 说明
chat_eval -i rl -a GSM8K与chat_rl.py内部 pass@k 的三个口径差异。
参考来源
- Karpathy, nanochat(commit 92d63d4),
tasks/gsm8k.py、nanochat/tokenizer.py、nanochat/engine.py、scripts/chat_rl.py、scripts/chat_eval.py、scripts/chat_sft.py—— 对应全部实现细节、数据集规模注释(8K rows per epoch、1.32K rows in test set)与 pass@k 计算。 - Cobbe et al., "Training Verifiers to Solve Math Word Problems", arXiv:2110.14168, 2021 —— 对应第 1 节的数据集来源与规模、第 2 节的
####答案格式。 - Shao et al., "DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models", arXiv:2402.03300, 2024 —— 对应第 6 节的「规则奖励用于数学任务」这一选择的先例与理由。
- DeepSeek-AI, "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning", arXiv:2501.12948, 2025 —— 对应第 6 节与第 7 节:以答案正确性为规则奖励、用 pass@k 与采样准确率联合刻画能力。
- Yu et al., "DAPO: An Open-Source LLM Reinforcement Learning System at Scale", arXiv:2503.14476, 2025 —— 对应第 8 节关于长度上限与长回复奖励塑形的讨论背景。
- Hendrycks et al., "Measuring Massive Multitask Language Understanding", arXiv:2009.03300, 2021 —— 对应第 1 节 categorical 与 generative 两类评测的对照。