---
tags: [nanochat, eval, benchmark]
阶段: 08-评测Eval
难度: ★★★
created: 2026-10-22
related: "[[CORE指标]], [[ARC与MMLU]], [[GSM8K与HumanEval]], [[如何解读指标]]"
---

# 评测方法论

## 定义

**评测方法论**指由任务集、提示模板、判分函数、聚合公式、执行环境五个要素共同构成的一套协议；同一模型在不同协议下得到的分数不可直接比较，因此任何分数都必须附带这五个要素。nanochat 的评测协议分成两类：base 模型用上下文学习（in-context learning，ICL）与续写打分，chat 模型用生成后判分或答案位置 logits 判分。

符号与术语定义如下。

- **base 模型**：只在预训练数据上训练、没有对话格式的模型，检查点目录为 `base_checkpoints`。
- **chat 模型**：在 base 之上经过 SFT 或 RL 的模型，检查点目录为 `chatsft_checkpoints` 与 `chatrl_checkpoints`。
- **ICL**：不更新参数，仅凭提示中给出的若干示例与任务描述完成新样本，模型通过前向计算对候选答案打分。
- **续写**（continuation）：提示中位于分隔符之后、需要模型给出概率的文本片段；`continuation_delimiter` 缺省为单个空格。
- **$k$-shot**：提示中示例的数量，取自 eval bundle 的 `num_fewshot` 列表首元素。
- **categorical 评测**：不生成文本，只在答案位置比较各候选字母 token 的 logits，取最大者为预测。
- **generative 评测**：先采样出文本，再用答案抽取或外部执行器判分。
- **CORE**：$K$ 个 ICL 任务中心化准确率的等权平均，$\mathrm{CORE}=\frac{1}{K}\sum_{i=1}^{K}c_i$。
- **中心化准确率**：$c_i=\dfrac{a_i-p_i}{1-p_i}$，其中 $a_i$ 为任务 $i$ 的原始准确率，$p_i$ 为其随机猜测基线（概率形式）。
- **bpb**（bits per byte）：$\mathrm{bpb}=\dfrac{\sum\text{nats}}{\ln 2\cdot\sum\text{bytes}}$，把逐 token 的交叉熵换算到逐字节。
- **ChatCORE**：5 个 chat 任务中心化准确率的等权平均，取值 0 表示随机水平，1 表示满分。
- **pass@$k$**：每题采样 $k$ 个解，至少一个通过即算该题通过，再对题目求平均。
- **MBU**（model bandwidth utilization）：解码阶段实际搬运字节数与 GPU 峰值带宽之比，衡量实现距离带宽上限的程度。
- **$w$**：模型权重的存储字节数，每个解码步都要完整读一遍。
- **$B$**：解码批大小；$\text{kv\_read}$：单行在给定上下文下每步读取的 KV 字节数。
- **$\text{tpot}$**：time per output token，解码阶段每生成一个 token 的中位耗时。
- **数据污染**（contamination）：评测样本或其答案出现在训练语料中，使分数包含记忆成分。
- **`max_per_task`**：每个 CORE 任务最多评测的样本数，用于快速近似。

## 为什么重要

评测方法解决的是「一次训练是否值得保留」这一决策问题，而决策需要四个彼此不能替代的答案。

第一，预训练是否有效，由 CORE 回答。CORE 固定了 22 个任务、提示模板、few-shot 数与打分规则，因此可以跨数据、跨架构、跨训练时长比较；没有它，一次换数据后的训练只能看到 loss 曲线，无法判断能力是否提升。第二，压缩质量是否提升，由 bpb 回答。bpb 与词表大小无关，换 tokenizer 后仍可比，且方差远小于 CORE，适合每 250 步监控。第三，对话是否可用，由 ChatCORE 的 5 个任务回答。CORE 高的 base 模型不一定会遵循对话格式，SFT 与 RL 的效果必须在 chat 协议下单独测量。第四，部署是否可行，由 MBU 与延迟回答。CORE 相同的两个模型，若一个的 KV 读取量是另一个的两倍，单位成本就不同。

缺少任一答案都会导致错误决策。只报 CORE 会漏掉对话退化；只报 ChatCORE 会漏掉 base 能力被 RL 侵蚀；只报 bpb 会在换数据时得到不可比的两个数字——`dev/LEADERBOARD.md` Run 4 明确注明该次 `val_bpb` 因数据分布从 FineWeb-EDU 换成 ClimbMix 而不可与前三次比较；只报准确率而不报样本量，则无法判断两个分数之差是否超出抽样波动。

在「懂原理、能复现、懂工程」三个维度中，本篇主要承担后两个：原理部分只给出五个指标的定义与聚合公式，工程部分是脚本接口、分布式聚合、随机种子与产物落盘。

## 原理与推导

### 1. 两条流水线：判分发生在生成之前还是之后

评测的根本差别不在模型，而在判分发生在生成的哪个阶段。base 模型没有被训练成「回答字母」，它的原生能力是给任意 token 序列分配概率，因此 base 侧把候选答案当作续写，直接读取其对数似然。chat 模型被训练成在 `<|assistant_start|>` 之后给出回答，因此 chat 侧必须按对话格式渲染提示，再决定是读取答案位置的 logits，还是真的采样出文本。

| 维度 | base 评测 | chat 评测 |
|---|---|---|
| 入口 | `scripts/base_eval.py` | `scripts/chat_eval.py` |
| 模型 | 固定加载 `base_checkpoints`（`load_model("base", ...)`） | `-i sft` 或 `-i rl` |
| 提示 | eval bundle 的 Jinja 模板 + few-shot | `render_conversation` / `render_for_completion` |
| 判分时机 | 生成之前：对每条候选续写算平均损失 | categorical 在生成之前读 logits；generative 在生成之后解析文本 |
| 指标 | CORE、bpb | ChatCORE、单任务准确率 |
| 计算量 | 每样本一次前向，批内并行 | categorical 每批一次前向；generative 逐题解码 |

这张表解释了一个常见误解：chat 侧的 categorical 评测既不生成也不属于 base 评测。它使用 chat 模板与 `<|assistant_start|>`，只是把「生成字母」换成「读答案位置那个字母的 logit」，因此它同时依赖 base 能力与 SFT 学到的格式。

### 2. base 侧：ICL 与续写打分

CORE 的每个样本都渲染成一段文本：若干 few-shot 示例、当前问题、分隔符、候选续写。三类任务的判别对象不同。

- **multiple_choice**：各候选共享同一段上下文，只有选项文本不同。用 `find_common_length(tokens, direction='left')` 找公共前缀长度 $s$，每条候选的终点为 $e_j$，取平均交叉熵最小的候选。
- **schema**：各候选上下文不同、续写相同，公共部分是后缀，用 `direction='right'` 找。
- **language_modeling**：渲染「不含续写」与「含续写」两条提示，断言前者是后者的 token 前缀，再逐 token 比较贪心预测是否全命中。

三条分支共用一次整批前向：`forward_model` 用 `torch.roll(input_ids, shifts=-1, dims=1)` 得到自回归目标，逐位置算交叉熵，最后一列置 `nan`。多选任务的判别式为

$$
\ell_j=\frac{1}{e_j-s}\sum_{t=s-1}^{e_j-2}\mathrm{CE}_t,\qquad \hat j=\arg\min_j \ell_j .
$$

CORE 的完整推导、22 任务构成与续写边界对齐见 [[CORE指标]]，本篇只强调协议层的两个事实：few-shot 示例由 `random.Random(1234 + idx)` 现场抽取且排除样本自身；数据在评测前用 `random.Random(1337)` 打乱，`max_per_task` 的截断发生在此之后。

### 3. bpb：与词表无关的连续指标

CORE 是离散、方差大的能力分数；bpb 是连续、低方差的压缩率。`nanochat/loss_eval.py` 的 `evaluate_bpb` 不取平均损失，而是分别累加总 nats 与目标 token 的总字节数，再相除：

```python
# 逐批累加：分子是损失乘以「该 token 是否计入」，分母是字节数
num_bytes2d = token_bytes[y]                     # (B*T,)，特殊 token 的字节数为 0
total_nats += (loss2d * (num_bytes2d > 0)).sum()
total_bytes += num_bytes2d.sum()
# ignore_index 的慢路径与分布式 all_reduce 见 `nanochat/loss_eval.py` 的完整实现
bpb = total_nats / (math.log(2) * total_bytes)   # ln2 把 nats 换成 bits
```

三个设计点：特殊 token 的 `token_bytes` 为 0，因此不进入分母也不贡献分子；`ignore_index` 为负的目标位先被掩掉，避免用负下标索引 `token_bytes`；分布式下两个累加量各自 `all_reduce` 求和后再相除，而不是先算各 rank 的 bpb 再平均——后者会给字节数不同的 rank 相同权重。

bpb 与词表无关的原因在分母：词表越大，单 token 覆盖的字节数越多，平均每 token 损失通常越低，但除以字节数后两个模型回到同一单位。代价是它与数据分布强绑定，换数据集后不可比。

### 4. chat 侧：categorical 与 generative

`run_chat_eval` 按 `task_object.eval_type` 分派。categorical 分支用于 ARC-Easy、ARC-Challenge、MMLU：整批前向一次，取每行最后一个提示 token 位置（`answer_time_positions`）上各候选字母的 logit，`argmax` 即预测。generative 分支用于 GSM8K、HumanEval：逐题解码，再用答案抽取或沙箱执行判分。

| 任务 | eval_type | 数据与切分 | 判分函数 |
|---|---|---|---|
| ARC-Easy | categorical | `allenai/ai2_arc`，`ARC-Easy`，`test` | 预测字母与 `answerKey` 相等 |
| ARC-Challenge | categorical | `allenai/ai2_arc`，`ARC-Challenge`，`test` | 同上 |
| MMLU | categorical | `cais/mmlu`，`all`，`test` | 预测字母等于 `letters[answer]` |
| GSM8K | generative | `openai/gsm8k`，`main`，`test` | `####` 后数值字符串相等 |
| HumanEval | generative | `openai/openai_humaneval`，`openai_humaneval`，`test` | 拼接测试后执行成功 |

两项任务的实现细节分别见 [[ARC与MMLU]] 与 [[GSM8K与HumanEval]]。

### 5. ChatCORE 的构造

`scripts/chat_eval.py` 末尾给出 ChatCORE：

```python
baseline_accuracies = {
    'ARC-Easy': 0.25, 'ARC-Challenge': 0.25, 'MMLU': 0.25,
    'GSM8K': 0.0, 'HumanEval': 0.0,
}
centered_acc = (acc - baseline_acc) / (1.0 - baseline_acc)
chatcore_metric = centered_mean / len(results)
```

三个约定必须记住。第一，只有 5 个任务全部评测过才计算 ChatCORE（`all_tasks_were_evaluated`），只跑两项任务时脚本不打印总分。第二，$1-\text{baseline}$ 是归一化分母：四选一任务答对 0.40 映射为 0.20，开式任务答对 0.10 映射为 0.10。第三，基线与「随机猜测概率」并不严格相等：ARC 各题的选项数并不固定，但脚本对所有多选任务统一使用 0.25，因此基准值本身是一个近似，这一点在 [[如何解读指标]] 中作为口径不确定性讨论。

`scripts/chat_sft.py` 在训练中每 `--chatcore-every=200` 步复算一次，并额外记录 `chatcore_cat`（仅 3 个 categorical 任务的均值）；`--chatcore-max-cat=-1` 表示 categorical 任务全量，`--chatcore-max-sample=24` 表示两个生成任务各只取 24 题，这是训练期快速估计与最终评测的关键差异。

### 6. pass@k 的两种口径

`scripts/chat_eval.py` 的生成循环对每题采样 `num_samples` 个解，`passed = any(outcomes)`，因此报告的准确率是「至少一个解通过」的比例。当 `num_samples=1`（命令行默认）时它就是 pass@1；当 `num_samples=k` 时它是

$$
\widehat{\text{pass@}k}_{\text{naive}}=\frac{1}{N}\sum_{i=1}^{N}\mathbb{1}\left[\exists\,j\le k:\ y_{ij}\ \text{通过}\right],
$$

即对每题取前 $k$ 个样本做逻辑或。HumanEval 原论文为避免高方差，给出的是无偏估计量

$$
\widehat{\text{pass@}k}=1-\frac{\binom{n-c}{k}}{\binom{n}{k}},
$$

其中 $n$ 为每题采样总数、$c$ 为通过数。两者在 $n=k$ 时相同，在 $n>k$ 且样本相关时不同：naive 版本只用了前 $k$ 个样本，且 $k$ 越大越依赖采样顺序。`scripts/chat_rl.py` 的评测正是 naive 版本，它对 $k=1,\dots,B$ 逐个计算「前 $k$ 个样本中是否至少一个正确」，温度固定 1.0，每题上限由 `--eval-examples=400` 控制。

### 7. MBU：评测的代价轴

解码阶段每生成一个 token 都要重读全部权重与 KV 缓存，算术量极小，因此受显存带宽约束；预填充一次并行处理整段提示，受算力约束。`scripts/infer_bench.py` 把这两段分开测量，并定义

$$
\mathrm{MBU}=100\cdot\frac{w+B\cdot\text{kv\_read}}{\text{tpot}}\Big/\text{peak\_bw},
$$

其中 $w$ 为 `weight_bytes(model)`，`kv_read` 取自模型的 `kv_read_bytes(context_mid)`。batch 1 时每步至少搬运全部权重与一行 KV，MFU 极低；batch 增大后 KV 读取量线性增加，MBU 上升，直到算力成为瓶颈。该脚本还打印 $w/(\text{peak\_bw}\cdot\text{kv\_read})$ 推出的 batch 1 吞吐上限，以及显存能容纳的满上下文行数。MBU 与其他指标的关系是：它不衡量智能，只衡量同样的智能要花多少带宽；架构改动（GQA、sliding window）会直接改变分母中的 KV 读取量。解码机制的推导见 [[KV Cache原理]]。

### 8. 中心化准确率的动机

不同任务的随机基线不同：四选一为 0.25，二选一为 0.5，逐 token 全匹配的语言建模接近 0。若直接平均原始准确率，二选一任务会被高估、开式任务会被低估。中心化把「猜中概率」从分子与分母同时扣掉：

$$
c=\frac{a-p}{1-p},\qquad p=\frac{b}{100}.
$$

它满足三条性质：$a=p$ 时 $c=0$，$a=1$ 时 $c=1$，$1-p$ 越小（任务越难猜）单位准确率的权重越大。CORE 与 ChatCORE 都用这一变换，因此两者落在「0 为随机、1 为满分」的同一尺度上；这是两个指标可以放在同一坐标上读的原因，但它们的任务集不同，仍不能互相替代。

### 9. 分布式评测：all_reduce 与 max_per_task

三条评测路径的聚合方式一致但实现不同。

- **CORE**：`evaluate_task` 为每个 rank 分配 `range(rank, len(data), world_size)` 的样本，写入长度为 `len(data)` 的 `correct` 张量，`barrier` 后 `all_reduce(SUM)`，再对全体样本求均值。零张量初始化保证未被本 rank 评测的位置贡献 0。
- **generative**：各 rank 只累加自己的 `num_passed` 与 `total`，`all_reduce(SUM)` 后相除，因此题目数不整除卡数时不会给某个 rank 过高权重。
- **bpb**：总 nats 与总 bytes 分别 `all_reduce`，再相除，避免「各 rank bpb 的算术平均」这一错误聚合。

`max_per_task` 用于快速近似：先用 `random.Random(1337)` 打乱，再截断到前 $n$ 条。它不是全量评测的随机子集意义上的无偏估计——截断改变了 `len(data)`，而 few-shot 采样池的大小依赖 `len(data)`，因此示例集合也随之改变。训练期的默认值是 500（`--core-metric-max-per-task=500`），最终评测用 -1 全量。

### 10. 可复现性：seed、shuffle 与 prompt 渲染

| 随机源 | 固定方式 | 影响 |
|---|---|---|
| 全局与 CUDA 种子 | `compute_init` 中 `torch.manual_seed(42)`、`torch.cuda.manual_seed(42)` | 采样与初始化 |
| few-shot 抽样 | `random.Random(1234 + idx)`，排除自身 | 每条样本的示例固定 |
| CORE 数据顺序 | `random.Random(1337).shuffle(data)` | 全量与子集评测的样本顺序 |
| 任务数据集顺序 | `HubDataset.shuffle(seed=42)`，复刻 `datasets` 的置换 | ARC/MMLU/GSM8K/HumanEval 的题目顺序 |
| 生成采样 | `Engine.generate` 的 `seed=42` 固定 `torch.Generator` | 温度大于 0 时的采样序列 |
| 评测精度 | `base_train` 的 CORE 评测包在 `disable_fp8` 中 | 训练用 fp8、评测用 bf16 |

提示渲染同样属于协议：`render_prompts_mc` 用 Jinja 模板，模板结尾 `.strip()`；语言建模分支还会对「不含续写」的提示再次 `strip()`，原因是数据集自带尾随空白，不去掉会让续写前缀在 token 空间里对不齐。分词是最后一个不可忽略的变量：`" A"` 与 `"A"` 是不同的 token id，因此 `render_mc` 要求字母紧跟 `=` 且不带空格，否则答案位置比较的 token 与 SFT 学到的回答 token 不是同一个。

真正不可复现的部分在训练侧：`dev/LEADERBOARD.md` Run 4 记录了同一命令 7 次独立运行，CORE 从 0.25119 到 0.26765，极差 0.01646；Run 5 的 5 次均值为 0.2690，Run 6 的 5 次均值为 0.262634。因此「可复现」在评测侧的准确含义是：给定检查点与协议，评测结果可复现到浮点误差；而检查点本身来自一次不可完全复现的训练。

### 指标—任务—脚本对照表

| 指标 | 度量对象 | 任务或数据 | 脚本与函数 | 输出位置 | 随机基线 |
|---|---|---|---|---|---|
| CORE | base 的 ICL 能力 | 22 个 ICL 任务 | `scripts/base_eval.py` → `core_eval.evaluate_task` | `base_eval/base_model_{step:06d}.csv` 末行 | 各任务 `eval_meta_data.csv` |
| bpb | 压缩率 | 训练/验证 split | `loss_eval.evaluate_bpb` | stdout 的 `train bpb` / `val bpb` | 无 |
| ChatCORE | chat 综合能力 | ARC-Easy、ARC-Challenge、MMLU、GSM8K、HumanEval | `scripts/chat_eval.py` 末尾 | stdout 的 `ChatCORE metric` | 0.25 与 0 |
| 单任务准确率 | 单项能力 | 同上 | `run_categorical_eval` / `run_generative_eval` | stdout 的 `X accuracy` | 同上 |
| pass@k | 生成任务的通过率 | GSM8K（RL 阶段） | `scripts/chat_rl.py` 的 `run_gsm8k_eval` | stdout 与 wandb 的 `pass@k` | 0 |
| MBU | 解码的带宽利用率 | 人工提示，固定 token 数 | `scripts/infer_bench.py` | stdout 末行 JSON 的 `sweep` | 无 |

### 在 nanochat 中的落地

第一处是 `nanochat/core_eval.py`。它把「任务类型、提示渲染、批量拼装、判分」四件事收敛到 `evaluate_example` 一个函数，三类任务共用 `forward_model` 的一次前向。去掉这个统一层，22 个任务就需要 22 套判分代码，`max_per_task` 与分布式聚合也无法复用。

第二处是 `nanochat/loss_eval.py` 的 `evaluate_bpb`。它接收 `token_bytes` 而非词表大小，因此把「哪些 token 不计分」交给调用方（特殊 token 的字节数为 0）。去掉这个参数，bpb 会把 `<|bos|>` 等特殊 token 算进分母，换分词器后数值失真。

第三处是 `scripts/chat_eval.py` 的两个循环。categorical 循环按批并行、逐行取答案位置；generative 循环逐题调用 `generate_batch` 并做 `any()`。两个循环的聚合代码几乎相同，差别在于判分粒度：前者是一个 token 的 argmax，后者是一整段生成文本的解析结果。

第四处是 `scripts/chat_sft.py` 的 ChatCORE 段。它用 `device_batch_size` 作为 categorical 批大小、`chatcore_max_sample=24` 限制生成任务题数，并在 `wandb_run.log` 中记录 `chatcore_metric`、`chatcore_cat` 与每个任务的 `chatcore/<task>`。这些键是训练曲线与最终成绩单之间的接口。

第五处是 `scripts/infer_bench.py`。它要求单卡 CUDA（`assert ddp_world_size == 1`），把可读卡片与最后一行 JSON 同时输出，使评测可以被人阅读、也可以被脚本消费。丢弃末行 JSON，成绩单就只能靠正则解析人类可读文本。

## 关键直觉

> [!tip] 两类评测的差别不在模型，而在「谁选下一个 token」
> 续写打分让模型为每个候选续写分配概率，判分者直接读这些概率，模型从不真正「选」一个 token；生成式评测让模型自己选 token，再由外部程序解析结果。categorical 评测是二者的杂交：提示按 chat 格式渲染，判分却只读答案位置那一个 token 的 logits。这个视角解释了三个现象：base 模型无法用字母准确率评测（它没有被训练成回答字母，答案位置的 logits 没有格式保证）；chat 模型的 categorical 分数对提示格式敏感（字母 token 必须与训练时的回答 token 一致）；生成式评测的方差通常大于 categorical（采样与解析都引入额外随机性）。与严格定义的关系：三个分支的判分函数不同，但都归结为「在某个 token 位置比较模型给候选分配的分数或由候选生成的结果」。

## 例子与代码

### 1. 手算一次 ChatCORE

取一组假设准确率，按 `scripts/chat_eval.py` 的公式逐项计算。

| 任务 | 准确率 $a$ | 基线 $p$ | $c=(a-p)/(1-p)$ |
|---|---|---|---|
| ARC-Easy | 0.40 | 0.25 | 0.2000 |
| ARC-Challenge | 0.28 | 0.25 | 0.0400 |
| MMLU | 0.30 | 0.25 | 0.0667 |
| GSM8K | 0.10 | 0.00 | 0.1000 |
| HumanEval | 0.05 | 0.00 | 0.0500 |
| 合计 | | | 0.4567 |

均值为 $0.4567/5=0.0913$。这说明一个反直觉的事实：5 个任务里有 3 个的原始准确率接近随机，ChatCORE 仍然为正，因为开式任务以 0 为基线，任何通过都计入分子。

```python
# 与仓库公式逐字对应：基线用概率，不用百分数
baselines = {"ARC-Easy": 0.25, "ARC-Challenge": 0.25, "MMLU": 0.25,
             "GSM8K": 0.0, "HumanEval": 0.0}
accs = {"ARC-Easy": 0.40, "ARC-Challenge": 0.28, "MMLU": 0.30,
        "GSM8K": 0.10, "HumanEval": 0.05}
centered = {k: (accs[k] - b) / (1.0 - b) for k, b in baselines.items()}
print({k: round(v, 4) for k, v in centered.items()})
print(round(sum(centered.values()) / len(centered), 4))
# 预期：{'ARC-Easy': 0.2, 'ARC-Challenge': 0.04, 'MMLU': 0.0667, 'GSM8K': 0.1, 'HumanEval': 0.05}
# 预期：0.0913
```

### 2. 手算一次 bpb

设两个目标 token 分别占 2 字节与 1 字节，交叉熵为 $\ln 4=1.3863$ 与 $\ln 2=0.6931$ nats。则

$$
\mathrm{bpb}=\frac{1.3863+0.6931}{\ln 2\times(2+1)}=\frac{2.0794}{2.0794}=1.0 .
$$

即平均每个字节需要 1 bit。若换一个词表，把这两个 token 合并为一个 3 字节 token、损失为 $\ln 8=2.0794$，分子与分母同比变化，bpb 仍为 1.0。这就是 bpb 跨词表可比的最小例子。

### 3. 复现 naive pass@k

```python
# 3 道题，每题 4 个采样，True 表示该样本通过
outcomes = [
    [False, True,  False, False],
    [False, False, False, False],
    [True,  False, False, True ],
]
for k in (1, 2, 4):
    passed = sum(any(row[:k]) for row in outcomes) / len(outcomes)
    print(f"pass@{k} = {passed:.3f}")
# 预期：pass@1 = 0.333，pass@2 = 0.667，pass@4 = 0.667
```

注意 pass@2 与 pass@4 相同：两处可能通过的位置在 $k=2$ 时都已包含至少一个通过样本（第一题的第 2 个样本、第三题的第 1 个样本），第 4 个样本不改变结果。这个例子说明 prefix-any 估计量只依赖前 $k$ 个样本的排列，而不是全部 $n$ 个样本的通过数。若改用无偏估计量，第一题 $n=4,c=1$ 时 $k=2$ 的贡献为 $1-\binom{3}{2}/\binom{4}{2}=0.5$，第三题 $n=4,c=2$ 时为 $1-\binom{2}{2}/\binom{4}{2}=0.833$，三题均值为 $(0.5+0+0.833)/3=0.444$，与 prefix-any 的 0.667 不同。差别来自无偏估计量使用了全部 4 个样本的通过总数，而 prefix-any 只看前两个样本。

### 4. 运行三种评测

```bash
# base：CORE 与 bpb，CSV 落在 ~/.cache/nanochat/base_eval/
OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.base_eval -- \
    --model-tag=d24 --eval=core,bpb --max-per-task=-1

# chat：5 任务与 ChatCORE，stdout 重定向便于汇总
OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.chat_eval -- \
    -i sft -a 'ARC-Easy|ARC-Challenge|MMLU|GSM8K|HumanEval' | tee chat_eval_sft.log

# 推理：末行 JSON 供脚本消费
python -m scripts.infer_bench -i sft -g d24 | tee infer_bench.log
```

## 易错点

> [!warning] 六个可检验的错误
> 1. 把 base 评测方法套到 chat 模型上。chat 模型的 `<|assistant_start|>` 与特殊 token 只在对话模板下出现，用 `core_eval` 的续写模板评测 chat 检查点，得到的数字不对应任何已定义的指标；chat 侧必须走 `scripts/chat_eval.py`。
> 2. 把 `any(outcomes)` 当成无偏 pass@k。它只用前 $k$ 个样本，且 `num_samples` 默认 1 时就是 pass@1；报告 pass@k 必须写明 $k$ 与采样温度，仓库内 chat_eval 为 0.0、RL 评测为 1.0，两者不可混用。
> 3. 认为 `max_per_task` 的结果是全量结果的子集均值。截断同时改变了 few-shot 采样池，500 条子集的 CORE 与全量 CORE 存在系统性偏差，不能用来替代最终数字。
> 4. 在 bpb 前面加「更小更好」的绝对阈值。bpb 依赖数据分布，Run 4 换数据后同比不可用；只有同一数据、同一 tokenizer 下的 bpb 才能比较。
> 5. 把 ChatCORE 的 0.25 基线当作所有多选任务的精确随机概率。ARC 的选项数并不固定，脚本统一取 0.25，因此该基线是约定值而非严格随机概率。
> 6. 忽略评测精度切换。`base_train` 在 CORE 评测前调用 `disable_fp8`，如果自己在 fp8 下评测，得到的 CORE 与 leaderboard 口径不一致。

## 关联笔记

- 前置 [[CORE指标]]：22 任务、续写边界与中心化公式的完整推导；本篇只保留协议层接口，不重复推导。
- 后续 [[ARC与MMLU]]：categorical 分支的逐段实现与 `render_mc` 的 token 约束。
- 后续 [[GSM8K与HumanEval]]：generative 分支的答案抽取、沙箱执行与 pass@k 口径。
- 后续 [[生成report成绩单]]：把本篇列出的产物组装成一张可复算的表。
- 后续 [[如何解读指标]]：二项标准误、运行间波动与指标冲突的统计处理。
- 跨库 [[模型评估矩阵]]：通用评估维度、污染检测与提示敏感性的系统讨论；本篇只讲 nanochat 的落地口径。

## 达标检测

- [ ] 能写出 base 与 chat 两条评测流水线的入口脚本、模型目录与判分时机。
- [ ] 能写出 CORE、bpb、ChatCORE、pass@k、MBU 五个指标的定义式，并指出各自的随机基线。
- [ ] 能手算 5 任务 ChatCORE 得到 0.0913，并解释为何 3 个任务接近随机时总分仍为正。
- [ ] 能说明 `evaluate_task` 中零张量初始化与 `all_reduce(SUM)` 的配合，以及为什么不能先算各 rank 均值再平均。
- [ ] 能解释 `max_per_task` 为什么会改变 few-shot 采样池，并给出一个具体后果。
- [ ] 能写出 naive pass@k 与无偏估计量的公式，并说明两者在 $n=k$ 与 $n>k$ 时的差别。
- [ ] 能计算 batch 1 与 batch 8 下的 MBU 分子，并说明批量增大时 MBU 上升的机制。
- [ ] 能列出评测侧的五个随机源与各自的固定方式，并指出哪一部分本质上不可复现。

## 参考来源

- DCLM 团队, *DataComp-LM: In search of the next generation of training sets for language models*（2406.11794）—— 对应 CORE 的 22 任务协议与中心化定义。
- Karpathy, *nanochat* `nanochat/core_eval.py`、`scripts/base_eval.py`（commit 92d63d4）—— 对应 base 侧 ICL 渲染、三类任务判分、分布式聚合与 CSV 产物。
- Karpathy, *nanochat* `scripts/chat_eval.py`、`scripts/chat_sft.py`（commit 92d63d4）—— 对应 categorical/generative 分派、ChatCORE 基线与训练期记录。
- Karpathy, *nanochat* `nanochat/loss_eval.py`（commit 92d63d4）—— 对应 bpb 的求和相除实现与特殊 token 掩码。
- Karpathy, *nanochat* `scripts/infer_bench.py`（commit 92d63d4）—— 对应 MBU 的定义、批扫描与末行 JSON 输出。
- Chen 等, *Evaluating Large Language Models Trained on Code*（2107.03374）—— 对应 pass@k 的无偏估计量与 HumanEval 协议。
