---
tags: [nanochat, rl, gsm8k]
阶段: 07-强化学习对齐RL
难度: ★★☆
created: 2026-10-22
related: "[[GRPO原理与实现]], [[多选与工具使用数据]], [[RL对模型的影响]], [[GSM8K与HumanEval]]"
---

# GSM8K数学任务

## 定义

**GSM8K**（Grade School Math 8K）是一个小学水平数学应用题数据集，每道题由英文题目与一段含 `<<表达式=结果>>` 工具调用标注的解题过程组成，最终答案写在 `####` 之后；nanochat 的 `tasks/gsm8k.py` 把它封装成 `GSM8K` 类，提供三种能力：把参考答案解析成「文本 + 工具调用 + 工具返回值」的分片列表、用 `####` 后的数值做字符串精确匹配判分、以及把该判分直接当作强化学习的奖励。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $x$ | 题目文本，数据集字段 `question` |
| $a$ | 参考答案文本，数据集字段 `answer`，含 `<<expr=result>>` 与 `#### 数值` |
| $\hat y$ | 模型生成的回复文本，由采样 token 解码得到 |
| $\mathrm{ref}$ | 参考答案中 `####` 后的数值字符串，`extract_answer` 的输出 |
| $\mathrm{pred}$ | 生成回复中 `####` 后的数值字符串 |
| $R$ | 奖励，$R=\mathbf 1[\mathrm{pred}=\mathrm{ref}]$，取值 $\{0,1\}$ |
| $n$ | 一道题的总采样条数，`run_gsm8k_eval` 中等于 `device_batch_size` |
| $c$ | 这 $n$ 条采样中答对的条数，$0\le c\le n$ |
| $k$ | pass@k 中的 $k$，要求 $1\le k\le n$ |
| $N$ | 参与评测的题目数，`--eval-examples=400` |
| $m_t$ | 第 $t$ 个目标 token 的掩码，1 表示参与损失 |

术语说明。**分片**（part）指 `get_example` 返回的 `content` 列表中的元素，类型为 `text`、`python` 或 `python_output`。**工具调用**指 `<<表达式=结果>>` 这一段标注：表达式由模型生成，结果由计算器或数据集给出。**生成式评测**（generative eval）指需要模型完整生成回复再做判分的评测方式，与只比较候选字母 logits 的 categorical 评测相对。**精确匹配**（exact match）指字符串相等，不做数值容差。**稀疏奖励**指整条轨迹只有终止时刻一个非零奖励。**pass@k** 指每题采样 $n$ 条、取前 $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 与掩码、一个数字如何变成奖励、$k$ 条采样如何变成一个 pass@k 数。这些换算的每一步都可以用几行代码核对，也可以在日志里找到对应字段。

## 原理与推导

### 1 数据集、划分与加载

GSM8K 由 Cobbe 等人在 2021 年发布，论文描述为约 8.5K 道小学应用题。Hugging Face 上的 `openai/gsm8k` 有两个子集：`main` 为常规题目，`socratic` 为苏格拉底式分步提问版本；`main` 的训练集约 7.5K 行、测试集约 1.3K 行。nanochat 只用 `main`，`tasks/gsm8k.py` 的构造器对子集与划分都有断言：

```python
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` 字段形如

```text
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` 用一条正则完成：

```python
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` 把参考答案解析成分片列表。核心是一次带捕获组的拆分：

```python
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` 列表共 $3+2\times2=7$ 项。渲染时每个工具标注占 6 个条目（`python_start`、表达式、`python_end`、`output_start`、结果、`output_end`），三段文本各占 1 个条目，共 $3+2\times6=15$ 个条目。

掩码在 `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` 做两步：

```python
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` 的关系

两个方法只差一个类型转换：

```python
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 在本场景下少了一个不稳定来源。

第三，难度可度量。答对率 $p$ 可以从采样直接估计，而 $p$ 决定组内优势是否为零（见 [[GRPO原理与实现]] 第 10 节）。这给出一个可操作的训练前置条件：$Gp\gtrsim1$。

第四，任务有唯一正确答案，因此「正确」不依赖评判者。这与开放对话的评测形成对照，也是 [[评测方法论]] 中把 GSM8K 归入可自动判分类的依据。

代价同样明确。奖励只看结果，因此过程正确性不可观测；模型可以通过猜数、只写答案、伪造工具调用等方式获得奖励。这些行为在奖励上无法与真正解题区分，只能靠人工抽检与格式统计发现。

### 7 pass@k 的定义与计算

设一道题采样 $n$ 条回复，其中 $c$ 条正确。**pass@k** 定义为：从这 $n$ 条中取 $k$ 条（不放回），至少一条正确的概率。当 $n$ 条采样可交换时，该概率只依赖 $n$、$c$、$k$：

$$
\mathrm{pass@}k=1-\frac{\binom{n-c}{k}}{\binom{n}{k}}.
$$

推导：$k$ 条全错的取法有 $\binom{n-c}{k}$ 种，总取法 $\binom{n}{k}$ 种，两者之比是全错概率。当 $n-c<k$ 时约定该组合数为 0，pass@k 为 1。

`chat_rl.py` 的实现不走组合数，而是直接对前 $k$ 条取样：

```python
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` 是同一题 $n$ 条采样的判分列表，顺序即生成顺序。固定 $c$ 时，「前 $k$ 条中至少一条正确」的概率恰好等于上式（超几何分布），因此前缀指示的平均值是 pass@k 的样本估计，与组合数公式同期望。区别只在方差：组合数公式直接用 $c$，前缀法只看前 $k$ 条，后者在 $k\ll n$ 时略多噪声。

表 1 给出 $n=8$ 时的数值。

表 1 pass@k（$n=8$）

| $c$ | $k=1$ | $k=2$ | $k=4$ | $k=8$ |
|---|---|---|---|---|
| 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 对 $k$ 单调不减：$k$ 增大只会增加「至少一条正确」的机会。第二，pass@n 等于「这题是否被解出至少一次」，即 $c>0$，因此它度量的是覆盖率而不是稳定率。第三，$k=1$ 时 pass@1 等于 $c/n$，即单条采样的平均正确率。

在 nanochat 中读取这三个数要注意三处口径差异。其一，`chat_rl.py` 的 pass@k 用 `temperature=1.0` 采样，$k=1$ 是采样准确率而不是贪心准确率；`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 的 $k$ 上限是 `device_batch_size`（默认 8），因为评测复用同一个 `generate_batch` 调用，且 `run_gsm8k_eval` 里有 `assert num_samples <= args.device_batch_size`。

### 8 一条样本的完整 token 与奖励流程

以第 2 节的样本为例，$T_{\text{prompt}}$ 为提示长度，$T_{\text{gen}}$ 为生成长度。流程如下。

```text
[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` 被置为 $-1$。

第 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 的数学分量 | 成绩单少一项 |

## 关键直觉

> [!tip] GSM8K 的奖励只传递一个比特：最后一个数字是否与参考相等。因此 RL 优化的对象是「最终数值的命中率」，不是「推理的正确性」；推理过程只是模型自行选择的手段，奖励函数对它完全不可见。这一性质与定义一致：$R=\mathbf 1[\mathrm{pred}=\mathrm{ref}]$，$\mathrm{pred}$ 由 `####` 后的字符串给出，中间 token 不进入 $R$。
>
> 由此可以推出两个可检验的预测。其一，若模型能以非零概率猜中答案，那么「只写答案、不写推理」在奖励上与完整解答等价，而前者的 token 数更少，因此在策略梯度下会被优先强化（短序列在 token 级归一化下权重较低，但单条概率上升更快）。其二，若模型完全不会做某题，奖励恒为 0，组内优势恒为 0，该题对训练没有贡献；RL 只在「已经能以非零概率做对」的题目上起作用。这两个预测分别对应 [[RL对模型的影响]] 中的奖励黑客与能力边界两节。

## 例子与代码

第一段复刻 `get_example` 的分片逻辑并核对判分，不依赖 nanochat 环境。

```python
"""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)}")
```

预期输出如下。

```text
分片数 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 的两种算法与 $k$ 的单调性。

```python
"""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}")
```

预期输出如下。

```text
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
```

这段代码在做什么：上半部分用组合数公式计算 $n=8$ 时不同 $c$ 与 $k$ 的 pass@k；下半部分给定三条采样的判分序列，用前缀指示重复 `chat_rl.py` 的计算。

为什么这样看：第一行 $c=1$ 时 $k=1$ 给出 $1/8$，与「单条采样命中率」一致；$k=8$ 时任何非零 $c$ 都给出 1。下半部分的结果不是单调的等步长上升（$k=2$ 与 $k=4$ 都是 $1/3$），因为第二条采样的正确项在第 8 位，$k=4$ 之前看不到；这正是 pass@k 依赖采样顺序的原因——前缀法只用前 $k$ 条，而组合数公式使用全部 $c$。

第三段是运行入口与评测命令。

```bash
# 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
```

## 易错点

> [!warning] 以下六条均可在判分结果、训练日志或张量检查中定位。
> 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原理与实现]]：奖励函数 $R$ 在该篇被代入策略梯度，掩码、归一化与退化条件都在那里展开。
- 后续 [[RL对模型的影响]]：只看答案的奖励如何导致「跳过推理」「只写答案」等行为，在该篇讨论。
- 后续 [[GSM8K与HumanEval]]：08 阶段评测方法论的展开，包含执行沙箱与生成式评测的统计口径。
- 跨库 [[模型评估矩阵]]：pass@k 与其他生成式指标的关系，以及指标选择的一般框架。

## 达标检测

- [ ] 写出 `GSM_RE` 并说明 `\-?`、`[0-9\.\,]+`、`search` 与 `replace(",", "")` 各自的作用。
- [ ] 手算样本答案的分片数、内容项数与渲染条目数，并列出 9 个监督条目。
- [ ] 解释 `re.split` 为什么必须带捕获组，去掉后的症状是什么。
- [ ] 说明 `render_for_completion` 的两步操作，以及不删除助手消息的后果。
- [ ] 写出 pass@k 的组合数公式并证明它等于超几何概率；说明前缀法与它的关系。
- [ ] 用表 1 验证 $c=2$、$k=2$ 时 pass@k 为 $0.4643$，并解释为什么 $k=2$ 与 $k=4$ 可能相同。
- [ ] 画出第 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 两类评测的对照。
