---
tags: [nanochat, eval, multiple-choice]
阶段: 08-评测Eval
难度: ★★☆
created: 2026-10-22
related: "[[评测方法论]], [[多选与工具使用数据]], [[GSM8K与HumanEval]], [[如何解读指标]]"
---

# ARC与MMLU

## 定义

**ARC**（AI2 Reasoning Challenge）是一个小学到初中难度的科学问答数据集，分为 Easy 与 Challenge 两个子集；每道题给出题干与若干选项，选项携带数据集自带的标签（通常是字母），标准答案以 `answerKey` 给出。**MMLU**（Massive Multitask Language Understanding）是一个覆盖 57 个学科的四选一知识问答数据集，标准答案以选项下标 0 至 3 给出。nanochat 把两者都实现为 **categorical 评测**：不生成文本，只在答案位置比较各候选标签 token 的 logits，取最大者为预测。

符号与术语定义如下。

- **题干**（question）：数据集的 `question` 字段，一段自然语言。
- **选项**（choices）：候选答案文本；ARC 位于 `choices["text"]`，MMLU 位于 `choices`。
- **选项标签**（label）：ARC 位于 `choices["label"]`，例如 `["A","B","C","D"]`；MMLU 固定为 `('A','B','C','D')`。
- **标准答案**：ARC 的 `answerKey` 是标签字符串，MMLU 的 `answer` 是下标 $i\in\{0,1,2,3\}$。
- **`render_mc`**：`tasks/common.py` 中的多选提示渲染函数，把题干与「选项=标签」逐行排列，并追加一句只回答字母的指令。
- **字母 token**：标签字符串经分词器编码后得到的单 token；`run_categorical_eval` 断言其长度为 1。
- **答案位置**（answer position）：提示最后一个真实 token 的下标，模型在该位置预测下一个 token，即标签。
- **logits**：模型在词表上的未归一化分数，形状 $(B,T,V)$，$B$ 为批大小，$T$ 为序列长度，$V$ 为词表大小。
- **argmax**：取分数最大者的下标；在受限集合上取 argmax 等价于只在该集合内选择。
- **随机基线**：均匀猜中概率；四选一为 0.25，三选一为 $1/3$。
- **categorical 准确率**：预测标签等于标准答案的题目比例。

## 为什么重要

chat 模型不能用 CORE 的续写打分评测：CORE 的模板是针对 base 模型设计的，chat 模型的输入必须包含 `<|user_start|>`、`<|assistant_start|>` 等特殊 token，两类提示不在同一分布上。若改用生成式评测来量化选项，则会引入新的失败来源——模型可能答出正确答案但表述不合格式，导致分数同时反映知识与格式遵循，无法归因。

categorical 评测解决这个归因问题。它保留 chat 的对话模板（因此测的是 SFT 之后的模型），却把「生成一个字母」替换为「在本题的候选标签里取 logit 最大者」。这样分数只反映两件事：模型是否在答案位置给正确标签更高的分数，以及 SFT 是否学会了在 `<|assistant_start|>` 之后输出标签。格式错误、解释长度、标点习惯都不再影响分数。

ARC 与 MMLU 在 nanochat 中的另一个作用是训练信号。MMLU 以 3 个 epoch 进入 SFT 数据混合（`--mmlu-epochs=3`），用于教模型「多选格式」；因此 MMLU 的评测分数包含明显的域内成分，不能当作纯粹的泛化指标。ARC 不进入训练混合，是更干净的 held-out 信号。两者的差别决定了它们在成绩单中的解读方式，见 [[如何解读指标]]。

在「懂原理、能复现、懂工程」三个维度中，本篇偏工程：原理只是「在受限集合上取 logits 最大值」，工程细节集中在批量拼装、答案位置对齐与 token 一致性上；这三处任一出错都会得到看似合理的错误分数。

## 原理与推导

### 1. ARC 的数据结构与实现

`tasks/arc.py` 的构造函数做三件事：断言子集与切分合法、下载并打乱数据、把每行转成 `Conversation`。

```python
# 节选自 tasks/arc.py 的 ARC 类
self.ds = load_hub_dataset("allenai/ai2_arc", subset, split=split).shuffle(seed=42)

def get_example(self, index):
    row = self.ds[index]
    question = row["question"]                         # 题干
    choices = row["choices"]["text"]                   # 选项文本列表
    answer_string = row["answerKey"]                   # 例如 "A"
    letters = row["choices"]["label"]                  # 例如 ["A","B","C","D"]
    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},
    ]
    return {"messages": messages, "letters": letters}
```

三个事实值得注意。第一，代码不对选项数做断言，ARC 的题目选项数并不固定（数据集中常见 3 至 5 个选项），标签由数据集给出，按数据集的顺序排列，不保证是固定元组 A 到 D。第二，`letters` 被原样保存在 `conversation` 中，评测时用它把预测限制在合法标签集合内。第三，数据在构造时 `shuffle(seed=42)`，与 `datasets.Dataset.shuffle(seed=42)` 的置换一致；`HubDataset.shuffle` 用 `np.random.default_rng(seed).permutation` 复刻了这一行为。

判分函数只有一个断言与一次字符串比较：

```python
def evaluate(self, conversation, assistant_response):
    assert assistant_response in conversation['letters']
    assistant_message = conversation['messages'][-1]['content']   # 标准答案，例如 "A"
    return assistant_response == assistant_message
```

`assistant_response` 在 categorical 路径下就是预测标签，因此断言恒成立；该断言存在的意义是防止未来改成生成式路径时把整段文本传进来。

### 2. MMLU 的数据结构与实现

`tasks/mmlu.py` 的 `groups` 元组列出 57 个学科，从 `abstract_algebra` 到 `world_religions`。构造函数要求 `subset="all"`、切分为 `auxiliary_train`、`validation`、`dev`、`test` 之一，并同样做 `shuffle(seed=42)`。

```python
# 节选自 tasks/mmlu.py 的 MMLU 类
letters = ('A', 'B', 'C', 'D')
# 为聚焦判分逻辑只保留关键字段；构造函数与 get_example 的完整实现见 tasks/mmlu.py 与 tasks/arc.py
question = row["question"]
choices = row["choices"]        # 4 个选项文本
answer = row["answer"]          # 0..3 的下标
subject = row["subject"]        # 学科名，评测时不参与聚合
assert len(choices) == 4, "MMLU should have 4 choices"
user_message = render_mc(question, self.letters, choices)
assistant_message = self.letters[answer]
```

MMLU 比 ARC 多一层约束：选项数固定为 4、标签固定为 A 到 D，因此随机基线严格为 0.25。`subject` 被保留在 `conversation` 中，但 `scripts/chat_eval.py` 只按任务名聚合，不做学科级拆分；若要按学科分析，需要在外部脚本中按 `subject` 分组重算。

各切分的职责不同：`auxiliary_train` 约 10 万条，是 SFT 阶段教多选格式的数据来源；`test` 是最终评测切分（`partial(MMLU, subset="all", split="test")`）；`dev` 与 `validation` 在当前脚本中没有被使用，只在构造函数中允许传入。`scripts/chat_sft.py` 的 `--mmlu-epochs=3` 只作用于 `auxiliary_train`，因此 test 切分本身没有直接进入训练，但同分布题型的格式已被反复强化。

### 3. `render_mc` 的格式与「字母紧跟选项」

`render_mc` 的完整实现只有四行，但每个字符都有理由。

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

以「法国的首都是哪里」为例，四个选项为 Paris、London、Berlin、Madrid，渲染结果是：

```text
Multiple Choice question: What is the capital of France?
- Paris=A
- London=B
- Berlin=C
- Madrid=D

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

两个设计决定写在函数 docstring 中。第一，字母放在选项之后而不是之前，因为小模型对「选项文本 → 标签」的绑定更敏感，字母紧跟选项时绑定更强；大模型对此不敏感，但小模型会显著变差。第二，`=` 与字母之间没有空白，这一点是关键的：分词器对 `" A"` 与 `"A"` 给出不同的 token id，而 SFT 训练时 assistant 消息的内容就是裸字母 `"A"`，因此提示里的标签必须是同一个 token。`tests/test_tasks.py` 的 `test_render_mc_letter_binding` 用 `assert "=A\n" in query` 固定了这一约定。

第三处细节是结尾指令与换行：每个选项后有一个换行，选项块与指令之间有一个空行。这些字符会进入提示的 token 序列，改变答案位置之前的上下文，因此修改格式等于改变评测协议。

### 4. `run_categorical_eval` 的批量拼装

`scripts/chat_eval.py` 的 categorical 循环把多个独立问题拼成一批，一次前向完成。批量拼装分五步。

```python
conversations = [task_object[ii] for ii in range(i0, i1)]
prompt_ids = [tokenizer.render_for_completion(conversation) for conversation in conversations]
max_length = max(len(ids) for ids in prompt_ids)
answer_time_positions = [len(ids) - 1 for ids in prompt_ids]
padded_prompt_ids = [ids + [bos] * (max_length - len(ids)) for ids in prompt_ids]
prompt_ids = torch.tensor(padded_prompt_ids, dtype=torch.long, device=device)
```

第一步，`render_for_completion` 弹出最后一条 assistant 消息，把对话渲染成 token，并追加 `<|assistant_start|>`。因此每条提示的最后一个 token 是 assistant 起始符，模型在该位置的下一 token 分布就是「回答的第一个 token」。第二步，取批内最大长度作为张量宽度。第三步，记录每行真实长度减一，即模型做预测的位置；这个位置在 padding 之前计算，因此不受补齐影响。第四步，在右侧用 BOS 补齐；因为注意力是因果的，右侧补齐不会改变答案位置的 logits。第五步，转成 $(B,T)$ 的整型张量并搬到设备。

随后一次前向得到 $(B,T,V)$ 的 logits。逐行处理时只取答案位置的切片：

```python
answer_pos = answer_time_positions[idx]
focus_logits = logits[idx, answer_pos, letter_ids]
argmax_letter_id = focus_logits.argmax(dim=-1).item()
predicted_letter = letters[argmax_letter_id]
```

`letter_ids` 是该题合法标签的 token id 列表，来自缓存：

```python
for letter in letters:
    if letter not in letter_to_id_cache:
        encoded_letter = tokenizer.encode(letter)
        assert len(encoded_letter) == 1, "Each letter must be a single token"
        letter_to_id_cache[letter] = encoded_letter[0]
    letter_ids.append(letter_to_id_cache[letter])
```

缓存的动机是省去重复分词：一批题里 A、B、C、D 会反复出现。断言的作用更关键：如果某个标签（例如带句点的 `"A."`）被切成多个 token，`logits[idx, answer_pos, letter_ids]` 就不再对应一个完整标签，判分将失去意义，因此必须在此处失败而不是静默继续。

### 5. 为什么只比较字母 logits 更宽容

模型被要求回答一个字母，但评测从不检查它是否真的会写这个字母。`focus_logits` 只包含合法标签的分数，其他 token 的分数被完全忽略。比较两种实现。

第一种是仓库的选择：在本题的合法标签 token 上取 argmax。只要正确标签的分数高于其余候选，就算答对。模型即使更倾向于输出「The answer is A」或「答案：A」，只要它在答案位置给 `"A"` 的分数高于 `"B"`、`"C"`、`"D"`，仍会计为正确。

第二种是生成式替代：让模型自由生成，再解析它是否给出正确字母。此时前缀「The answer is」中的 token 会消耗生成长度，格式不合、大小写、标点、解释过多都可能导致解析失败；同一个模型在两种实现下的分数可以相差数十个百分点。仓库注释明确写出这一点：这种聚焦「helps the evaluation a lot」，而生成后检查正确字母是「much harder alternative」，并说明「evaluations typically make the task easier in this way」。

宽容不等于无信息。因为 logits 仍然来自同一个模型，标签之间的相对分数仍反映知识与格式；只是把「表达能力」这一维度从分数中剥离了。代价是分数不能解释为「模型能否正确回答」，只能解释为「模型在给定提示下是否把正确标签排在首位」。

### 6. 准确率与随机基线

MMLU 四选一的随机基线为 0.25；ARC 的选项数不固定，严格基线应逐题取 $1/n_{\text{options}}$，但 `scripts/chat_eval.py` 对两个 ARC 任务统一使用 0.25。这是一个约定而非推导：

```python
baseline_accuracies = {
    'ARC-Easy': 0.25,       # multiple choice 1 of 4 => 25%
    'ARC-Challenge': 0.25,  # multiple choice 1 of 4 => 25%
    'MMLU': 0.25,           # multiple choice 1 of 4 => 25%
    'GSM8K': 0.0,           # open-ended => 0%
    'HumanEval': 0.0,       # open-ended => 0%
}
```

若一道 ARC 题只有 3 个选项，随机概率是 0.333，用 0.25 作基线会把该题的中心化分数算得偏高；若某题有 5 个选项，则算得偏低。由于 ARC 大多数题为 4 选项，这一近似在总体上误差有限，但它意味着 ARC 的 centered 分数不是严格的无偏估计。报告跨模型比较时应说明基线是约定值。

### 在 nanochat 中的落地

第一处是 `tasks/common.py` 的 `render_mc`。它同时服务训练与评测：SFT 阶段的 MMLU 数据、chat 评测的 ARC 与 MMLU 都调用它。去掉「字母紧跟选项」的约束，训练与评测的 token 序列会不一致，categorical 分数会显著下降；去掉结尾指令，答案位置前最后一个 token 改变，分数同样变化。

第二处是 `tasks/arc.py` 与 `tasks/mmlu.py` 的 `evaluate`。两者都断言预测在合法标签内，再与 assistant 消息比较。去掉断言，错误的标签会静默计为错误；保留断言，实现错误会立即暴露。

第三处是 `scripts/chat_eval.py` 的 `run_categorical_eval`。它按 rank 轮转批次（`range(ddp_rank, num_batches, ddp_world_size)`），每批一次前向，最后把 `num_passed` 与 `total` 各自 `all_reduce(SUM)`。按批分配而不是按题分配，是因为 categorical 一次前向处理整批，按批分配才能让各 rank 的前向次数接近。

第四处是 `scripts/chat_sft.py` 的数据混合与训练期评测。训练混合按下面的方式构造（节选）：

```python
train_tasks = [
    SmolTalk(split="train"),                                              # 46 万条通用对话
    *[MMLU(subset="all", split="auxiliary_train") for _ in range(args.mmlu_epochs)],  # 每轮 10 万条
    *[GSM8K(subset="main", split="train") for _ in range(args.gsm8k_epochs)],          # 每轮 8 千条
]
train_dataset = TaskMixture(train_tasks)
```

MMLU 因此被重复 3 遍，格式被反复强化；训练期每 `--chatcore-every=200` 步用 `run_chat_eval` 复算，其中 categorical 任务默认全量（`--chatcore-max-cat=-1`），生成任务只取 24 题。

## 关键直觉

> [!tip] 评测把「生成一个字母」换成了「在候选标签里选一个」，因此测的是排序而不是表达能力
> 模型在答案位置的输出分布覆盖整个词表，categorical 评测只读取本题若干标签 token 的分数并取最大者。这个操作等价于把模型的回答约束为「只能从给定标签中选一个」，于是解析失败、格式错误、解释冗长都不再计入分数。与严格定义的关系：准确率仍然是「预测等于标准答案」的频率，只是预测不再是采样结果，而是受限集合上的 argmax；因此分数的方差比生成式小，但对提示格式与 token 一致性的依赖比生成式强。

## 例子与代码

### 1. 渲染一条 MMLU 提示

```python
# 独立运行：复刻 tasks/common.py 的 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

print(render_mc("What is the capital of France?",
                ("A", "B", "C", "D"),
                ("Paris", "London", "Berlin", "Madrid")))
```

输出为四行题干选项加一行指令；注意 `- Paris=A` 中 `=` 与 `A` 之间没有空格。若写成 `- Paris = A`，分词器会把 `" A"` 编成另一个 token，答案位置的标签 token 与 SFT 学到的回答 token 不再一致。

### 2. 手算一次字母 argmax

设某题在答案位置的四个 logits 为 $z_A=8.1$，$z_B=9.3$，$z_C=7.7$，$z_D=6.9$。softmax 后

$$
p_B=\frac{e^{9.3}}{e^{8.1}+e^{9.3}+e^{7.7}+e^{6.9}}=0.6274,
$$

其余为 $p_A=0.1890$、$p_C=0.1267$、$p_D=0.0569$。若标准答案是 B，该题计为正确；若标准答案是 A，即使 $p_A$ 排第二，该题也计为错误——categorical 判分没有部分分。

```python
import math
logits = {"A": 8.1, "B": 9.3, "C": 7.7, "D": 6.9}
m = max(logits.values())
exps = {k: math.exp(v - m) for k, v in logits.items()}   # 减去最大值保证数值稳定
total = sum(exps.values())
probs = {k: v / total for k, v in exps.items()}
print({k: round(v, 4) for k, v in probs.items()})
# 预期：{'A': 0.189, 'B': 0.6274, 'C': 0.1267, 'D': 0.0569}
pred = max(logits, key=logits.get)
print(pred)   # 预期：B
```

设另一道 ARC 题只有三个标签 A、B、C，logits 为 $7.0$、$6.5$、$6.8$，则受限 argmax 为 A。此时随机基线应为 $1/3$，但仓库仍按 0.25 计算中心化值。

### 3. 观察答案位置

```python
# 用 4 条长度不同的假提示说明组批后的索引关系
prompts = [[11, 12, 13], [11, 12, 13, 14], [11, 12], [11, 12, 13, 14, 15]]
max_length = max(len(p) for p in prompts)          # 5
answer_positions = [len(p) - 1 for p in prompts]   # [2, 3, 1, 4]
padded = [p + [0] * (max_length - len(p)) for p in prompts]
print(max_length, answer_positions)
# 预期：5 [2, 3, 1, 4]
print([row[pos] for row, pos in zip(padded, answer_positions)])
# 预期：[13, 14, 12, 15]，即每行最后一个真实 token
```

这段最小复现对应 `run_categorical_eval` 的五行准备代码。若误用 `logits[:, -1]` 取批内最后一列，只有最后一行是对的，其余三行会读到补齐位。

### 4. 运行一次 ARC 与 MMLU 评测

```bash
# 单卡快速检查：每题只取 200 条
python -m scripts.chat_eval -i sft -a 'ARC-Easy|ARC-Challenge|MMLU' -x 200

# 8 卡全量，并保存 stdout 供成绩单使用
OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.chat_eval -- \
    -i sft -a 'ARC-Easy|ARC-Challenge|MMLU' | tee chat_eval_cat.log
```

输出中每个任务先打印 `Final: n/m (x.xx%)`，再打印 `ARC-Easy accuracy: x.xx%` 形式的一行；只跑三个 categorical 任务时不会打印 ChatCORE。

## 易错点

> [!warning] 六个可检验的错误
> 1. 认为 ARC 一定是四选一、标签一定是 A 到 D。代码只断言答案在 `letters` 中，不对选项数与标签取值做任何限制；把 0.25 当作精确随机基线会在选项数不为 4 的题目上产生偏差。
> 2. 用 `logits[:, -1, :]` 取答案位置。批内各提示长度不同，最后一列是补齐位；必须用逐行的 `answer_time_positions` 索引，否则只有最长的一行判定正确。
> 3. 在 padding 之后计算答案位置。`answer_time_positions` 在补齐前由 `len(ids) - 1` 得到；若在补齐后取「第一个补齐位减一」，短提示会得到错误位置。
> 4. 认为评测会检查解释或推理过程。categorical 只读取本题候选标签 token 的 logits，模型输出分布中其余 token 完全不参与判分。
> 5. 在 `render_mc` 的 `=` 后加空格。`" A"` 与 `"A"` 是不同的 token id，这会让答案位置的标签 token 与训练时的回答 token 不一致，分数下降而难以定位。
> 6. 忽略 MMLU 的域内成分。MMLU 的 `auxiliary_train` 以 3 个 epoch 进入 SFT 混合，MMLU 分数同时反映知识与题型熟悉度；把它当作纯 held-out 泛化指标会高估模型的知识能力。

## 关联笔记

- 前置 [[评测方法论]]：两类评测的分工、ChatCORE 的聚合公式与基线约定。
- 后续 [[GSM8K与HumanEval]]：同一批任务的生成式分支，判分从 logits 换成文本解析与执行。
- 前置 [[多选与工具使用数据]]：MMLU 如何以 3 个 epoch 进入 SFT 混合，`render_mc` 在训练侧的使用方式。
- 后续 [[如何解读指标]]：为什么 categorical 的方差小于生成式，以及基线近似带来的口径不确定性。
- 跨库 [[模型评估矩阵]]：多选基准的位置偏差、污染与人类基线的通用讨论；本篇只讲 nanochat 的 categorical 实现。

## 达标检测

- [ ] 能写出 ARC 与 MMLU 的字段名、标签来源与标准答案类型，并说明两者的不同。
- [ ] 能逐字写出 `render_mc` 的输出格式，并解释为何 `=` 与字母之间不能有空格。
- [ ] 能解释 `render_for_completion` 做了什么，以及为何答案位置是提示的最后一个 token。
- [ ] 给定一批长度不同的提示，能手算 `answer_time_positions` 与补齐后的张量形状。
- [ ] 能手算 4 个 logits 的 softmax 与 argmax，并指出标准答案不同时该题的正确性。
- [ ] 能说明字母 token 缓存的断言在什么情况下失败，以及失败为何必须暴露。
- [ ] 能解释 categorical 为何比生成式宽容，并给出至少一个被宽容的具体输出形式。
- [ ] 能说明 ARC 的 0.25 基线与实际选项数的关系，并给出一个高估或低估的方向。

## 参考来源

- Clark 等, *Think you have Solved Question Answering? Try ARC, the AI2 Reasoning Challenge*（1803.05457）—— 对应 ARC 的数据构造、Easy/Challenge 划分与题目规模。
- Hendrycks 等, *Measuring Massive Multitask Language Understanding*（2009.03300）—— 对应 MMLU 的 57 学科构成、四选一格式与切分。
- Karpathy, *nanochat* `tasks/arc.py`、`tasks/mmlu.py`、`tasks/common.py`（commit 92d63d4）—— 对应字段读取、`render_mc` 与判分函数。
- Karpathy, *nanochat* `scripts/chat_eval.py`（commit 92d63d4）—— 对应 `run_categorical_eval` 的批量拼装、答案位置与字母缓存。
- Karpathy, *nanochat* `scripts/chat_sft.py`（commit 92d63d4）—— 对应 MMLU 的 3 个 epoch 训练混合与 ChatCORE 训练期评测。
- Karpathy, *nanochat* `tests/test_tasks.py`（commit 92d63d4）—— 对应「字母紧跟等号」的单元测试约束。
