w wyl123ly 的博客
MD

从生成式到对话式

30 KB 2026.10.22 原文件

从生成式到对话式

定义

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

符号约定如下。

符号含义
文档语料,base 模型的训练分布
对话语料,SFT 的训练分布
参数为 的下一 token 分布
用户侧提示(system 与 user token 序列)
assistant 回复 token 序列
协议渲染函数,即 render_conversation
推理时的会话状态,conversation_tokens
训练上下文长度,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 模型在一个文档序列 上最大化

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

chat 模型的目标是条件分布

其中 由 从用户消息渲染而来, 是 assistant 回合的内容(包括 <|assistant_end|>)。差别有两处:条件项 被固定为提示,求和只覆盖回复; 本身带有协议标记,使模型能区分「这是要回复的输入」与「这是要延续的文本」。

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

2. 特殊 token 如何定义轮次

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

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>`数据加载器文档起点,也作 padding0
`<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|> 作为生成起点。

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,因此第 轮的提示长度是前 轮的总和。这带来两个后果:KV 缓存随轮数线性增长;上下文一旦超过训练长度 ,模型进入训练中未见过的位置区间,回复质量下降。代码没有截断逻辑,位置编码表按 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 列表,用于采样。

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。设第 轮新增的 token 数为 (用户输入、四个角色控制符与回复之和),则第 轮 prefill 的长度为

到第 轮为止累计 prefill 的 token 数为 ,在多轮等长时随轮数平方增长。这与 KV Cache原理 中「缓存把每步降为 」的结论并不矛盾:缓存消除的是单轮内的重复计算,而 chat_cli 在轮与轮之间丢弃缓存、重新构建,因此跨轮的重复仍然存在。缓存容量由每次调用重新分配,峰值取决于最长一轮的提示长度,而不是各轮之和。

轮数单轮新增 token该轮 prefill 长度累计 prefill token
1100100100
51005001500
1010010005500
20100200021000

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

在 nanochat 中的落地

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

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

关键直觉

base 模型学的是「在这个位置,语料中最可能出现的下一个 token 是什么」;chat 模型学的是「在协议的这个位置上,assistant 应当给出什么」。协议是显式的 token 结构,不是隐式的语气;因此推理时少一个特殊 token,模型面对的就是一个训练中不存在的状态。

与严格定义的关系:定义中的 是协议的唯一实现,训练与推理都必须经过它。条件分布 里的 不是原始用户文本,而是 渲染后的 token 序列;把 换成原始文本,条件项就与训练不一致,模型输出的分布随之漂移。这条关系解释了为什么对话模板必须逐 token 复现,也解释了为什么特殊 token 的嵌入虽然只有初始化值,却能在 SFT 后被赋予稳定含义。

例子与代码

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

"""会话状态机的最小复现:与 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)

预期输出如下。

第 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,因此第 轮的计算量随累计长度增长。

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

"""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|> 由函数重新追加。

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

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

$ 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 序列在文本层面是(示意,回复按单句计)

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

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

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 的常见原因之一。

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

# 单轮提问
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 用贪心以保证可复现。

易错点

以下六条均可在拼接、生成或评测日志中直接检验。

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 的剥离行为验证。