---
tags: [nanochat, sft, 多选数据]
阶段: 06-中段训练与SFT
难度: ★★☆
created: 2026-10-22
related: "[[对话数据与SmolTalk]], [[有监督微调SFT]], [[指令微调SFT]]"
---

# 多选与工具使用数据

## 定义

**多选数据**（multiple-choice data，nanochat 中记为 `categorical` 评测类型）指这样的监督样本：用户回合给出一道题干与若干带标签的选项，assistant 回合的内容被压缩为单个标签 token。**工具使用数据**（tool-use data，记为 `generative` 评测类型）指 assistant 回合的内容不是字符串，而是由 `text`、`python`、`python_output` 三类分片组成的列表，其中 `python` 分片表示模型发起一次计算器调用，`python_output` 分片表示解释器返回的结果。

**`render_mc`** 是 `tasks/common.py` 中的多选渲染函数，规定题干、选项、标签与回答指令的固定文本格式。符号约定如下。

| 符号 | 含义 |
|---|---|
| $q$ | 题干文本 |
| $J$ | 选项个数，MMLU 固定 4，ARC 由数据的标签列表长度决定 |
| $\ell_j$ | 第 $j$ 个选项的标签，如 `A`、`B`、`C` |
| $c_j$ | 第 $j$ 个选项的文本 |
| $a$ | 正确答案的标签；MMLU 以整数索引给出，ARC 以 `answerKey` 字符串给出 |
| $e$ | 工具调用的表达式，取自 `<<e=r>>` 的左半部分 |
| $r$ | 工具调用的返回值，取自 `<<e=r>>` 的右半部分 |
| $\rho$ | 奖励（reward），GSM8K 上取 0 或 1 |
| $m_t$ | 位置 $t$ 的损失掩码 |

`eval_type` 是 `Task` 的属性，取 `categorical` 或 `generative`，决定评测走哪条路径：前者不采样，直接比较候选标签的 logits；后者需要自回归生成再解析文本。**`answerKey`** 是 ARC 数据中的正确答案标签字段。**`####`** 是 GSM8K 答案行前的标记，答案抽取依赖它定位数值。

## 为什么重要

`scripts/chat_sft.py` 的训练混合由三个任务构成，其中两个负责非语言能力：MMLU 教模型遵守多选格式（ARC 以同一格式作为留出评测，不进入训练），GSM8K 教模型调用计算器并把结果写进解题过程。这两项能力在 ChatCORE 中各自占据固定份额：5 个评测任务里 3 个是 categorical（ARC-Easy、ARC-Challenge、MMLU），2 个是 generative（GSM8K、HumanEval），前者的评测方式完全依赖「模型在 assistant 起始位置是否把概率质量放在标签 token 上」，后者依赖「模型是否在文本中写出 `#### 数值`」。

没有统一的多选格式，评测无法收敛到一个可比较的数字。`chat_eval.py` 的 categorical 路径只在候选标签对应的 token 上比较 logits：`focus_logits = logits[idx, answer_pos, letter_ids]`，取 argmax 作为预测。这一做法成立的前提是训练时的回答位置与评测时的读取位置是同一个 token：prompt 的最后一个 token 是 `<|assistant_start|>`，模型在该位置的下一 token 分布就是要被读取的对象；训练时紧随其后的正是答案标签。若训练数据的格式与评测时构造的 prompt 不一致，评测读到的分布与训练优化的分布错位，分数不再反映能力。

没有工具使用数据，GSM8K 的能力无法凭空出现。模型自身不做精确算术：三位数乘法、小数比较、长除法都超出它在预训练中形成的近似计算能力。工具使用数据把算术外置给解释器，模型只需要学会三件事：在何处发起调用（`<|python_start|>`）、写出什么表达式、如何消费返回的输出（`<|output_start|>` 之后的内容由运行时注入）。这三件事都是纯格式行为，可以由少量样本监督得到。

在全书结构中，本篇承上：[[对话数据与SmolTalk]] 给出通用对话分布与渲染器，本篇给出两种特殊分布；启下：[[有监督微调SFT]] 把三者混合成 792K 行训练流，[[GRPO原理与实现]] 的奖励函数直接复用 GSM8K 的判分逻辑。工程上，本篇还解释了一个容易忽略的细节：tokenizer 的空格处理会决定一个格式字符串能否真正对齐到训练目标。

## 原理与推导

### 1. render_mc 的格式与两条设计理由

函数本体只有四行，但注释用两段说明了两个设计决定。

```python
def render_mc(question, letters, choices):
    """The common multiple choice rendering format we will use.

    Note two important design decisions:
    1) Bigger models don't care as much, but smaller models prefer to have
       the letter *after* the choice, which results in better binding.
    2) There is no whitespace between the delimiter (=) and the letter.
       This is actually critical because the tokenizer has different token ids
       for " A" vs. "A".
    """
    query = f"Multiple Choice question: {question}\n"
    query += "".join([f"- {choice}={letter}\n" for letter, choice in zip(letters, choices)])
    query += "\nRespond only with the letter of the correct answer."
    return query
```

渲染结果的精确形态如下，以 MMLU 的一条样本为例。

```text
Multiple Choice question: Which of the following is a prime number?
- 21=A
- 23=B
- 25=C
- 27=D

Respond only with the letter of the correct answer.
```

题干与选项之间没有空行，选项组与回答指令之间有一个空行；这两处空白都属于训练分布的一部分，改动会改变渲染后的 token 序列。

第一条设计理由关于标签的位置。选项写作 `- <文本>=<标签>`，标签在选项文本之后。repo 注释的表述是「smaller models prefer to have the letter after the choice, which results in better binding」。可解释的机制是依赖距离：标签与被标注的文本相邻，模型只需学习一个局部模式（文本结束符 `=` 之后出现哪个标签）；若改为 `A. 文本`，标签在其内容之前，模型必须把标签跨越整段选项文本保留到最后，注意力路径更长，小模型的容量不足以稳定学到这一绑定。

第二条设计理由关于空格。选项行是 `- 21=A`，`=` 与 `A` 之间没有空格；assistant 的回答是裸的 `A`，前面也没有空格。这看起来是排版细节，实际决定 token id 是否一致。nanochat 的 `SPLIT_PATTERN` 中含 `[^\r\n\p{L}\p{N}]?+\p{L}+` 这一段，它把「一个可选的非字母字符 + 一串字母」切成同一个片段；空格属于 `[^\r\n\p{L}\p{N}]`，因此 `" A"` 与 `"A"` 是不同的字节串，经过 BPE 合并后通常也是不同的 token。若 prompt 写成 `- 21= A`，模型在标签位置看到的 token 是 `" A"`，而训练目标与评测比较用的 token 是 `"A"`；两者不同，模型必须额外学会「输出裸字母」这一映射，评测读取的 logits 与训练优化的位置也不再是同一个对象。

第三行 `Respond only with the letter of the correct answer.` 固定输出格式。它把「回答什么」与「怎么回答」分开：题干与选项给出内容，最后一句给出格式约束；两者之间用空行分隔，使指令在 token 序列中有明确边界。

### 2. MMLU：固定字母与整数索引

`tasks/mmlu.py` 的实现把字母表硬编码为四元组，把答案编码为索引。

```python
class MMLU(Task):
    letters = ('A', 'B', 'C', 'D')
    # groups 是 57 个学科名的元组，完整列表见 tasks/mmlu.py

    def __init__(self, subset, split, **kwargs):
        super().__init__(**kwargs)
        assert subset in ["all"]
        assert split in ["auxiliary_train", "validation", "dev", "test"]
        self.ds = load_hub_dataset("cais/mmlu", subset, split=split).shuffle(seed=42)

    def get_example(self, index):
        row = self.ds[index]
        question = row["question"]    # 题干文本
        choices = row["choices"]      # 4 个选项文本
        answer = row["answer"]        # 0,1,2,3 对应 A,B,C,D
        assert len(choices) == 4, "MMLU should have 4 choices"
        user_message = render_mc(question, self.letters, choices)
        assistant_message = self.letters[answer]
```

四处细节值得记录。字母表固定为 `A` 至 `D`，不存在三选项或五选项的 MMLU 样本，因此 `render_mc` 的 `letters` 参数总是同一个元组。答案是整数索引，`self.letters[answer]` 完成从索引到标签的映射，映射方向与 ARC 相反。`assert len(choices) == 4` 是对上游数据的校验：辅助训练集由多个来源拼接，理论上可能混入其他选项数的题目，断言把这类样本挡在训练之外。对话字典额外携带 `subject` 与 `letters` 两个键，前者可用于按学科分组统计，后者供评测阶段限定候选标签。

SFT 使用 `split="auxiliary_train"`，约 10 万行（`chat_sft.py` 的注释写 100K rows per epoch），默认重复 3 次。不使用 `test` 划分的理由是评测隔离：`chat_eval.py` 的 MMLU 任务构造为 `partial(MMLU, subset="all", split="test")`，若训练也用 test，ChatCORE 会直接反映训练集记忆。`auxiliary_train` 是 MMLU 发布时附带的额外多选题集合，与 test 不同分布，用于扩大训练信号。

### 3. ARC：标签顺序与 answerKey 校验

ARC 的结构与 MMLU 不同：选项不是字符串列表，而是包含 `text` 与 `label` 两个平行列表的字典；答案不是索引，而是标签字符串。

```python
class ARC(Task):
    def get_example(self, index):
        row = self.ds[index]
        question = row["question"]
        choices = row["choices"]["text"]      # 选项文本
        answer_string = row["answerKey"]      # 如 "A"、"B"、"C"、"D"
        letters = row["choices"]["label"]     # 与 choices 平行的标签列表
        assert answer_string in letters, f"ARC answer {answer_string} must be one of {letters}"
        user_message = render_mc(question, letters, choices)
        messages = [
            {"role": "user", "content": user_message},
            {"role": "assistant", "content": answer_string},
        ]
        conversation = {"messages": messages, "letters": letters}
        return conversation
```

三处差异带来不同的失效模式。第一，标签由数据给出而非硬编码，ARC 的标签集合可能是三元素或五元素，也可能是非字母的编号；`render_mc` 逐项 zip，标签顺序与文本顺序严格对应，若上游的 `label` 与 `text` 两个列表不同长，zip 会静默截断，断言无法发现。第二，`answerKey` 是字符串，必须与 `label` 中的某一项完全相等；`assert answer_string in letters` 在构造期拦截标签集合不一致的样本，否则训练出的 assistant 目标会是一个 prompt 中从未出现的标签。第三，对话字典携带实际的 `letters`，评测时 `chat_eval.py` 用 `conversation['letters']` 限定候选 token 集合，所以评测的候选数随题目变化，而不是固定 4 个。

ARC 的两个子集在难度上不同，`ARC-Easy` 与 `ARC-Challenge` 分别作为独立的评测任务计入 ChatCORE。二者共用同一份代码，只有 `subset` 参数不同。

### 4. MMLU 与 ARC 的对照

| 维度 | MMLU | ARC |
|---|---|---|
| 选项个数 | 固定 4（有断言） | 不固定，等于 `choices["label"]` 的长度 |
| 标签来源 | 硬编码 `('A','B','C','D')` | `row["choices"]["label"]` |
| 答案表示 | 整数索引 `answer` | 字符串 `answerKey` |
| 映射方向 | 索引到标签 | 标签直接使用 |
| 关键断言 | `len(choices) == 4` | `answer_string in letters` |
| 对话附带字段 | `subject`、`letters` | `letters` |
| SFT 使用的划分 | `auxiliary_train`，3 个 epoch | 不参与 SFT |
| 评测任务名 | `MMLU` | `ARC-Easy`、`ARC-Challenge` |
| 评测候选集 | 固定 4 个标签 | 该题的标签集合 |

ARC 不参与 SFT、只参与评测，是一个有意的设计：多选格式由 MMLU 的 3 个 epoch 共 30 万行教，ARC 作为同格式的留出任务检验泛化。若 ARC 也进入训练混合，「按格式作答」与「按题目记忆答案」两种解释就分不开了。

### 5. GSM8K：把 `<<expr=result>>` 拆成分片

GSM8K 的原始答案是一段自然语言解题过程，其中用 `<<>>` 标注每一步的算术，行末用 `####` 给出最终数值。模块的文档字符串给出完整样例。

```text
Question:
Weng earns $12 an hour for babysitting. Yesterday, she just did 50 minutes of babysitting. How much did she earn?
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
```

`GSM8K.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` 把分隔符本身也放进结果列表，因此文本段与工具段交替出现，不需要额外的定位逻辑。`rsplit('=', 1)` 取最后一个等号，允许表达式内部出现等号（例如比较或赋值形式的写法），而 `split('=', 1)` 会把表达式的后半段误当作结果。缺少等号时把 `result` 置为空串而不是报错，使格式异常的数据仍能进入训练，代价是产生一个空的 `python_output` 分片。

拆分后 assistant 回合的内容是分片列表，渲染器据此产生三类 token 区间：`text` 分片按普通文本处理，掩码为 1；`python` 分片被包进 `<|python_start|>` 与 `<|python_end|>`，三个部分掩码都为 1；`python_output` 分片被包进 `<|output_start|>` 与 `<|output_end|>`，三个部分掩码都为 0。

### 6. `####` 答案抽取与奖励

判分只关心最终数值，不关心解题过程是否正确。

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

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):
    return float(self.evaluate(conversation, assistant_response))
```

正则要求 `####` 之后紧跟一个空格，再跟数字、小数点、逗号或负号；千分位逗号在归一化时删除。比较是字符串相等，不是数值相等。这一设计使判分极简：不需要数值解析、不需要浮点容差、不需要单位处理。代价是任何表示差异都被判错：`10.0` 与 `10` 不等，`1/2` 与 `0.5` 不等，`10 ` 与 `10` 相等（`strip` 只去掉两端空白，而正则在数字处停止匹配）。

`reward` 只是 `evaluate` 的浮点包装，二者在 SFT 中都不使用：SFT 只用交叉熵。它们在强化学习阶段才生效，`scripts/chat_rl.py` 的 rollout 循环调用 `train_task.reward(conversation, generated_text)` 得到标量奖励。因此 GSM8K 的判分逻辑同时承担两个角色：评测指标与训练奖励，改动它会同时改变这两条链路。

### 7. 三种数据各自贡献什么监督信号

把三种数据的监督位置展开，可以看到混合比例与能力类型的关系。下表是量级估计，用于说明结构而不是精确统计。

| 数据 | 行数 | 每条监督 token 数（估计） | 监督 token 总量（估计） | 教什么 |
|---|---|---|---|---|
| SmolTalk | 460K | 约 120 | 约 $5.5\times10^{7}$ | 通用回复分布、多轮、停止 |
| MMLU | 300K（3 epoch） | 2（标签 + 结束符） | 约 $6\times10^{5}$ | 多选格式、单 token 回答 |
| GSM8K | 32K（4 epoch） | 约 100（文本 + 表达式 + 结束符） | 约 $3.2\times10^{6}$ | 工具调用协议、解法结构、`####` 约定 |

MMLU 只贡献约 60 万监督 token，占总量的 1% 左右，但它是唯一含有「单 token 答案」模式的来源。这一模式的特征是上下文极长（题干与四个选项）、目标极短（一个标签），与 SmolTalk 的「中等上下文、中等长度回复」完全不同。模型因此学到一个条件规则：当 prompt 以 `Respond only with the letter of the correct answer.` 结尾时，输出应当压缩为单个标签。评测时读取的正是这一规则的输出分布。

GSM8K 的监督 token 量约为 MMLU 的 5 倍，原因是它的 assistant 段包含完整解题过程。它教的不只是工具协议，还包括解题的书写结构：先写一步算式，再写该步的结论，最后另起一行写 `#### 数值`。这个结构使模型在评测时更可能生成可被判分器识别的输出；即使数值算错，格式正确也让失败原因可区分（算术错误 vs 格式错误）。

### 在 nanochat 中的落地

| 位置 | 代码 | 作用 | 去掉会怎样 |
|---|---|---|---|
| `tasks/common.py` | `render_mc` | 统一多选 prompt 格式 | 各任务格式不一致，评测读取位置与训练不对齐 |
| `tasks/mmlu.py` | `letters` 与 `self.letters[answer]` | 索引到标签 | 需要额外的映射表 |
| `tasks/mmlu.py` | `assert len(choices) == 4` | 拦截异常选项数 | zip 静默截断，产生错位的选项 |
| `tasks/arc.py` | `assert answer_string in letters` | 校验标签集合 | 目标标签可能不在 prompt 中出现 |
| `tasks/gsm8k.py` | `re.split(r'(<<[^>]+>>)', answer)` | 分片 | 无法区分表达式与文本 |
| `tasks/gsm8k.py` | `GSM_RE` 与 `extract_answer` | 数值抽取 | 判分与奖励都失效 |
| `nanochat/tokenizer.py` | `render_conversation` 的 `python`/`python_output` 分支 | 掩码构造 | python 段不被监督或输出段被监督 |
| `scripts/chat_sft.py` | `--mmlu-epochs=3`、`--gsm8k-epochs=4` | 过采样 | 格式与工具能力的学习不充分 |
| `scripts/chat_eval.py` | `focus_logits = logits[idx, answer_pos, letter_ids]` | 标签 logits 聚焦 | 只能靠生成文本判分，噪声更大 |
| `scripts/chat_rl.py` | `reward = train_task.reward(conversation, generated_text)` | RL 奖励 | 强化学习没有信号 |

`render_conversation` 的分支决定了掩码，这是工具数据最关键的一处实现。

```python
elif part["type"] == "python":
    # 模型发起的调用：起始符、表达式、结束符都监督
    add_tokens(python_start, 1)
    add_tokens(value_ids, 1)
    add_tokens(python_end, 1)
elif part["type"] == "python_output":
    # 解释器返回的内容：三个部分都不监督
    add_tokens(output_start, 0)
    add_tokens(value_ids, 0)
    add_tokens(output_end, 0)
```

`python_output` 不监督的理由是它不由模型生成。推理时 `Engine.generate` 在遇到 `<|python_end|>` 后调用 `use_calculator` 求值，再把 `<|output_start|>结果<|output_end|>` 作为强制 token 注入，强制 token 的 mask 记为 0。若训练时也监督输出，模型会学到「直接写出计算结果」，而它不具备精确算术能力；这正是工具调用试图避免的失败模式。

## 关键直觉

> [!tip] 监督信号的位置决定能力类型，而不是数据量。MMLU 的每条样本只监督 2 个 token，却定义了「多选」这一输出格式；GSM8K 监督约 100 个 token，其中关键的是 `<|python_start|>` 与 `<|python_end|>` 包裹的表达式部分；`python_output` 的 3 个 token 一律不监督，因为它的来源是解释器而非模型。
>
> 与严格定义的关系：定义中的掩码 $m_t$ 是这套分工的唯一表达方式。同一个 prompt 可以同时提供「格式」与「内容」两种信息，但只有被掩码标为 1 的位置才会改变参数；$m_t=1$ 的集合决定了模型把容量分配到哪一类行为上。判断一份新数据能否教会某种能力，应当先画出它的监督区间，再看这些区间是否覆盖该能力出现时的 token 位置。

## 例子与代码

第一段复现 `render_mc` 并检查空格，不依赖外部库。

```python
"""render_mc 的复现与格式检查。"""

def render_mc(question, letters, choices):
    query = f"Multiple Choice question: {question}\n"
    query += "".join([f"- {choice}={letter}\n" for letter, choice in zip(letters, choices)])
    query += "\nRespond only with the letter of the correct answer."
    return query

prompt = render_mc("Which of the following is a prime number?",
                   ("A", "B", "C", "D"), ("21", "23", "25", "27"))
print(prompt)
print(repr(prompt.splitlines()[2]))     # 观察 = 与标签之间是否有空格
assert "= A" not in prompt and "= B" not in prompt   # 空格会改变标签 token
```

预期输出如下。第二行用 `repr` 显示选项行，可见 `=B` 之间没有空格。

```text
Multiple Choice question: Which of the following is a prime number?
- 21=A
- 23=B
- 25=C
- 27=D

Respond only with the letter of the correct answer.
'- 23=B'
```

第二段处理 GSM8K 的答案，验证分片、渲染顺序、掩码与奖励。

```python
"""GSM8K 答案拆分、掩码示意与奖励计算（不依赖 nanochat 环境）。"""
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)
rendered = []
for part in parts:
    if part.startswith('<<') and part.endswith('>>'):
        inner = part[2:-2]
        expr, result = inner.rsplit('=', 1) if '=' in inner else (inner, "")
        rendered += [("<|python_start|>", 1), (expr, 1), ("<|python_end|>", 1)]
        rendered += [("<|output_start|>", 0), (result, 0), ("<|output_end|>", 0)]
    elif part:
        rendered.append((part, 1))

supervised = [t for t, m in rendered if m == 1]
print("分片数:", len(parts), "监督片段数:", len(supervised))
print("首个工具段:", [t for t, m in rendered[1:5]])

GSM_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
extract = lambda s: (lambda m: m.group(1).strip().replace(",", "") if m else None)(GSM_RE.search(s))
ref = extract(rendered[-1][0])
for completion in ["...#### 10", "...#### 10.0", "...#### 1,000", "最终答案是 10"]:
    pred = extract(completion)
    print(repr(completion), "->", pred, "reward", int(pred == ref))
```

预期输出如下。工具调用的三段掩码为 1，输出的三段掩码为 0；奖励只有字符串完全相等时才为 1。

```text
分片数: 5 监督片段数: 9 渲染条目: 15
首个工具段: ['<|python_start|>', '12/60', '<|python_end|>', '<|output_start|>']
ref = 10
'...#### 10' -> 10 reward 1
'...#### 10.0' -> 10.0 reward 0
'...#### 1,000' -> 1000 reward 0
'最终答案是 10' -> None reward 0
```

`分片数 5` 来自三段文本加两处工具调用；每处调用拆成 `python` 与 `python_output` 各一段，因此渲染条目为 $3+2\times6=15$。监督片段 9 个：三段文本与两个表达式，加上两组 `<|python_start|>`/`<|python_end|>` 控制符按片段计。`1,000` 归一化为 `1000` 后仍与参考答案 `10` 不等，说明逗号删除只做格式化，不做数值比较。

第三段复现 categorical 评测的标签聚焦。

```python
"""chat_eval 的 categorical 路径：只比较候选标签的 logits。"""
letters = ["A", "B", "C", "D"]
letter_ids = [101, 102, 103, 104]           # 各标签对应的单个 token id
logits = {101: 1.2, 102: 3.4, 103: 2.1, 104: 0.3}   # 最后一层的词表 logits 子集

focus = [logits[i] for i in letter_ids]
predicted = letters[focus.index(max(focus))]
print("候选 logits:", focus, "预测:", predicted)
assert predicted == "B"
```

预期输出 `候选 logits: [1.2, 3.4, 2.1, 0.3] 预测: B`。这段代码省略了模型前向，只保留评测的核心操作：在 `answer_pos` 位置取候选标签的 logits、argmax、映射回标签。真实实现的 `answer_pos` 是 prompt 的最后一个位置，即 `<|assistant_start|>` 所在位置；若把该位置算错（例如用了 `len(ids)` 而非 `len(ids)-1`），读到的就是 `<|assistant_start|>` 自身的 logits，结果不再反映 assistant 首 token 的分布。

一条 GSM8K 样本完整渲染后的 token 序列示意如下，方括号内为控制符，右侧标注掩码。

```text
[BOS]                                                                    m=0
[user_start]                                                             m=0
Weng earns $12 an hour for babysitting. Yesterday, she just did 50 minutes of babysitting. How much did she earn?       m=0
[user_end]                                                               m=0
[assistant_start]                                                        m=0
"Weng earns 12/60 = $"                                                   m=1
[python_start] 12/60 [python_end]                                        m=1 1 1
[output_start] 0.2 [output_end]                                          m=0 0 0
"0.2 per minute.\nWorking 50 minutes, she earned 0.2 x 50 = $"           m=1
[python_start] 0.2*50 [python_end]                                       m=1 1 1
[output_start] 10 [output_end]                                           m=0 0 0
"10.\n#### 10"                                                           m=1
[assistant_end]                                                          m=1
```

监督区间覆盖了模型需要自己生成的全部内容：解题文本、两次调用的表达式，以及最后的 `#### 10`；解释器返回的 `0.2` 与 `10` 不参与损失。评测时模型只需生成到 `<|assistant_end|>`，判分器从生成文本中抽取 `####` 后的数值与数据集答案比较。

## 易错点

> [!warning] 以下六条均可在数据检查或评测日志中验证。
> 1. 在 `render_mc` 的 `=` 与标签之间加空格。`- 21= A` 会让 prompt 中的标签 token 与训练目标、评测候选的 token 不一致，格式仍能显示，分数下降但原因难以定位。
> 2. 给 MMLU 换一份选项数不为 4 的数据源。`assert len(choices) == 4` 会直接失败；若删掉断言，`render_mc` 的 zip 会按标签数截断，产生「第五个选项凭空消失」的错位样本。
> 3. 把 ARC 的 `answerKey` 与 `choices["text"]` 直接按下标对齐。正确对齐依据是 `choices["label"]` 的顺序；标签集合可能不是 `A` 至 `D`（例如数字标签），选项数也可能少于 4，硬编码标签会得到错误的监督目标。
> 4. 把 `python_output` 的掩码写成 1。模型会学到直接输出计算结果的模式，推理时不再发起工具调用；损失曲线不会异常，GSM8K 分数却停滞在格式正确的错误答案上。
> 5. 认为 `extract_answer` 做了数值比较。它只做字符串相等，`10.0` 与 `10` 判错；若要容差比较，必须改判分逻辑，并同步修改 RL 的奖励定义。
> 6. 忽略 `None == None` 的情形。若参考答案与预测都没有匹配到 `####`，`int(None == None)` 为 1，奖励会被误判为正确；参考答案通常含 `####`，但预测格式异常时仍可能出现两侧同时为空。

## 关联笔记

- 前置 [[对话数据与SmolTalk]]：提供通用对话分布与渲染器，本篇的 MMLU 与 GSM8K 复用同一个 `render_conversation`。
- 后续 [[有监督微调SFT]]：三种数据在此被混合、打包、加掩码并训练，本篇的 `eval_type` 决定评测路径。
- 后续 [[GSM8K数学任务]]：强化学习阶段沿用本篇的 `evaluate` 与 `reward`，把判分函数变成训练信号。
- 对照 [[ARC与MMLU]]：评测视角的同一批数据，说明 categorical 评测为何只比较标签 logits。
- 跨库 [[指令微调SFT]]：通用原理见该篇，本篇只讲 nanochat 的多选格式与工具协议实现。

## 达标检测

- [ ] 默写 `render_mc` 的输出格式，标出 `=` 与标签之间的空格，并说明它为什么影响 token id。
- [ ] 复述 repo 注释给出的两条设计理由，并为第二条给出 tokenizer 层面的机制解释。
- [ ] 列出 MMLU 与 ARC 在选项数、标签来源、答案表示三方面的差异，各给出一个对应的失效模式。
- [ ] 解释为什么 ARC 不进入 SFT 混合，而 MMLU 进入且过采样 3 次。
- [ ] 手写一段代码把 `<<12/60=0.2>>` 拆成 `python` 与 `python_output` 两个分片，并给出两段的掩码。
- [ ] 给定参考答案 `#### 10` 与四类补全，判断奖励并说明 `10.0` 为何判错。
- [ ] 画出 categorical 评测的读取位置与候选集合，说明 `answer_pos` 少减 1 会发生什么。

## 参考来源

- Hendrycks et al., "Measuring Massive Multitask Language Understanding", arXiv:2009.03300, 2021 —— 对应第 2 节的 MMLU 结构、57 个学科与 `auxiliary_train` 划分的用途。
- Clark et al., "Think you have Solved Question Answering? Try ARC, the AI2 Reasoning Challenge", arXiv:1803.05457, 2018 —— 对应第 3 节的选项标签结构、`answerKey` 语义与两个难度子集。
- Cobbe et al., "Training Verifiers to Solve Math Word Problems", arXiv:2110.14168, 2021 —— 对应第 5 节的 `<<expr=result>>` 标注与 `####` 答案约定，以及第 6 节的判分口径。
- Karpathy, *nanochat*（commit 92d63d4），`tasks/common.py`、`tasks/mmlu.py`、`tasks/arc.py`、`tasks/gsm8k.py`、`scripts/chat_eval.py` —— 对应第 1 至 6 节的实现细节、「在 nanochat 中的落地」一节的表格与三段示例代码。
- Karpathy, *nanochat*（commit 92d63d4），`dev/LOG.md` 2026-02-16 条目 —— 对应第 2 节 MMLU 与 GSM8K 的 epoch 数调整（1 到 3、2 到 4）及「以 sweep 结果为准」的说明。
