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

# 对话数据与SmolTalk

## 定义

**对话数据**（conversation data）指以消息序列组织的监督微调样本：每条消息由角色（role）与内容（content）两个字段构成，角色取 `system`、`user`、`assistant` 之一，内容为该角色发言的字符串。**SmolTalk** 指 HuggingFace 数据集 `HuggingFaceTB/smol-smoltalk` 及其在 `tasks/smoltalk.py` 中的 `Task` 封装。**Task** 是 nanochat 对「数据集 + 元数据 + 评测准则」的统一抽象，提供长度、切片、逐条取对话与判分四个接口。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $C$ | 一条对话（conversation），即含 `messages` 键的字典 |
| $M$ | 对话中消息条数，$M\ge 2$ |
| $r_i$ | 第 $i$ 条消息的角色，$i=0,\dots,M-1$ |
| $c_i$ | 第 $i$ 条消息的内容字符串 |
| $\mathbf{u}=(u_1,\dots,u_L)$ | 一条对话渲染后的 token id 序列 |
| $\mathbf{m}=(m_1,\dots,m_L)$ | 与 $\mathbf{u}$ 等长的损失掩码，$m_t\in\{0,1\}$ |
| $L$ | 渲染后的 token 长度，渲染时截断到 2048 |
| $N$ | 一个 `Task` 的逻辑样本数 |

渲染（render）指把消息序列映射为 token 序列与掩码，由 `RustBPETokenizer.render_conversation` 完成。**混合**（mixture）指把多个 `Task` 的样本交错成一条训练流，由 `TaskMixture` 完成。**切片**（slicing）指用 `start`/`stop`/`step` 在不复制数据的前提下取子集，由 `Task` 基类完成。**打包**（packing）指把多条渲染后的对话首尾相接填入长度为 `max_seq_len` 的固定行。`HubDataset` 是 `datasets.Dataset` 的最小替代品，用本地 parquet 分片提供惰性行访问与带种子的置换。

## 为什么重要

预训练只让模型学会在文档分布上做下一 token 预测，模型没有「角色」概念：给定一段用户提问，它更可能续写更多提问，而不是给出回复。SFT 把行为从续写改写为应答，而行为的上限由数据决定。在 `scripts/chat_sft.py` 的训练混合中，SmolTalk 提供 460K 条通用对话；MMLU 的 3 个 epoch 提供 300K 条多选样本；GSM8K 的 4 个 epoch 提供 32K 条带工具调用的数学样本。按行数计，通用对话占 $460/792\approx58\%$，是唯一提供「指令—回复」分布的任务，其余两个任务只负责格式与工具协议。

去掉 SmolTalk 会得到什么结果，可以从另外两个任务的结构直接推出。MMLU 的监督目标是单个字母，GSM8K 的监督目标是算式与 `####` 数值，二者都不包含开放式的自然语言回复。只用这两个任务训练，模型会把所有输入都当作「需要输出一个短符号」的请求：它学会多选格式与计算器协议，但不具备多轮对话、解释、拒绝与追问的能力。

在「懂原理 / 能复现 / 懂工程」三条主线中，本篇属于能复现与懂工程。能复现要求数据可稳定重放：`HubDataset` 用固定种子的置换替代 `datasets` 库，使同一份代码在任何机器上给出同一条样本顺序；懂工程要求知道缓存在哪里、由哪个进程下载、失败后如何恢复，以及一条样本进入训练前会经过几次变换。这些细节不改变目标函数，却直接决定实验能否复现、8 卡训练会不会互相踩踏。

## 原理与推导

### 1. 规模、来源与使用方式

`tasks/smoltalk.py` 的类注释给出规模：「train is 460K rows, test is 24K rows」。数据来源是 HuggingFace 的 SmolTalk，它由 SmolLM2 的训练流程构造，混合了对话合成数据与数学推理数据；repo 注释说明选用 `smol` 版本的原因是「more appropriate for smaller models」，即完整版规模更大，面向更宽的模型族，而 nanochat 的模型容量与训练步数都按小模型设定。

在 nanochat 中的使用方式由 `chat_sft.py` 的两处构造决定。

| 用途 | 构造 | 行数 |
|---|---|---|
| 训练混合 | `SmolTalk(split="train")` | 460K |
| 验证混合 | `SmolTalk(split="test")` | 24K |

训练混合中 SmolTalk 只出现一次，MMLU 与 GSM8K 通过重复构造对象出现过采样，这是 `TaskMixture` 的设计约定：把一个 `Task` 在列表里传多次即等于过采样，不需要修改采样概率。

### 2. 对话 schema 与三层断言

一条 SmolTalk 样本在内存中是一个字典，`messages` 键下是消息列表。

```json
{"messages": [
  {"role": "system", "content": "You are a helpful assistant."},
  {"role": "user", "content": "What is the capital of France?"},
  {"role": "assistant", "content": "Paris."}
]}
```

`SmolTalk.get_example` 在返回前做三层校验，逐条对应数据格式的假设。

```python
def get_example(self, index):
    row = self.ds[index]
    messages = row["messages"]
    # 断言一：至少一条消息；首条若为 system 则允许，其余部分独立校验
    assert len(messages) >= 1
    first_message = messages[0]
    if first_message["role"] == "system":
        rest_messages = messages[1:]  # optional system message is OK
    else:
        rest_messages = messages
    # 断言二：除去 system 后至少 user 与 assistant 两条
    assert len(rest_messages) >= 2, "SmolTalk messages must have at least 2 messages"
    for i, message in enumerate(rest_messages):
        # 断言三：user 与 assistant 严格交替，且从 user 开始
        expected_role = "user" if i % 2 == 0 else "assistant"
        assert message["role"] == expected_role, f"Message {i} has role {message['role']} but should be {expected_role}"
        assert isinstance(message["content"], str), "Content must be a string"
    conversation = {"messages": messages}
    return conversation
```

第一层断言排除空样本。第二层断言要求至少有一问一答：只有一条 `user` 消息的样本无法产生监督信号，因为渲染后不存在 assistant 段。第三层断言是格式的核心：$r_0=\texttt{user}$、$r_1=\texttt{assistant}$，依次交替；不允许两条连续 `user`，也不允许在中间插入第二条 `system`。这一条与渲染器的假设必须一致，`render_conversation` 内部同样断言 `must_be_from = "user" if i % 2 == 0 else "assistant"`，两处不一致会导致训练时才在某个 batch 上崩溃。

第三层断言还要求 `content` 是字符串。GSM8K 的 assistant 内容是分片列表（`text`/`python`/`python_output` 字典组成的 list），SmolTalk 显式排除这种类型；如果错误地把两种数据混在同一个 `Task` 里，断言会在取数时失败，而不是在渲染时静默产生错误的掩码。

### 3. HubDataset：用 parquet 替代 datasets 库

`tasks/common.py` 顶部没有导入 `datasets`，而是用 `pyarrow` 与 `filelock` 实现了一个最小替身。动机是依赖面：`pyarrow` 在训练环境中已经因 parquet 与其他依赖存在，而 `datasets` 库带来额外的版本约束与导入开销；nanochat 只需要「按行取字典」与「带种子的 shuffle」两项能力。

`load_hub_dataset` 的流程是五行。

```python
def load_hub_dataset(repo_id, subset="default", split="train"):
    base_dir = get_base_dir()
    slug = repo_id.replace("/", "--")
    shards_dir = os.path.join(base_dir, "task_data", slug, subset, split)
    # manifest 最后写入，因此它的存在等价于下载完成
    manifest_path = os.path.join(shards_dir, "manifest.json")
    if not os.path.exists(manifest_path):
        os.makedirs(shards_dir, exist_ok=True)
        with FileLock(manifest_path + ".lock"):
            # 只有一个 rank 拿到锁并下载，其余 rank 阻塞后重查 manifest 并跳过
            if not os.path.exists(manifest_path):
                listing_url = f"https://huggingface.co/api/datasets/{repo_id}/parquet/{subset}/{split}"
                with urllib.request.urlopen(listing_url) as response:
                    shard_urls = json.loads(response.read())
                filenames = []
                for shard_index, shard_url in enumerate(shard_urls):
                    filename = f"{shard_index:05d}.parquet"
                    with urllib.request.urlopen(shard_url) as response:
                        content = response.read()
                    with open(os.path.join(shards_dir, filename), "wb") as f:
                        f.write(content)
                    filenames.append(filename)
                with open(manifest_path, "w") as f:
                    json.dump(filenames, f)
    with open(manifest_path, "r") as f:
        filenames = json.load(f)
    shard_paths = [os.path.join(shards_dir, filename) for filename in filenames]
    tables = [pq.read_table(path) for path in shard_paths]
    table = pa.concat_tables(tables)
    return HubDataset(table)
```

hub API 的 `parquet` 端点返回该数据集的自动导出分片 URL 列表，nanochat 不需要知道上游格式：CSV、JSONL 或 Arrow 上游都会被统一导出为 parquet。缓存目录按 `repo_id`（`/` 替换为 `--`）、subset、split 三级组织，物理位置在 `$NANOCHAT_BASE_DIR`（默认 `~/.cache/nanochat`）下的 `task_data/`。分布式训练时 8 个 rank 同时启动，`FileLock` 保证只有一个进程下载，其余进程在锁上阻塞；拿到锁后先重查 manifest，已存在则直接返回，不重复下载。

manifest 最后写入，使得「manifest 存在」等价于「全部 shard 已落盘」。这个顺序是一种廉价的原子提交：下载中途崩溃会留下部分 shard 但没有 manifest，下次启动会重新下载并覆盖；反之若先写 manifest 再下载，崩溃后会永久认为数据完整。

`HubDataset` 只承担两件事。

```python
class HubDataset:
    def __init__(self, table, permutation=None):
        self.table = table
        self.permutation = permutation

    def __len__(self):
        return self.table.num_rows

    def shuffle(self, seed):
        # matches datasets.Dataset.shuffle(seed=seed) exactly, row order comes out identical
        permutation = np.random.default_rng(seed).permutation(len(self))
        return HubDataset(self.table, permutation)

    def __getitem__(self, index):
        physical_index = index if self.permutation is None else int(self.permutation[index])
        row = {column: self.table[column][physical_index].as_py() for column in self.table.column_names}
        return row
```

置换与物理访问分离：`shuffle` 不移动数据，只记录一个逻辑下标到物理下标的映射；`__getitem__` 先查表再取行。`np.random.default_rng(seed).permutation` 与 `datasets.Dataset.shuffle` 使用同一算法，因此同样的 `seed=42` 在两个实现下给出同一顺序，这是从 `datasets` 切换到本地 parquet 后仍能逐位复现旧结果的前提。取行时对每列调用 `.as_py()`，把 Arrow 标量转换为 Python 对象，`messages` 列因此变成字典列表。

所有任务都以 `shuffle(seed=42)` 结尾：`SmolTalk`、`MMLU`、`GSM8K`、`ARC` 的构造函数都写 `load_hub_dataset(...).shuffle(seed=42)`。固定种子保证同一份代码在任何机器上产出同一条样本顺序，这是后续 `TaskMixture` 的确定性混合能够成立的基础。

### 4. Task 的切片语义

`Task` 基类把「数据集」与「取哪一段」分离，三个字段 `start`、`stop`、`step` 定义逻辑视图，不复制底层数据。

```python
def __len__(self):
    start = self.start
    stop = self.num_examples() if self.stop is None else self.stop
    step = self.step
    span = stop - start
    num = (span + step - 1) // step  # ceil_div(span, step)
    assert num >= 0
    return num

def __getitem__(self, index: int):
    assert isinstance(index, int)
    physical_index = self.start + index * self.step
    conversation = self.get_example(physical_index)
    return conversation
```

长度公式是 $\lceil(\text{stop}-\text{start})/\text{step}\rceil$，与 Python 切片的语义一致；逻辑下标 $j$ 映射到物理下标 $\text{start}+j\cdot\text{step}$。`chat_sft.py` 用这套机制把 MMLU 的 14K 行测试集裁到 5.2K、GSM8K 的 1.32K 测试集裁到 420 行，使验证混合的比例与训练混合大致对应，同时不改变底层的 parquet 缓存。

构造参数带三条断言：`start >= 0`、`stop is None or stop >= start`、`step >= 1`。这些断言防止负长度与无限循环，代价是 `Task` 不能被用作反向切片；nanochat 不需要该能力。

### 5. TaskMixture 的确定性混合

`TaskMixture` 把多个任务按行数比例交错。实现方式是先枚举所有 $(\text{task\_idx},\text{local\_idx})$ 对，再用固定种子的 `random.Random` 打乱。

```python
class TaskMixture(Task):
    def __init__(self, tasks, **kwargs):
        super().__init__(**kwargs)
        self.tasks = tasks
        self.lengths = [len(task) for task in tasks]
        self.num_conversations = sum(self.lengths)
        self.index_map = []
        for task_idx, task_length in enumerate(self.lengths):
            for local_idx in range(task_length):
                self.index_map.append((task_idx, local_idx))
        # Deterministically shuffle to mix tasks throughout training
        rng = random.Random(42)
        rng.shuffle(self.index_map)

    def get_example(self, index):
        assert 0 <= index < self.num_conversations
        task_idx, local_idx = self.index_map[index]
        return self.tasks[task_idx][local_idx]
```

混合后的长度是各任务长度之和，训练一个 epoch 恰好把 `index_map` 的每一项看完一次。重复的 `MMLU` 对象各有独立的 `index_map` 段，因此每个 MMLU 样本在一个 epoch 中被看三次，且三次分散在训练流的三个随机位置，而不是集中在前三分之一。

为什么用全局 shuffle 而不是轮转（round-robin）：轮转会把三个任务强制成交替的 1:1:1，与 460:300:32 的既定配比不符；若改成按行数分块的首尾相接，又会出现长时间只来自一个任务。全局 shuffle 在保持精确配比的同时把任务打散，代价是每个任务内部也失去了有意义的顺序，而 SFT 不需要这个顺序。更实际的理由来自数据加载器的缓冲结构。`chat_sft.py` 的 `sft_data_generator_bos_bestfit` 维护 `buffer_size=100` 条对话的缓冲区，并从缓冲区里按 best-fit 取整条对话填行；每行约容纳 8 条对话（2049 token 容量、平均约 250 token 的对话），一个 micro-batch 有 16 行，即约 128 条对话。若相邻 128 条对话同属一个任务，则该 micro-batch 的梯度完全来自单一任务；全局 shuffle 使缓冲区在任务间交错，单步梯度是混合任务的加权平均。

打乱只发生一次，顺序在整个训练过程中固定：`index_map` 在构造时生成并保存，`get_example` 只做查表。因此同一个检查点恢复训练时，若按 `consumed` 定位，样本顺序仍可复现。

### 6. TaskSequence 与课程式顺序

`TaskSequence` 是另一种组合方式：不打乱，按列表顺序拼接。

```python
class TaskSequence(Task):
    def __init__(self, tasks, **kwargs):
        super().__init__(**kwargs)
        self.tasks = tasks
        self.lengths = [len(task) for task in tasks]
        self.num_conversations = sum(self.lengths)

    def get_example(self, index):
        assert 0 <= index < self.num_conversations
        for task_idx, task_length in enumerate(self.lengths):
            if index < task_length:
                return self.tasks[task_idx][index]
            index -= task_length
```

它存在的理由是课程式训练：先在小而简单的任务上收敛格式，再切换到主任务，避免早期梯度被长样本主导。`chat_sft.py` 当前没有使用 `TaskSequence`，训练混合用的是 `TaskMixture`；两者的区别只在顺序，长度与切片语义完全相同。若要把「先 MMLU 后 GSM8K」写成课程，只需把 `TaskMixture(train_tasks)` 换成 `TaskSequence(train_tasks)`，但代价是丢失跨任务交错，训练后期的梯度分布会偏向最后一个任务。

### 7. 为什么用 smol 版本

三个量共同决定 SFT 的数据规模：对话条数、每条对话的 token 数、允许的 epoch 数。`smol-smoltalk` 的 460K 条在 1 个 epoch 下约产生 $460\text{K}\times250\approx1.15\times10^{8}$ token，与 d24 预训练约 $5.6\times10^{9}$ token 相比约为 2%。这个比例是刻意的小：SFT 的目标是改变行为分布，不是注入新知识，数据量超过必要规模会带来两个副作用。

第一是算力与配比。完整版 SmolTalk 规模在百万级（SmolLM2 论文报告约 2.2M 条），若全量使用，SFT 的 token 数会扩大数倍；与预训练 `--target-param-data-ratio=8` 的预算相比，SFT 不再是一个仅占 2% 的尾部步骤。同时通用对话在混合中的占比会升到 90% 以上，MMLU 与 GSM8K 的技能暴露被挤压，多选格式与工具协议学不牢。

第二是容量匹配。小模型的参数量只支持有限的分布分辨率；面对长尾且高度多样的指令数据，模型只能学到每种模式的平均响应，噪声大于信号。smol 版本是面向小模型筛选的子集，单条样本的信息密度更高，同样步数下的有效监督更多。这一取舍的代价是风格多样性下降，见下一节。

### 8. 数据质量与模板化风险

SmolTalk 的对话来自合成与蒸馏，模板化是其结构性问题，不是标注错误。可观察到四类现象。

固定开头。大量 assistant 回复以相同短语开始（确认词、复述问题的短语、礼貌前缀）。SFT 直接学这一分布，于是推理时开头的多样性下降。判断方法是统计训练集中 assistant 回复首 4 个 token 的分布熵，与推理时的分布对比。

安全话术迁移。合成数据中包含拒答与免责声明模板，模型会把它们当作通用回复策略，即使问题完全良性也可能触发。这类行为在 ChatCORE 上不可见，因为 ChatCORE 只测正确率。

评测污染。通用对话数据混合了数学与学科问答来源，MMLU 与 GSM8K 的题目或近邻可能出现在 SmolTalk 中。nanochat 的训练管线没有去污染步骤：`tasks/common.py` 只做格式校验，`chat_sft.py` 只做混合，没有 n-gram 重叠检查。若要在自己的数据上报告可信的 ChatCORE，需要额外在训练混合与评测集之间做 13-gram 重叠过滤。

长度偏置。对话数据以短回复为主，模型学到「回复应当短」的先验；需要长输出的任务（多步数学、代码）因此受限。GSM8K 的 4 个 epoch 部分抵消这一偏置，因为它的 assistant 段包含完整解题步骤。

这四类风险不影响损失曲线的形状，只能通过人工抽查与留出集评估识别；具体的数据过滤流程见 [[数据集质量控制]]，本篇只讨论 nanochat 现有的校验边界。

### 在 nanochat 中的落地

| 位置 | 代码 | 作用 | 去掉会怎样 |
|---|---|---|---|
| `tasks/smoltalk.py` | `SmolTalk.__init__` 的 `assert split in ["train", "test"]` | 限定两个合法划分 | 传错划分名会在下游 KeyError 或空数据集上失败 |
| `tasks/smoltalk.py` | `load_hub_dataset("HuggingFaceTB/smol-smoltalk", split=split).shuffle(seed=42)` | 下载、缓存、固定顺序 | 顺序不定则实验不可复现 |
| `tasks/smoltalk.py` | `get_example` 的三层断言 | 校验角色交替与字符串内容 | 渲染器在训练中途断言失败 |
| `tasks/common.py` | `HubDataset.shuffle` | 与 `datasets` 一致的置换 | 换库后样本顺序改变 |
| `tasks/common.py` | `TaskMixture.__init__` 的 `random.Random(42)` | 跨任务交错 | 单步梯度集中在一个任务上 |
| `scripts/chat_sft.py` | `train_tasks = [SmolTalk(split="train"), ...]` | 组装 792K 行混合 | 通用对话能力缺失 |
| `scripts/chat_sft.py` | `val_dataset = TaskMixture([SmolTalk(split="test"), ...])` | 29.6K 行验证混合 | 无留出集损失可监控 |
| `nanochat/tokenizer.py` | `render_conversation` 的 system 合并 | 把 system 拼进首条 user | 系统提示无槽位，只能丢弃或报错 |

`render_conversation` 的 system 处理值得单列：它不设独立的 system 槽位，而是断言 `messages[1]["role"] == "user"`，把 system 内容与首条 user 内容用两个换行拼接，再从消息列表里删除 system 项。因此带 system 与不带 system 的两种写法渲染结果完全相同，`tests/test_tokenizer.py` 的 `test_render_conversation_system_message_merged` 断言的正是这一点。代价是 system 与 user 在 token 序列中不可区分，模型无法学会「system 优先于 user」这类层级关系。

## 关键直觉

> [!tip] 数据决定「行为分布」，渲染决定「哪些位置产生梯度」。SmolTalk 提供前者：460K 条 user/assistant 交替的样本，把对话协议的内容分布写进训练流；`render_conversation` 提供后者：同一批样本渲染后，只有 assistant 段与 `<|assistant_end|>` 的掩码为 1。
>
> 与严格定义的关系：定义里的 $\mathbf{u}$ 与 $\mathbf{m}$ 是两个独立产物，长度相同但含义不同。$\mathbf{u}$ 决定模型看到什么上下文，$\mathbf{m}$ 决定哪些位置产生损失。混合与打包只改变 $\mathbf{u}$ 的排列与拼接方式，不改变 $\mathbf{m}$ 的构造规则；因此更换数据不会让掩码失效，更换掩码规则却会让所有数据同时失效。判断一次改动是否安全，先问它动的是 $\mathbf{u}$ 还是 $\mathbf{m}$。

## 例子与代码

第一段代码用字符级 tokenizer 复现 `render_conversation` 的结构，使掩码可以逐位置手算。三段实现与 repo 逐句对应，只有分词被替换。

```python
"""render_conversation 的等价最小实现：字符级 tokenizer，其余结构逐句对应。"""
BOS, USER_START, USER_END, ASSISTANT_START, ASSISTANT_END = 0, 1, 2, 3, 4

def tok(text):
    """模拟 tiktoken.encode_ordinary：一个字符一个 token。"""
    return [100 + ord(c) for c in text]

def render(conversation):
    ids, mask = [], []
    def add(seq, val):
        seq = [seq] if isinstance(seq, int) else seq
        ids.extend(seq)
        mask.extend([val] * len(seq))

    messages = conversation["messages"]
    # 可选 system：拼进首条 user，再从列表删除（与 repo 的 merge 分支一致）
    if messages[0]["role"] == "system":
        assert messages[1]["role"] == "user"
        merged = {"role": "user", "content": messages[0]["content"] + "\n\n" + messages[1]["content"]}
        messages = [merged] + messages[2:]

    add(BOS, 0)
    for i, msg in enumerate(messages):
        assert msg["role"] == ("user" if i % 2 == 0 else "assistant")
        if msg["role"] == "user":
            add(USER_START, 0); add(tok(msg["content"]), 0); add(USER_END, 0)
        else:
            add(ASSISTANT_START, 0); add(tok(msg["content"]), 1); add(ASSISTANT_END, 1)
    return ids, mask

conv = {"messages": [{"role": "user", "content": "hi"},
                     {"role": "assistant", "content": "hello"}]}
ids, mask = render(conv)
print(len(ids), ids)
print(mask, sum(mask))
```

预期输出如下。`hi` 占 2 个 token、`hello` 占 5 个 token，因此总长 $1+(1+2+1)+(1+5+1)=12$，掩码和为 $5+1=6$。

```text
12 [0, 1, 204, 205, 2, 3, 204, 201, 208, 208, 211, 4]
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1] 6
```

前三项 `0,1,204` 分别对应 BOS、`<|user_start|>`、`h`；`205` 是 `i`；`2` 是 `<|user_end|>`；`3` 是 `<|assistant_start|>`，掩码为 0；其后的 `204,201,208,208,211` 是 `hello` 的五个字符，`4` 是 `<|assistant_end|>`，这六项的掩码为 1。可见 `<|assistant_start|>` 虽然属于 assistant 回合，却不计入损失：它由推理运行时注入，不是模型要生成的内容。

第二段代码在真实 tokenizer 上检查同一组掩码规则。需要已训练的分词器与 `~/.cache/nanochat/tokenizer`。为避免依赖词表版本，只打印可判定的布尔量。

```python
"""真实 tokenizer 上的掩码检查（需要 nanochat 的分词器与缓存目录）。"""
from nanochat.tokenizer import get_tokenizer

tok = get_tokenizer()
conversation = {"messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the capital of France?"},
    {"role": "assistant", "content": "Paris."},
]}
ids, mask = tok.render_conversation(conversation)
user_start = tok.encode_special("<|user_start|>")
assistant_start = tok.encode_special("<|assistant_start|>")
assistant_end = tok.encode_special("<|assistant_end|>")
print("user 段全部无监督:", all(m == 0 for i, m in zip(ids, mask) if i == user_start))
print("assistant_start 无监督:", mask[ids.index(assistant_start)] == 0)
print("assistant_end 有监督:", mask[ids.index(assistant_end)] == 1)
print("监督数等于回复长度加一:", sum(mask) == len(tok.encode("Paris.")) + 1)
```

预期输出四行全为 `True`。前三行直接对应掩码表；第四行是等价的定量校验：assistant 段的监督 token 恰好是回复文本的 token 数加上结束符，多一个或少一个都说明掩码区间错了。

```text
user 段全部无监督: True
assistant_start 无监督: True
assistant_end 有监督: True
监督数等于回复长度加一: True
```

`system` 内容被拼进首条 user，因此序列中不存在独立的 system 标记；若把带 system 与把 system 手工拼进 user 的两种写法分别渲染，结果应逐 token 相同，`tests/test_tokenizer.py` 的 `test_render_conversation_system_message_merged` 断言的正是这一点。掩码为 0 的前缀包含 BOS、user 回合与 `<|assistant_start|>`，这些位置在 SFT 中不产生梯度，但它们仍参与注意力计算，是回复的条件。

第三段验证切片语义。`tasks/common.py` 末尾的 `__main__` 就是为这一目的写的。

```bash
python -m tasks.common
```

输出包含四部分：MMLU 的完整长度、第 5 条的原始内容、切片后的长度与首元素一致性。下面的摘录只保留后两部分；前两部分的数值与内容都随数据集版本变化。

```text
Length of sliced MMLU[5:10]:  5
They match:  True
```

`They match: True` 说明 `ds[5]` 与 `MMLU(..., start=5, stop=10)[0]` 指向同一条物理样本，切片只改逻辑视图。若这一行为假，`chat_sft.py` 里 `stop=5200` 的验证裁剪就会取到错误的样本，而验证损失仍然能算出来，错误只能通过人工比对发现。

## 易错点

> [!warning] 以下六条均可在取数与渲染阶段直接检验。
> 1. 把 `system` 放在消息列表中间，或让 `system` 后紧跟 `assistant`。`render_conversation` 只处理首位 `system`，且断言其后必须是 `user`；违反时抛 `AssertionError`，而不是退化为无 system。
> 2. 把 GSM8K 的分片列表当作 SmolTalk 的 `content`。SmolTalk 断言 `isinstance(content, str)`，混入后会立即失败；反过来，把字符串塞进 GSM8K 的解析路径会得到空的 `parts`。
> 3. 混用逻辑下标与物理下标。`shuffle(42)` 之后 `ds.ds[0]` 是物理第 0 行，`ds[0]` 是置换后的第 0 行；绕过 `Task.__getitem__` 直接读 `ds.ds` 会让训练顺序与混合顺序脱钩，实验不可复现。
> 4. 手删缓存中的某个 parquet 分片但保留 `manifest.json`。manifest 存在即视为下载完成，代码不会重下，`pq.read_table` 直接抛 `FileNotFoundError`；修复方法是删除 manifest 后重跑。
> 5. 认为掩码为 0 的位置「模型看不到」。掩码只作用于损失，BOS 与 user 段仍进入注意力；把掩码与注意力混为一谈，会错误地以为需要额外的 attention mask。
> 6. 忽略渲染的 2048 截断。`render_conversation` 在末尾对 `ids` 与 `mask` 同时截断到 `max_tokens=2048`；超长对话的 `<|assistant_end|>` 可能被截掉，该行因此失去停止监督，模型在长输入上不会停止。

## 关联笔记

- 前置 [[词表与特殊token]]：`<|bos|>`、`<|user_start|>` 等 9 个特殊 token 是对话渲染的语法基础，渲染器只做拼接，不训练新 token。
- 前置 [[数据集质量控制]]（跨库）：通用原理见该篇，本篇只讲 nanochat 的格式校验与缓存边界；去污染与重复检测在本库中没有实现。
- 后续 [[多选与工具使用数据]]：同为 SFT 数据，但监督目标从自然语言回复变为单字母与分片工具协议。
- 后续 [[有监督微调SFT]]：本篇产出的 `(ids, mask)` 是 SFT 数据加载器的输入，掩码在那里被移位并写入 `targets`。
- 对照 [[训练数据与FineWeb]]：预训练数据只提供 `ids`，没有掩码；SFT 数据第一次引入「哪些位置算损失」这一维度。

## 达标检测

- [ ] 不看笔记写出 SmolTalk 的三层断言，并说明每条断言对应哪种坏样本。
- [ ] 画出 `~/.cache/nanochat/task_data/` 下的目录层级，说明 `HuggingFaceTB/smol-smoltalk` 的 train 划分落在哪个路径。
- [ ] 解释为什么 manifest 必须最后写入；给出下载中途崩溃后系统的恢复行为。
- [ ] 给定 `start=5`、`stop=10`、`step=2`，手算 `len()` 与逻辑下标 1 对应的物理下标。
- [ ] 说明 `TaskMixture` 中「重复传入同一个 Task 对象」为什么等价于过采样，并算出 MMLU 在训练流中的占比。
- [ ] 运行第一段代码，把 `hello` 换成空字符串，预测新的 token 数与掩码和，并解释结果。
- [ ] 给出三条证据说明 SmolTalk 存在模板化风险，并说明哪一类无法通过 ChatCORE 发现。

## 参考来源

- Allal et al., "SmolLM2: When Smol Goes Big — Data-Centric Training of a Small Language Model", arXiv:2502.02737, 2025 —— 对应第 1 节的 smol-smoltalk 来源、构成与面向小模型的取舍，以及第 7 节的规模论证。
- Karpathy, *nanochat*（commit 92d63d4），`tasks/smoltalk.py`、`tasks/common.py`、`scripts/chat_sft.py` —— 对应第 2 至 6 节的断言、`HubDataset`、切片与混合实现，以及「在 nanochat 中的落地」一节的表格。
- Hugging Face, *datasets* 文档（parquet 自动导出与 `shuffle` 的种子语义） —— 对应第 3 节「用 parquet 替代 datasets」的接口对照与置换一致性要求。
- Karpathy, *nanochat*（commit 92d63d4），`tests/test_tokenizer.py` —— 对应第 2 节 system 合并的断言与掩码边界，以及第二段代码的可检验结论。
