w wyl123ly 的博客
MD

ARC与MMLU

22 KB 2026.10.22 原文件

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 是下标 。
  • render_mc:tasks/common.py 中的多选提示渲染函数,把题干与「选项=标签」逐行排列,并追加一句只回答字母的指令。
  • 字母 token:标签字符串经分词器编码后得到的单 token;run_categorical_eval 断言其长度为 1。
  • 答案位置(answer position):提示最后一个真实 token 的下标,模型在该位置预测下一个 token,即标签。
  • logits:模型在词表上的未归一化分数,形状 , 为批大小, 为序列长度, 为词表大小。
  • argmax:取分数最大者的下标;在受限集合上取 argmax 等价于只在该集合内选择。
  • 随机基线:均匀猜中概率;四选一为 0.25,三选一为 。
  • 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。

# 节选自 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 复刻了这一行为。

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

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)。

# 节选自 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 的完整实现只有四行,但每个字符都有理由。

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,渲染结果是:

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 循环把多个独立问题拼成一批,一次前向完成。批量拼装分五步。

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。第五步,转成 的整型张量并搬到设备。

随后一次前向得到 的 logits。逐行处理时只取答案位置的切片:

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 列表,来自缓存:

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 的选项数不固定,严格基线应逐题取 ,但 scripts/chat_eval.py 对两个 ARC 任务统一使用 0.25。这是一个约定而非推导:

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 的数据混合与训练期评测。训练混合按下面的方式构造(节选):

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 题。

关键直觉

评测把「生成一个字母」换成了「在候选标签里选一个」,因此测的是排序而不是表达能力

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

例子与代码

1. 渲染一条 MMLU 提示

# 独立运行:复刻 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 为 ,,,。softmax 后

其余为 、、。若标准答案是 B,该题计为正确;若标准答案是 A,即使 排第二,该题也计为错误——categorical 判分没有部分分。

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 为 、、,则受限 argmax 为 A。此时随机基线应为 ,但仓库仍按 0.25 计算中心化值。

3. 观察答案位置

# 用 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 评测

# 单卡快速检查:每题只取 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。

易错点

六个可检验的错误

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)—— 对应「字母紧跟等号」的单元测试约束。