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

# 从生成式到对话式

## 定义

**生成式模型**（base model）指只在一个目标上训练过的模型：给定前缀，输出下一个 token 的概率分布，训练分布是文档。**对话式模型**（chat model）指在同一组参数上再经过 SFT，使给定按协议渲染的提示时，输出分布集中在 assistant 回合的内容上。二者的参数结构相同，差别在于条件分布与推理协议。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $\mathcal{D}$ | 文档语料，base 模型的训练分布 |
| $\mathcal{C}$ | 对话语料，SFT 的训练分布 |
| $p_\theta$ | 参数为 $\theta$ 的下一 token 分布 |
| $x$ | 用户侧提示（system 与 user token 序列） |
| $y$ | assistant 回复 token 序列 |
| $\mathcal{P}$ | 协议渲染函数，即 `render_conversation` |
| $\mathbf{s}$ | 推理时的会话状态，`conversation_tokens` |
| $L_{\max}$ | 训练上下文长度，2048 |

**协议**（protocol）指由特殊 token 定义的轮次结构：`<|user_start|>` 与 `<|user_end|>` 包裹用户回合，`<|assistant_start|>` 与 `<|assistant_end|>` 包裹 assistant 回合，`<|python_start|>`/`<|python_end|>` 与 `<|output_start|>`/`<|output_end|>` 包裹工具调用与返回值。**流式解码**（streaming decode）指每生成一个 token 就立即解码并输出。**灾难性遗忘**（catastrophic forgetting）指微调后模型在原训练分布上的能力下降。

## 为什么重要

base 模型与 chat 模型在参数规模、结构、分词器上完全相同，行为却完全不同。理解这一点的工程价值在于三条推论。

第一，对话能力不是预训练的自然延伸，而是协议训练的结果。九个特殊 token 中有八个在预训练中从未出现：预训练数据加载器只用到 `<|bos|>` 作为文档分隔符。这八个 token 的嵌入行在预训练中没有梯度，只受初始化与权重衰减影响，因此没有学到任何语义；它们的含义完全由 SFT 的 792K 行样本赋予。这意味着 SFT 不只是「调整风格」，它同时在训练八个嵌入向量与它们在所有层中的表示。

第二，推理必须精确复现训练时的协议。`chat_cli.py` 手工拼接 `[bos] + [user_start] + 用户 token + [user_end] + [assistant_start]`，而不是调用某个模板函数；`render_conversation` 是协议的唯一定义处，推理代码必须与它逐 token 一致。任何空格、换行或缺失的特殊 token 都会让模型看到一个训练中不存在的上下文，输出退化为续写。

第三，SFT 的副作用与收益同源。训练目标只覆盖 assistant 段，模型在通用文本上的似然不再被优化；数据分布窄（英文对话、单字母答案、小学数学）、轮数少（一个 epoch）、学习率相对预训练不低（0.8 倍），三者共同决定遗忘的幅度。`chat_sft.py` 只评测 SFT 混合上的 bpb 与 ChatCORE，不重测 base 的 CORE，因此遗忘在默认流程中不可见，需要额外测量。

在全书结构中，本篇是 06 阶段的收束：[[对话数据与SmolTalk]] 给出数据格式，[[多选与工具使用数据]] 给出监督目标，[[有监督微调SFT]] 给出训练实现，本篇解释训练前后模型行为的差异及其边界。后续的 [[GRPO原理与实现]] 以 chat 模型为策略初值，[[CLI与WebUI]] 复用同一套拼接逻辑，[[KV Cache原理]] 给出推理显存与上下文长度的第一性约束。

## 原理与推导

### 1. 两种条件分布

base 模型在一个文档序列 $\mathbf{x}=(x_1,\dots,x_T)$ 上最大化

$$
\log p_\theta(\mathbf{x})=\sum_{t=1}^{T}\log p_\theta\bigl(x_t\mid x_{<t}\bigr),
$$

对语料中所有位置求和。这个目标不区分「谁在说话」：一段问答、一段代码、一段论坛争论都以同样方式被建模。给定前缀「请解释光合作用」，最可能的续写可能是更多类似的问题，因为网页中问题常成组出现。

chat 模型的目标是条件分布

$$
\log p_\theta(y\mid x)=\sum_{t=1}^{|y|}\log p_\theta\bigl(y_t\mid x,y_{<t}\bigr),
$$

其中 $x$ 由 $\mathcal{P}$ 从用户消息渲染而来，$y$ 是 assistant 回合的内容（包括 `<|assistant_end|>`）。差别有两处：条件项 $x$ 被固定为提示，求和只覆盖回复；$x$ 本身带有协议标记，使模型能区分「这是要回复的输入」与「这是要延续的文本」。

由于两个目标共享参数，SFT 不是替换预训练学到的函数，而是在其输出空间上重新加权。模型仍然会用预训练学到的语法、事实与推理，但「下一个 token 应该是什么」的决策规则被改写为「在这个协议位置上，assistant 应当说什么」。

### 2. 特殊 token 如何定义轮次

九个特殊 token 在分词器训练阶段被保留，不参与 BPE 合并。

```python
SPECIAL_TOKENS = [
    "<|bos|>",
    "<|user_start|>", "<|user_end|>",
    "<|assistant_start|>", "<|assistant_end|>",
    "<|python_start|>", "<|python_end|>",
    "<|output_start|>", "<|output_end|>",
]
```

训练 BPE 时词表先减去特殊 token 数量，再把它们作为额外的单选 token 加入 tiktoken 编码器。因此每个特殊 token 恰好对应一个 id，且不出现在普通文本的分词结果中。

| token | 开放者 | 轮次作用 | 掩码 |
|---|---|---|---|
| `<|bos|>` | 数据加载器 | 文档起点，也作 padding | 0 |
| `<|user_start|>` | 拼接代码 | 用户回合开始 | 0 |
| `<|user_end|>` | 拼接代码 | 用户回合结束 | 0 |
| `<|assistant_start|>` | 拼接代码 | 提示结尾，生成起点 | 0 |
| `<|assistant_end|>` | 模型 | 回复结束，停止条件 | 1 |
| `<|python_start|>` | 模型 | 工具调用开始 | 1 |
| `<|python_end|>` | 模型 | 工具调用结束 | 1 |
| `<|output_start|>` | 运行时注入 | 工具返回开始 | 0 |
| `<|output_end|>` | 运行时注入 | 工具返回结束 | 0 |

用单 token 而不是文本标记（如 `User:`），有四个原因。其一，边界无歧义：文本标记可能被 BPE 与前后文字合并，导致同一语义在不同上下文中有不同 token 序列；特殊 token 恒为单个 id。其二，掩码边界精确：`render_conversation` 只需在拼接处记录掩码，不需要按字符位置回溯。其三，停止判定是整数比较：`Engine` 在 `next_token == assistant_end` 时结束该行，成本为一次比较。其四，协议不可伪造：`tests/test_tokenizer.py` 的 `test_special_tokens` 断言普通文本编码不会把字面量 `"<|bos|>"` 折叠成特殊 token，因此用户在输入里写特殊 token 的字面量只得到普通文本，无法提前终止回合或注入角色标记。

代价是词表占用与冷启动。九个 token 占九个词表槽位，相对于 32768 的词表可忽略；真正的代价是冷启动：八个 token 的嵌入在预训练中没有任何梯度。SFT 需要同时学习「这些 token 的含义」与「如何组织回复」，这是 SFT 不能用过小学习率与过少步数的原因之一。

### 3. 拼接与会话状态机

`scripts/chat_cli.py` 是协议的最小实现。它维护一个整数列表 `conversation_tokens`，每轮把用户输入与角色标记追加进去，再追加 `<|assistant_start|>` 作为生成起点。

```python
bos = tokenizer.get_bos_token_id()
user_start, user_end = tokenizer.encode_special("<|user_start|>"), tokenizer.encode_special("<|user_end|>")
assistant_start, assistant_end = tokenizer.encode_special("<|assistant_start|>"), tokenizer.encode_special("<|assistant_end|>")
engine = Engine(model, tokenizer)
conversation_tokens = [bos]

while True:
    user_input = input("\nUser: ").strip()
    # 省略 quit/exit/clear 与空输入的处理
    conversation_tokens.append(user_start)
    conversation_tokens.extend(tokenizer.encode(user_input))
    conversation_tokens.append(user_end)
    conversation_tokens.append(assistant_start)

    response_tokens = []
    for token_column, token_masks in engine.generate(conversation_tokens, num_samples=1,
                                                     max_tokens=256, temperature=0.6, top_k=50):
        token = token_column[0]
        response_tokens.append(token)
        print(tokenizer.decode([token]), end="", flush=True)

    if response_tokens[-1] != assistant_end:
        response_tokens.append(assistant_end)
    conversation_tokens.extend(response_tokens)
```

五处细节对应五个不变量。

初始状态包含 `<|bos|>`。SFT 渲染的每条对话都以 BOS 开头，若推理时省略，模型看到的序列与训练分布相差一个 token，虽然只有一个位置，但它是所有注意力的第一个键。

用户输入先编码再包裹，而不是把 `user_start` 与文本拼成一个字符串再编码。若拼成一个字符串，特殊 token 的字面量可能被普通编码路径处理，得到多个 token 而非一个 id；先编码得到 id 再拼接，能保证 `<|user_start|>` 始终是单个特殊 token。

生成前必须追加 `<|assistant_start|>`。模型被训练为在看到该 token 时开始 assistant 回合，如果不追加，模型面对的是 `<|user_end|>` 之后的位置，而这个位置在训练中总是紧跟 `<|assistant_start|>`，于是模型最可能先输出 `<|assistant_start|>`，造成重复的开始标记。

回复结束后若没有 `<|assistant_end|>` 则手工补上。生成可能因 `max_tokens=256` 上限中断，此时最后一个 token 不是结束符；若把未闭合的回复直接留在上下文里，下一轮的用户回合会出现在一个未结束的 assistant 回合内部，协议结构被破坏。补上结束符使上下文始终是合法对话。

`conversation_tokens` 只增不减，多轮对话依靠上下文而非外部记忆。`Engine` 每次调用都会对完整 `conversation_tokens` 做一次 prefill，因此第 $n$ 轮的提示长度是前 $n-1$ 轮的总和。这带来两个后果：KV 缓存随轮数线性增长；上下文一旦超过训练长度 $L_{\max}=2048$，模型进入训练中未见过的位置区间，回复质量下降。代码没有截断逻辑，位置编码表按 10 倍序列长度预计算，因此不会立即报错，退化是静默的。

### 4. 流式解码与字节边界

生成循环每步产出一列 token 与一列掩码：`token_column` 是该步各行的 token id，`token_masks` 标记该 token 是采样得到（1）还是强制注入（0）。工具调用的返回值就是强制注入：`Engine` 在遇到 `<|python_end|>` 后求值，把 `<|output_start|>结果<|output_end|>` 放进该行的 `forced_tokens` 队列，下一步直接取出，掩码记为 0。

`chat_cli` 对每个 token 立即调用 `tokenizer.decode([token])` 并输出。分词器是字节级 BPE：一个 token 对应若干字节，一个 UTF-8 字符可能被拆到两个或三个 token 中。单独解码一个不完整的字节序列会得到替换字符（U+FFFD），因此中文或 emoji 在流式输出时可能出现乱码，而同样的 token 序列整体解码则正常。可行的修正是在客户端累积字节，仅在字节序列构成合法 UTF-8 边界时输出；nanochat 未做这一处理，因为它的训练与演示以英文为主。

### 5. render_for_completion 在 RL 与评测中的作用

训练与评测需要的不是同一个函数。`render_conversation` 返回完整对话的 `(ids, mask)`，用于训练；`render_for_completion` 返回「提示 + 生成起点」的 id 列表，用于采样。

```python
def render_for_completion(self, conversation):
    conversation = copy.deepcopy(conversation)
    messages = conversation["messages"]
    assert messages[-1]["role"] == "assistant", "Last message must be from the Assistant"
    messages.pop()  # 移除最后一条 assistant 消息
    ids, mask = self.render_conversation(conversation)
    assistant_start = self.encode_special("<|assistant_start|>")
    ids.append(assistant_start)
    return ids
```

两步外科手术各有理由。弹出最后一条 assistant 消息，是因为数据集的对话里含有标准答案；采样时必须让模型自己生成，不能把答案留在上下文里。追加 `<|assistant_start|>`，是给出与训练一致的生成起点。

调用点有三处。`chat_rl.py` 的 rollout 用它对 GSM8K 训练样本渲染提示，再采样 16 条回复并计算奖励。`chat_eval.py` 的 generative 路径用它对 GSM8K 与 HumanEval 渲染提示，采样后解码 `result_tokens[prefix_length:]` 得到补全，再交给 `task.evaluate`。`chat_eval.py` 的 categorical 路径用它对 ARC 与 MMLU 渲染提示，然后取最后一个位置的 logits，只在候选标签的 token 上比较。

categorical 路径依赖一个位置事实：`render_for_completion` 的最后一个 token 是 `<|assistant_start|>`，其位置索引为 `len(ids) - 1`。`chat_eval.py` 的 `answer_time_positions = [len(ids) - 1 for ids in prompt_ids]` 正是取这个位置，模型在该位置的输出分布就是「assistant 回合第一个 token」的分布，也就是训练时被监督的那个位置。少减 1 会读到 `<|assistant_start|>` 自身的 logits，结果不再反映 assistant 首 token 的分布。

### 6. SFT 之后的行为变化

| 维度 | base 模型 | chat 模型 | 机制 |
|---|---|---|---|
| 对提问的反应 | 续写更多提问或模板文本 | 给出回复 | 损失只覆盖 assistant 段 |
| 停止 | 无停止概念，直到上限 | 生成 `<|assistant_end|>` 即停 | 该 token 被监督 |
| 多轮 | 无轮次概念 | 依赖上下文列表，可继续多轮 | 协议 token 累积 |
| 多选题 | 续写选项文本 | 输出单个标签 | MMLU 过采样 3 次 |
| 数学 | 直接写结果，常算错 | 调用计算器并把结果写进过程 | GSM8K 的 parts 监督 |
| 语言 | 依语料，英文为主 | 英文为主，中文不稳定 | 训练数据全为英文 |
| 拒答 | 无系统策略 | 继承数据中的安全话术 | 合成数据含拒答模板 |
| 幻觉 | 续写风格 | 以自信语气给出无依据内容 | 只学到风格，未学到校准 |

最后两行值得展开。拒答不是对齐训练的结果：nanochat 没有 RLHF 或安全微调阶段，chat 模型的拒答完全来自 SFT 数据中的话术模板。若数据中「我不能帮助」出现频率高，模型会在良性问题上也使用它；若频率低，则几乎不拒答。同理，幻觉在 SFT 后并未减少，反而更明显：base 模型输出的是续写文本，读者容易识别其为生成物；chat 模型输出的是格式规范的回复，读者更容易把它当作事实陈述。SFT 只改变形式，不改变知识边界，缓解机制见 [[幻觉与缓解]]。

英文为主这一点对中文使用者尤其重要。SmolTalk、MMLU、GSM8K 都是英文数据，SFT 之后模型的行为分布以英文为中心；中文输入会被编码为字节级 token，模型能续写但质量显著低于英文。若目标是中文对话，需要替换 SFT 数据而不是调整推理参数。

### 7. 灾难性遗忘与 base 能力

遗忘的机制可以从梯度式读出。SFT 的梯度只来自 assistant 段，且这些段落的分布集中在对话、单字母答案与小学数学三类；预训练分布中的代码、长文档、多语言文本在 SFT 中权重为零。参数被推向新分布，旧分布上的似然下降。

nanochat 的四项设置限制了遗忘幅度：只跑一个 epoch（每类样本最多 4 次）；初始学习率是预训练基础值的 0.8 倍而非更高；weight decay 为 0，不做参数收缩；动量缓冲从预训练继承，参数不会因优化器重置而剧烈跳动。这四项都不能消除遗忘，只能把它控制在「base 能力部分保留」的范围内。

关键在于度量缺口。`chat_sft.py` 在训练中计算两类指标：SFT 验证混合上的 bpb，以及 ChatCORE。前者衡量对话数据的拟合，后者衡量对话任务的能力；两者都不衡量 base 能力。若要度量遗忘，需要在 SFT 检查点上重新跑 base 的 CORE 评测（`scripts/base_eval.py`），或在与预训练同分布的验证集上比较 bpb。默认流程不做这件事，因此「SFT 后 CORE 下降多少」在 nanochat 的日志中没有答案，需要实验者自己补测。

这一缺口有实际影响。若把 SFT 检查点当作通用模型使用，CORE 的下降直接决定它在非对话任务上的可用性；若只用它做对话，遗忘的代价被 ChatCORE 掩盖。报告结果时应同时给出两个口径，或明确说明只报告了对话侧。

### 8. 如何检查行为迁移

三类检查，成本从低到高。

ChatCORE 前后对比。在 SFT 检查点与 base 检查点上分别跑 `scripts/chat_eval.py -i sft` 与 `scripts/chat_eval.py -i base`（`load_model` 接受 `base`/`sft`/`rl` 三个来源），比较 5 个任务的准确率。base 模型在 categorical 任务上的准确率通常接近随机（因为它不遵守「只回答字母」的格式，评测读到的分布没有集中在标签上），在 GSM8K 上接近零。SFT 后前三个任务的 centered accuracy 应显著为正，这是格式迁移是否成功的直接证据。

人工对话检查。固定一组提示，覆盖单轮问答、多轮追问、格式要求、算术、拒答与越界请求，逐条记录。检查项包括：是否在合理位置停止、是否复读用户输入、是否保持角色、工具调用是否成对出现、多轮中是否引用前文。人工检查不可替代，因为 ChatCORE 的 5 个任务都不测多轮连贯性。

base 能力回归。在 SFT 检查点上重跑 CORE，与预训练检查点的 CORE 比较。若下降超过预设阈值，应减小学习率、减少 epoch 或混入少量预训练数据；`chat_sft.py` 没有内置这一项，需要手工执行。

三项检查的顺序有讲究：先看 ChatCORE 确认迁移发生，再看人工对话确认行为可用，最后看 CORE 确认代价可接受。若顺序颠倒，容易在格式尚未学会时就去测遗忘，得到无意义的结论。

### 9. 多轮上下文的增长与截断

`chat_cli` 每轮把新 token 追加到同一个列表，`Engine.generate` 每次调用都对整表重新做一次 prefill。设第 $i$ 轮新增的 token 数为 $n_i$（用户输入、四个角色控制符与回复之和），则第 $k$ 轮 prefill 的长度为

$$
L_k=\sum_{i=1}^{k}n_i,
$$

到第 $k$ 轮为止累计 prefill 的 token 数为 $\sum_{j=1}^{k}\sum_{i=1}^{j}n_i$，在多轮等长时随轮数平方增长。这与 [[KV Cache原理]] 中「缓存把每步降为 $O(td)$」的结论并不矛盾：缓存消除的是单轮内的重复计算，而 `chat_cli` 在轮与轮之间丢弃缓存、重新构建，因此跨轮的重复仍然存在。缓存容量由每次调用重新分配，峰值取决于最长一轮的提示长度，而不是各轮之和。

| 轮数 | 单轮新增 token | 该轮 prefill 长度 | 累计 prefill token |
|---|---|---|---|
| 1 | 100 | 100 | 100 |
| 5 | 100 | 500 | 1500 |
| 10 | 100 | 1000 | 5500 |
| 20 | 100 | 2000 | 21000 |

第 20 轮的 prefill 长度达到 2000，接近训练长度 2048 的上界；此后每增加一轮，位置编码与注意力窗口都处在训练中未见过的区间，回复质量下降且不可通过调整采样参数修复。若要支持更长的会话，需要在客户端做历史截断或摘要，`chat_cli` 没有提供这类机制。

### 在 nanochat 中的落地

| 位置 | 代码 | 作用 | 去掉会怎样 |
|---|---|---|---|
| `nanochat/tokenizer.py` | `SPECIAL_TOKENS` 九项 | 定义协议词汇 | 无轮次边界，退化为文本模板 |
| `nanochat/tokenizer.py` | `render_conversation` | 训练侧渲染 | SFT 无输入 |
| `nanochat/tokenizer.py` | `render_for_completion` | 推理侧渲染 | 采样会把答案留在上下文里 |
| `scripts/chat_cli.py` | `conversation_tokens = [bos]` | 会话状态 | 首 token 与训练分布不符 |
| `scripts/chat_cli.py` | 追加 `assistant_start` | 生成起点 | 模型先输出开始标记 |
| `scripts/chat_cli.py` | 补 `assistant_end` | 闭合回合 | 下一轮嵌在未闭合回合内 |
| `nanochat/engine.py` | `next_token == assistant_end` | 停止条件 | 生成到 `max_tokens` |
| `nanochat/engine.py` | `forced_tokens` 与 `token_masks` | 工具注入 | 模型需自己编造输出 |
| `scripts/chat_eval.py` | `answer_time_positions` | 标签 logits 位置 | 读取位置错位，评测退化 |
| `scripts/chat_rl.py` | `render_for_completion` | rollout 提示 | 奖励基于含答案的上下文 |

一处实现细节决定了协议的可靠性：`token_masks` 区分采样与强制注入，但 `chat_cli` 没有使用它。掩码为 0 的 token 是工具返回值，`chat_cli` 照样打印；这在交互场景中是可接受的，因为用户需要看到计算结果，但若要区分「模型说的」与「工具算的」，必须读取这一列。

## 关键直觉

> [!tip] base 模型学的是「在这个位置，语料中最可能出现的下一个 token 是什么」；chat 模型学的是「在协议的这个位置上，assistant 应当给出什么」。协议是显式的 token 结构，不是隐式的语气；因此推理时少一个特殊 token，模型面对的就是一个训练中不存在的状态。
>
> 与严格定义的关系：定义中的 $\mathcal{P}$ 是协议的唯一实现，训练与推理都必须经过它。条件分布 $p_\theta(y\mid x)$ 里的 $x$ 不是原始用户文本，而是 $\mathcal{P}$ 渲染后的 token 序列；把 $x$ 换成原始文本，条件项就与训练不一致，模型输出的分布随之漂移。这条关系解释了为什么对话模板必须逐 token 复现，也解释了为什么特殊 token 的嵌入虽然只有初始化值，却能在 SFT 后被赋予稳定含义。

## 例子与代码

第一段复现会话状态机，展示多轮如何累积，以及结束符如何闭合回合。

```python
"""会话状态机的最小复现：与 chat_cli.py 的拼接顺序一致。"""
BOS, US, UE, AS, AE = 0, 1, 2, 3, 4

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

class Session:
    def __init__(self):
        self.tokens = [BOS]                 # 每条对话以 BOS 开始
    def user(self, text):
        self.tokens += [US] + tok(text) + [UE]
    def prime(self):
        self.tokens.append(AS)              # 生成起点
    def accept(self, generated):
        self.tokens += generated
        if self.tokens[-1] != AE:           # 未闭合则补结束符
            self.tokens.append(AE)

s = Session()
s.user("hi"); s.prime()
print("第 1 轮提示:", s.tokens)
s.accept([211, 207, AE])                    # 模型生成 "ok" + 结束符
print("第 1 轮之后:", s.tokens)
s.user("go"); s.prime()
print("第 2 轮提示:", s.tokens)
```

预期输出如下。

```text
第 1 轮提示: [0, 1, 204, 205, 2, 3]
第 1 轮之后: [0, 1, 204, 205, 2, 3, 211, 207, 4]
第 2 轮提示: [0, 1, 204, 205, 2, 3, 211, 207, 4, 1, 203, 211, 2, 3]
```

第 1 轮提示是 `BOS, user_start, h, i, user_end, assistant_start`，长度为 6。模型生成 `o, k, assistant_end` 后，列表长度变为 9。第 2 轮在末尾追加 `user_start, g, o, user_end, assistant_start`，长度变为 14。多轮的上下文就是这一个列表，没有任何额外状态；`Engine` 每次对整表做 prefill，因此第 $n$ 轮的计算量随累计长度增长。

第二段复现 `render_for_completion` 的「弹出 + 追加」结构，并验证答案不在提示中（沿用上段定义的 `BOS`、`US`、`UE`、`AS`、`AE` 与 `tok`）。

```python
"""render_for_completion 的等价实现：弹出最后一条 assistant，追加生成起点。"""
def render(messages):
    ids, mask = [BOS], [0]
    for i, (role, text) in enumerate(messages):
        assert role == ("user" if i % 2 == 0 else "assistant")
        if role == "user":
            ids += [US] + tok(text) + [UE]; mask += [0] * (len(text) + 2)
        else:
            ids += [AS] + tok(text) + [AE]; mask += [0] + [1] * (len(text) + 1)
    return ids, mask

conversation = {"messages": [("user", "hi"), ("assistant", "answer")]}

ids_full, mask_full = render(conversation["messages"])
print("训练用:", ids_full, "掩码和", sum(mask_full))

prompt = render(conversation["messages"][:-1])[0]   # 弹出最后一条 assistant
prompt.append(AS)
print("推理用:", prompt)
assert tok("answer")[0] not in prompt               # 答案 token 不在提示中
print("答案已剥离: True")
```

预期输出如下。训练用序列的掩码和为 7（`answer` 六个字符加结束符），长度为 13；推理用序列长度为 6，比前者短 7 个 token：少了 assistant 的六个内容 token 与结束符，而生成起点 `<|assistant_start|>` 由函数重新追加。

```text
训练用: [0, 1, 204, 205, 2, 3, 197, 210, 215, 219, 201, 214, 4] 掩码和 7
推理用: [0, 1, 204, 205, 2, 3]
答案已剥离: True
```

第三段是一次会话的示意输出，用于说明协议在文本层面的形态。以下为按协议推演的示例，不是某次运行的记录；模型回复为英文，因为 SFT 数据全为英文。

```text
$ python -m scripts.chat_cli -p "What is the capital of France?"

NanoChat Interactive Mode
--------------------------------------------------
Type 'quit' or 'exit' to end the conversation
Type 'clear' to start a new conversation
--------------------------------------------------

User: What is the capital of France?

Assistant: The capital of France is Paris. It is the largest city in the country
and serves as its political, economic, and cultural center.
```

对应的 token 序列在文本层面是（示意，回复按单句计）

```text
[BOS] [user_start] What is the capital of France? [user_end] [assistant_start]
The capital of France is Paris. [assistant_end]
```

工具调用的会话形态不同，控制符会出现在回复中间。

```text
User: What is 23 * 47?

Assistant: 23 * 47 = [python_start]23*47[python_end][output_start]1081[output_end]1081
```

这里 `23*47` 由模型生成，`1081` 由 `use_calculator` 计算后强制注入；模型随后继续生成最后的 `1081` 与 `<|assistant_end|>`。若模型跳过工具调用直接写答案，协议仍合法，但正确率显著下降，这是 GSM8K 奖励为 0 的常见原因之一。

第四段是运行与评测命令。

```bash
# 单轮提问
python -m scripts.chat_cli -p "Why is the sky blue?"

# 交互式多轮
python -m scripts.chat_cli

# 评测 SFT 检查点（全部 5 个任务）
torchrun --standalone --nproc_per_node=8 -m scripts.chat_eval -- -i sft
```

`chat_cli` 的默认采样参数为 `temperature=0.6`、`top_k=50`、`max_tokens=256`；`chat_eval` 的默认参数为 `temperature=0.0`（贪心）与 `max_new_tokens=512`。训练时 `temperature` 无意义，推理时的温度选择影响回复多样性，但 `chat_eval` 用贪心以保证可复现。

## 易错点

> [!warning] 以下六条均可在拼接、生成或评测日志中直接检验。
> 1. 推理时漏掉 `<|bos|>`。训练序列总以 BOS 开头，推理若从 `<|user_start|>` 开始，第一个注意力键就是错误 token，回复倾向于从句子中间开始。
> 2. 用字符串拼接代替 id 拼接。`"<|user_start|>" + text` 交给普通编码路径后不再是一个特殊 token，而是若干普通 token，模型看到的是字面量文本而非协议标记。
> 3. 忘记在生成后补 `<|assistant_end|>`。生成被 `max_tokens` 截断时，未闭合的 assistant 回合后面直接跟下一轮 `user_start`，上下文不再是合法对话，后续回复会错乱。
> 4. 流式解码多字节字符。逐 token `decode` 在 UTF-8 边界处产生替换字符；中文场景必须按字节缓冲，或在生成结束后整体解码。
> 5. 用 `render_conversation` 做采样提示。它保留最后一条 assistant 消息，等于把答案放进上下文，模型只需复述；采样必须用 `render_for_completion`。
> 6. 把 ChatCORE 当作 base 能力的度量。ChatCORE 只含对话任务，遗忘要在 base 的 CORE 上测；用 ChatCORE 判断「模型是否变笨」会得到错误结论。

## 关联笔记

- 前置 [[有监督微调SFT]]：掩码与打包的实现细节，是本文行为差异的直接来源。
- 前置 [[对话数据与SmolTalk]]：消息 schema 与 `render_conversation` 的校验规则。
- 对照 [[词表与特殊token]]：九个特殊 token 的编码方式与词表位置，决定协议能否用单 token 表达。
- 后续 [[CLI与WebUI]]：同一套拼接逻辑在命令行与网页端的复用与差异。
- 后续 [[GRPO原理与实现]]：以 chat 模型为策略初值，`render_for_completion` 是 rollout 的入口。
- 跨库 [[幻觉与缓解]]：SFT 只改变形式不改变知识边界，幻觉的成因与缓解在该篇。

## 达标检测

- [ ] 写出 base 与 chat 两个目标函数，指出条件项与求和范围的两处差别。
- [ ] 列出九个特殊 token 的开放者与掩码取值，说明为什么 `<|assistant_start|>` 的掩码是 0 而 `<|assistant_end|>` 是 1。
- [ ] 说明为什么推理时必须用 id 拼接而不是字符串拼接，并给出一个会失败的例子。
- [ ] 复述 `chat_cli` 的五个拼接不变量，指出漏掉任意一个的后果。
- [ ] 解释 `render_for_completion` 的两步外科手术，以及 categorical 评测为什么取 `len(ids)-1` 位置。
- [ ] 给出三条 SFT 后的行为变化及其机制，说明哪一条无法用 ChatCORE 观测。
- [ ] 设计一个实验测量 SFT 造成的 base 能力退化，写明需要的脚本与对照口径。

## 参考来源

- Ouyang et al., "Training language models to follow instructions with human feedback", arXiv:2203.02155, 2022 —— 对应第 1 节两种目标（对所有位置求和与只对回复求和）的区分，以及第 6 节「SFT 改变形式而非知识」的结论。
- Allal et al., "SmolLM2: When Smol Goes Big — Data-Centric Training of a Small Language Model", arXiv:2502.02737, 2025 —— 对应第 6 节英文为主的分布来源，以及第 7 节小模型的数据规模与遗忘关系。
- Karpathy, *nanochat*（commit 92d63d4），`nanochat/tokenizer.py`、`nanochat/engine.py`、`scripts/chat_cli.py`、`scripts/chat_eval.py`、`scripts/chat_rl.py` —— 对应第 2 至 5 节的特殊 token、拼接、流式解码与 `render_for_completion` 的全部实现细节。
- Karpathy, *nanochat*（commit 92d63d4），`tests/test_tokenizer.py` —— 对应第 2 节「普通文本不折叠特殊 token」的断言，以及第 5 节 `render_for_completion` 的剥离行为验证。
