对话数据与SmolTalk
定义
对话数据(conversation data)指以消息序列组织的监督微调样本:每条消息由角色(role)与内容(content)两个字段构成,角色取 system、user、assistant 之一,内容为该角色发言的字符串。SmolTalk 指 HuggingFace 数据集 HuggingFaceTB/smol-smoltalk 及其在 tasks/smoltalk.py 中的 Task 封装。Task 是 nanochat 对「数据集 + 元数据 + 评测准则」的统一抽象,提供长度、切片、逐条取对话与判分四个接口。
符号约定如下。
| 符号 | 含义 |
|---|---|
一条对话(conversation),即含 messages 键的字典 | |
| 对话中消息条数, | |
| 第 条消息的角色, | |
| 第 条消息的内容字符串 | |
| 一条对话渲染后的 token id 序列 | |
| 与 等长的损失掩码, | |
| 渲染后的 token 长度,渲染时截断到 2048 | |
一个 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 条带工具调用的数学样本。按行数计,通用对话占 ,是唯一提供「指令—回复」分布的任务,其余两个任务只负责格式与工具协议。
去掉 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 键下是消息列表。
{"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 在返回前做三层校验,逐条对应数据格式的假设。
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 段。第三层断言是格式的核心:、,依次交替;不允许两条连续 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 的流程是五行。
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 只承担两件事。
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 定义逻辑视图,不复制底层数据。
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
长度公式是 ,与 Python 切片的语义一致;逻辑下标 映射到物理下标 。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 把多个任务按行数比例交错。实现方式是先枚举所有 对,再用固定种子的 random.Random 打乱。
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 是另一种组合方式:不打乱,按列表顺序拼接。
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 下约产生 token,与 d24 预训练约 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」这类层级关系。
关键直觉
数据决定「行为分布」,渲染决定「哪些位置产生梯度」。SmolTalk 提供前者:460K 条 user/assistant 交替的样本,把对话协议的内容分布写进训练流;
render_conversation提供后者:同一批样本渲染后,只有 assistant 段与<|assistant_end|>的掩码为 1。与严格定义的关系:定义里的 与 是两个独立产物,长度相同但含义不同。 决定模型看到什么上下文, 决定哪些位置产生损失。混合与打包只改变 的排列与拼接方式,不改变 的构造规则;因此更换数据不会让掩码失效,更换掩码规则却会让所有数据同时失效。判断一次改动是否安全,先问它动的是 还是 。
例子与代码
第一段代码用字符级 tokenizer 复现 render_conversation 的结构,使掩码可以逐位置手算。三段实现与 repo 逐句对应,只有分词被替换。
"""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,因此总长 ,掩码和为 。
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。为避免依赖词表版本,只打印可判定的布尔量。
"""真实 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 数加上结束符,多一个或少一个都说明掩码区间错了。
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__ 就是为这一目的写的。
python -m tasks.common
输出包含四部分:MMLU 的完整长度、第 5 条的原始内容、切片后的长度与首元素一致性。下面的摘录只保留后两部分;前两部分的数值与内容都随数据集版本变化。
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 的验证裁剪就会取到错误的样本,而验证损失仍然能算出来,错误只能通过人工比对发现。
易错点
以下六条均可在取数与渲染阶段直接检验。
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 合并的断言与掩码边界,以及第二段代码的可检验结论。