Datasets与Tokenizers数据处理库

可视化演示

展示SQL查询优化器生成执行计划、连接顺序优化和代价估算对比过程，动态演示基于代价的优化器决策机制。

认识双引擎

中央厨房开业第一课，不是学炒菜，而是先认识两位管后勤的骨干。小 D 是仓库管理员，负责接收一车车生鲜、盘点库存、按需求把食材送到备餐台；小 T 是切菜机操作员，负责把整棵菜、整块肉切成统一规格的小块。没有他们，大厨（Transformer 模型）再厉害，也只能对着一堆没处理的原材料发愣。

在大模型训练里，这两台“机器”就是 Hugging Face 生态中的 Datasets 库和 Tokenizers 库。任何深度学习项目的首要环节，都是把散落在磁盘上的文本、表格变成模型能吃的数字张量。Datasets 负责“存取”，Tokenizers 负责“切分”，两者互相独立又紧密配合，构成了大模型数据预处理的标准工具链。

Datasets 库内置了 CSV、JSON、Parquet、文本等多种格式的读取器，并实现了内存映射、流式读取等机制；Tokenizers 库则基于 Rust 重写了分词逻辑，多线程并行下的速度比 Python 原生实现快几十倍。它们被设计成不含模型逻辑的纯数据管线，所以可以放心用于任何框架。整个预处理流程可以用一个复合函数表示：

$$\displaystyle \text{模型输入} = g_{\text{Tokenizers}}\left( f_{\text{Datasets}}(\text{原始语料}) \right)$$

1. 原始语料：磁盘上的 txt/csv/json 文件，相当于刚运来的整箱食材，一箱一箱等待拆封。

$$\displaystyle \text{语料} = \{\text{doc}_1, \text{doc}_2, \ldots, \text{doc}_N\}$$

2. f_Datasets 函数：Datasets 库完成加载、清洗、筛选、切分训练与验证集，相当于仓库管理员收货、理货、分拣。

$$\displaystyle \mathcal{D} = f_{\text{Datasets}}(\text{语料})$$

3. g_Tokenizers 函数：Tokenizers 库把每篇文档切成子词序列并映射成 ID，相当于切菜机切块后贴上编号标签。

$$\displaystyle \mathbf{x}_i = g_{\text{Tokenizers}}(d_i), \quad d_i \in \mathcal{D}$$

4. 复合顺序：先 f 后 g，输出直接喂给模型，形成一条从磁盘到 GPU 的干净流水线。

$$\displaystyle \text{模型输入} = \{\mathbf{x}_1, \mathbf{x}_2, \ldots, \mathbf{x}_N\}$$

只要这条流水线通畅，大厨只管开火炒菜，不用再操心食材从哪来、怎么切——这正是现代大模型训练能规模化复制的秘密。

数据集加载

小 D 最拿手的一招叫“透视玻璃墙”。普通仓库要拿货，得把整柜货搬到备餐区；小 D 的仓库墙是半透明的，大厨站在这边，就能透过墙看清每一格货架上的东西，需要哪块取哪块，货柜本身纹丝不动。

对应到技术，这面“透视墙”就是操作系统的内存映射（mmap）。Datasets 加载大文件时，并不把整个文件读进内存，而是让文件内容以虚拟内存页的形式暴露给程序。程序访问哪一部分，操作系统才把那几 KB 的页真实载入物理内存。对于动辄几十 GB、甚至 TB 级的数据集，这是“能跑”和“不能跑”的区别。

内存映射带来的第一个好处是“零拷贝”——数据从磁盘到模型视野只需一次缺页中断，不需要先整份复制进用户空间；第二个好处是“按需读取”，训练时往往只需访问少量样本，物理内存占用非常低。更进一步，Datasets 还提供 streaming 模式，把数据集当成一根水管，按批次从远端或本地源源不断地流出，适合无法整体装入单机的大规模语料。内存占用的数学表达：

$$\displaystyle M_{\text{RSS}} = N_{\text{访问页}} \times S_{\text{页大小}}$$

1. M_RSS：程序实际占用的物理内存，单位是字节或 MB，决定这台机器能不能扛住这份数据。

$$\displaystyle M_{\text{RSS}} \approx \text{实际占用内存}$$

2. N_访问页：程序真正读取过的内存页数量。mmap 下只有访问到的页才被调入，其余页面仍在磁盘上睡觉。

$$\displaystyle N_{\text{访问页}} \ll N_{\text{总页数}}$$

3. S_页大小：操作系统管理内存的最小单位，多数平台是 4096 字节（4KB）。

$$\displaystyle S_{\text{页大小}} = 4\,\text{KB}$$

4. 乘积关系：两者相乘才构成真实内存占用，这说明“文件多大”不等于“内存要多大”。

$$\displaystyle M_{\text{RSS}} = N_{\text{访问页}} \times 4\,\text{KB}$$

小 D 的透视墙让 TB 级仓库变得轻若无物，训练时只取需要的几十个样本，物理内存纹丝不动——这就是大模型团队敢直接拿整个互联网语料开练的底气。

高效数据加工

食材进了仓库，还要经历流水线加工：洗菜（map）、挑出烂叶（filter）、把一锅菜搅拌均匀（shuffle）。小 D 的流水线有个聪明设计——每道工序做完就把半成品存进冷柜（cache），下次做同样的菜直接拿出来用，不用再洗一遍。

在 Datasets 中，这三道工序对应三个核心 API：map 对每个样本执行变换函数，适合做文本清洗、字段补充、批量分词；filter 按布尔条件筛掉不合格样本，比如丢弃空文本；shuffle 打乱数据顺序，避免模型学到批次内的虚假规律。它们都支持批处理、多进程并行，并且默认开启缓存。

map 的 batched=True 参数把样本打包成批次交给函数，函数内部可以用 tokenizer 的批量接口，吞吐量提升一个量级；num_proc 参数再开多进程，吃满 CPU。缓存机制则用“数据集版本 + 处理函数 + 参数”生成哈希键，同名键直接复用磁盘缓存，省掉重复计算。整个加工流程可以写成函数嵌套：

$$\displaystyle \mathcal{D}' = \text{shuffle}\Big( \text{filter}\big( \text{map}(\mathcal{D}, f),\, p \big) \Big)$$

1. D 原始数据集：map 的输入，相当于刚从仓库领出的整筐菜，等待逐棵处理。

$$\displaystyle \mathcal{D} = \{x_1, x_2, \ldots, x_N\}$$

2. map(D, f)：对每个样本执行变换 f，比如截断文本、补全字段；batched 模式下 f 一次处理一批。

$$\displaystyle \tilde{x}_i = f(x_i)$$

3. filter(……, p)：按谓词 p 逐个判断，p 为真保留、为假丢弃，相当于挑出烂叶扔掉。

$$\displaystyle \mathcal{D}_{\text{filter}} = \{ \tilde{x}_i \mid p(\tilde{x}_i) = \text{True} \}$$

4. shuffle(……)：把顺序彻底打乱，防止模型学到“前面都是同类样本”的批次偏见。

$$\displaystyle \mathcal{D}' = \text{random\_shuffle}(\mathcal{D}_{\text{filter}})$$

洗、挑、拌三道工序加上冷柜缓存，让十万条数据的加工从“每次从头再来”变成“一次性投入、无限次复用”，小 D 的流水线因此越跑越快。

BPE分词原理

小 T 这台切菜机不认识“字”和“词”的传统分界，它只遵循一条朴素准则：哪两个相邻的小块总是一起出现，就把它们焊成一块。就像厨房发现“番”和“茄”总是成对出现，干脆预先把它们做成“番茄”半成品，下次直接取用。

这条准则就是 BPE（Byte Pair Encoding，字节对编码）的核心。BPE 是一种子词切分算法，先以字符为单位切开所有文本，然后反复统计相邻字符对的频次，把最高频的一对合并成一个新符号，写进词表。GPT 系列模型用的就是 BPE（或其变体 byte-level BPE）。

BPE 训练过程完全数据驱动：只需要给定目标词表大小（比如 50k），算法就自动迭代合并，直到词表达到目标。合并规则被保存下来，推理时对任意新词，只需按规则从左到右反复合并，就能得到一组子词。新词若由未见过的字符组合而成，则自动回退到字符级，天然免疫“未登录词”问题。合并的数学表示：

$$\displaystyle (a, b)^* = \arg\max_{(a,b)} \operatorname{count}(a \cdot b), \qquad \mathcal{V} \leftarrow \mathcal{V} \cup \{a \cdot b\}$$

1. 相邻符号对 (a, b)：把语料拆成当前符号序列后，所有相邻的两个符号构成候选对，如 l-o、o-w、e-s。

$$\displaystyle \text{pairs} = \{(x_i, x_{i+1})\}$$

2. count(a * b)：统计每个相邻对在全部语料中出现的次数，这是合并的“民意调查”。

$$\displaystyle \operatorname{count}(a \cdot b) = \sum_{i} \mathbf{1}[x_i x_{i+1} = ab]$$

3. arg max 选最高频：在所有候选对中挑出频次最高的那一对，作为本轮合并对象。

$$\displaystyle (a, b)^* = \arg\max_{(a,b)} \operatorname{count}(a \cdot b)$$

4. V 更新词表：把合并出的新符号 ab 加入词表 V，下一轮在新序列上继续统计、合并，直到达到 vocab_size。

$$\displaystyle \mathcal{V} \leftarrow \mathcal{V} \cup \{a \cdot b\}$$

小 T 用这套“民意合并法”，把英语里常见的 "low" "est" 等高频碎片焊成了半成品，词表既小又能覆盖绝大多数真实文本，连没见过的生词也能按规则拼出来。

其它分词算法

除了 BPE 这台“焊机”，切菜机还内置了另外两套刀法：WordPiece 是“看菜下刀”——合并前先算一算这对食材是不是门当户对；Unigram 则是“先切碎再选优”——把所有可能的切法摆出来，按概率挑最像样的那种。

WordPiece 是 BERT 使用的分词算法，同样从字符出发逐步合并，但选择合并对时不看原始频次，而是看一个打分公式：共现频次除以两个符号各自频次的乘积。Unigram 则相反，它先构造一个超大的候选词表（包含所有可能的子串），再用 EM 算法反复删除对整体概率贡献最小的词，直到词表收敛到目标大小；推理时用维特比算法找出概率最高的切分。

两者各有特点：WordPiece 的分词效果与 BPE 接近，但打分公式更偏向“粘合度高”的搭配；Unigram 支持基于概率的采样与回退，日语等形态丰富的语言常用它。实际选择往往看生态惯例——BERT 系用 WordPiece，GPT 系用 BPE，T5/mT5 等则用 SentencePiece 的 Unigram。两个核心公式：

$$\displaystyle s_{\text{WP}}(a,b) = \frac{\operatorname{count}(a\cdot b)}{\operatorname{count}(a)\times\operatorname{count}(b)}, \qquad P_{\text{UNI}}(\mathbf{x}) = \prod_{j=1}^{m} P(t_j)$$

1. WP 打分公式：count(a·b) 是共现频次，除以各自频次乘积起到归一化作用，防止高频符号抱团垄断。

$$\displaystyle s_{\text{WP}}(a,b) = \frac{\operatorname{count}(a\cdot b)}{\operatorname{count}(a)\times\operatorname{count}(b)}$$

2. 选分最高合并：每轮挑 score 最大的对合并，与 BPE 选 count 最大的对形成鲜明区别。

$$\displaystyle (a,b)^* = \arg\max_{(a,b)} s_{\text{WP}}(a,b)$$

3. Unigram 整体概率：一段文本 x 被切成 t1 到 tm 后，整段概率等于各 token 概率连乘，越高代表切分越合理。

$$\displaystyle P(\mathbf{x}) = P(t_1)\,P(t_2)\cdots P(t_m)$$

4. 删词迭代：训练时从超大词表出发，删除让整体似然下降最少的词，直到词表缩到目标大小。

$$\displaystyle \mathcal{V}_{k+1} = \mathcal{V}_k \setminus \{ t^* \}, \quad t^* = \arg\min_{t} \Delta \mathcal{L}$$

三套刀法殊途同归——都是把“字”拼成“词块”，只是合并的尺子和路线不同。小 T 的刀架上三种刀头齐全，任何语言、任何模型都能找到匹配的那把。

分词器实战

买来切菜机，得先让它“学会”你厨房的食材结构。小 T 的启动步骤很快：喂几万条菜谱，它几秒钟就能统计出高频搭配、生成专属刀法库，然后存成配置文件，以后开机直接加载。这批“刀法库”里还预置了几个特殊挡位，比如 [PAD] 表示空盘、[CLS] 表示上菜铃。

在 tokenizers 库中，训练分词器只需三步：创建模型（BPE/WordPiece/Unigram）、配置预切分器（是否按空格/标点预切）、调用 train_from_iterator 喂入语料。得益于 Rust 实现和多线程，训练 10 万条样本的 BPE 通常只要几秒到几十秒。训练产物可 save 成单个 JSON 文件，加载时 tokenizer_from_file 一行复原。

特殊 token 必须在训练前通过 special_tokens 参数声明，它们会被分配专属 ID，并在 BPE 合并时被当作不可拆分的整体，从而保证 [CLS]、[SEP] 等控制符始终完整。编码阶段，encode 返回包含 tokens、ids、attention_mask 等信息的 Encoding 对象；批量场景用 encode_batch 配合预编译算子，速度提升明显。词表与特殊词的并集关系：

$$\displaystyle \mathcal{V}_{\text{final}} = \mathcal{V}_{\text{subword}} \cup \mathcal{V}_{\text{special}}$$

1. V_subword：BPE/WordPiece 训练出的子词词表，负责把文本切成有意义的碎片。

$$\displaystyle \mathcal{V}_{\text{subword}} = \{t_1, t_2, \ldots, t_K\}$$

2. V_special：特殊 token 集合，如 [PAD]、[CLS]、[SEP]、[MASK]、[UNK]，各自独占一个 ID。

$$\displaystyle \mathcal{V}_{\text{special}} = \{[\text{PAD}], [\text{CLS}], [\text{SEP}], [\text{MASK}], [\text{UNK}]\}$$

3. 并集：最终词表是两者拼接，特殊 token 不参与合并、不被拆碎。

$$\displaystyle \mathcal{V}_{\text{final}} = \mathcal{V}_{\text{subword}} \cup \mathcal{V}_{\text{special}}$$

4. 批处理补白：定长批次里不足的部分用 [PAD] 填充，并用 attention_mask 标记真实 token 的位置，避免模型把空白当真。

$$\displaystyle \text{attention\_mask}_{i,j} = \mathbf{1}[x_{i,j} \neq [\text{PAD}]]$$

小 T 学会刀法后，把配置文件往流水线里一插，从此每个新来的食材都被自动切成统一切法，还自带“这是真菜、那是空盘”的标签，大大方便了大厨批量下锅。

生态集成

中央厨房的终极形态，是仓库、切菜机、灶台全部接入同一条传送带。小 D 把样本送到小 T，小 T 切好贴上标签，标签随传送带直接进大厨的炒锅——全程无人搬运、无缝衔接。

Hugging Face 生态里，这条传送带就是 Datasets 与 Transformers/Trainer 的深度集成。最典型的做法：用 Dataset.map 对整个训练集一次性完成分词，产出 input_ids 和 attention_mask 两列；随后直接传给 Trainer，或用 DataLoader 按批加载。由于列式内存布局和 Arrow 格式，这套流程比手工写循环快得多，也省去大量模板代码。

集成时要注意预处理对齐：训练与推理必须使用同一个 tokenizer 配置文件，padding 与 truncation 策略要一致，特殊 token 的 ID 才对应得上。Rust 的速度与 Python 的易用性在这里汇合——tokenizers 在 map 内部以原生速度跑批量编码，Datasets 提供并行缓存，Transformers 负责把 ID 序列组装成张量并喂给模型。一条样本的最终形态：

$$\displaystyle x_i = [\text{CLS}] \oplus \text{tokens}(d_i) \oplus [\text{SEP}]$$

1. tokens(d_i)：tokenizer 把第 i 篇文档切成子词序列，如 ["low", "est"]。

$$\displaystyle \text{tokens}(d_i) = [t_1, t_2, \ldots, t_m]$$

2. [CLS] 开头：分类或序列起始标记加在最前面，BERT 系用它汇总整句信息。

$$\displaystyle x_i = [\text{CLS}] \oplus [t_1, \ldots, t_m]$$

3. [SEP] 结尾：分隔或句子结束标记加在最后面，让模型知道序列边界。

$$\displaystyle x_i = [\text{CLS}] \oplus [t_1, \ldots, t_m] \oplus [\text{SEP}]$$

4. 批量对齐：batch 内每条样本经 padding 对齐到相同长度 L，再转为张量交给模型前向。

$$\displaystyle \mathbf{X} = \text{pad}([x_1, x_2, \ldots, x_B]) \in \mathbb{Z}^{B \times L}$$

传送带一开，小 D 送菜、小 T 切菜、大厨炒菜三个环节自动咬合。十亿参数的大模型训练，就这么被拆成一条每个人都能拧螺丝的标准化流水线——这就是现代 AI 工程化的魅力。

AI 应用场景

Python 演示

from datasets import Datasetfrom tokenizers import Tokenizerfrom tokenizers.models import BPEfrom tokenizers.trainers import BpeTrainerfrom tokenizers.pre_tokenizers import Whitespace # 1. 用几行英文文本模拟原始语料corpus = Dataset.from_dict({    "text": [        "the quick brown fox jumps over the lazy dog",        "machine learning models need high quality data",        "datasets and tokenizers are the foundation of llm",        "attention is all you need for transformer models",        "the dog and the fox are quick learners today",    ]})print("语料样本数:", len(corpus)) # 2. 训练一个 BPE 分词器, 词表较小便于观察tokenizer = Tokenizer(BPE(unk_token="[UNK]"))tokenizer.pre_tokenizer = Whitespace()trainer = BpeTrainer(    vocab_size=80,    special_tokens=["[UNK]", "[PAD]", "[CLS]", "[SEP]", "[MASK]"],)tokenizer.train_from_iterator(corpus["text"], trainer) # 3. 编码一条新句子, 查看子词切分结果sentence = "the quick fox learns fast"output = tokenizer.encode(sentence)print("原始句子:", sentence)print("分词结果:", output.tokens)print("Token IDs:", output.ids) # 4. 用 Datasets 的 map 批量编码整个数据集def encode_batch(batch):    results = tokenizer.encode_batch(batch["text"])    return {"input_ids": [r.ids for r in results]} encoded = corpus.map(encode_batch, batched=True)print("第一条样本:", encoded[0]["text"])print("第一条input_ids:", encoded[0]["input_ids"])

1. corpus = Dataset.from_dict({用字典直接构造内存数据集，免去落地文件的麻烦。
2. tokenizer = Tokenizer(BPE(unk_token="[UNK]"))创建 BPE 模型并指定未知词兜底符号。
3. tokenizer.pre_tokenizer = Whitespace()先按空格预切成词，再对词内部做 BPE 合并。
4. trainer = BpeTrainer(vocab_size=80, ...)设定词表规模与 5 个特殊 token。
5. tokenizer.train_from_iterator(corpus["text"], trainer)一次遍历完成统计与合并，核心训练入口。
6. output = tokenizer.encode(sentence)对全新句子编码，得到分词结果与 ID 序列。
7. print("分词结果:", output.tokens)直观看到子词如何被切出，验证训练效果。
8. encoded = corpus.map(encode_batch, batched=True)对整个数据集批量编码，产出模型输入列。
9. return {"input_ids": [r.ids for r in results]}从批量结果中提取每条的 ID 序列并存入新字段。

常见误区

面试题