一个问题

你在 ChatGPT 里输入"你好，世界"，模型真的收到了这六个字吗？

不是。模型收到的是一串数字，比如 [1, 47, 892, 15, 1024, 2]。

大语言模型的底层全是矩阵乘法和概率计算。它不认识汉字，不认识英文字母，甚至不认识空格。它只认识 数字。

30 秒上手体验

加载 MiniMind 的 Tokenizer，亲手完成一次编码和解码

>>> from transformers import AutoTokenizer
>>> tok = AutoTokenizer.from_pretrained("./model/")

>>> ids = tok.encode("你好，世界")
>>> print("Token IDs:", ids)
Token IDs: [1, 47, 892, 15, 1024, 2]

>>> text = tok.decode(ids)
>>> print("还原:", text)
还原: 你好，世界

三行代码，你就看到了 Tokenizer 的全部职责：文字 → 数字 → 文字。接下来的整个章节，我们要搞清楚这背后的每一步是怎么工作的。

Part 1：桥梁

Tokenizer 在大模型流水线中的位置——它是训练和推理的第一道关卡。

编码与解码

Tokenizer 同时承担两个方向的翻译

无论训练还是推理，所有文本 必须 先经过 Tokenizer 编码。它是大模型流水线的第一道关卡，也是最后一道关卡。

训练与推理流程

注意：训练和推理 必须使用同一个 Tokenizer。如果训练时"你好"编码为 [47, 892]，推理时换了一个 Tokenizer 把它编码为 [331, 502]，模型就完全看不懂了。

Part 2：Token

Tokenizer 不是把文本逐字符翻译——它有更聪明的拆分策略。

Token 形态

一个 Token 可以是完整的词、词的一部分、单个字符或特殊标记

ID 到向量

编号本身没有语义，必须通过 Embedding 查表变成向量

Token ID 只是一个整数编号，比如"你"的 ID 是 47。模型不能直接对整数做运算。

解决方法：Embedding 查表。模型内部有一张 6400 行 × d_model 列的矩阵。用 Token ID 当行号，取出对应的一行向量。

# 伪代码：Embedding 查表
embedding_matrix = torch.randn(6400, 512)  # 6400个Token, 每个512维
token_ids = [47, 892, 15, 1024]
vectors = embedding_matrix[token_ids]  # 取出4个512维向量
print(vectors.shape)  # torch.Size([4, 512])

编码粒度对比

不同分词策略对"unhappiness"的切分结果

Part 3：BPE

MiniMind 使用的分词算法——也是 GPT、LLaMA、Qwen 的共同选择。

BPE 核心思想

反复把最常一起出现的相邻 Token 对合并成新的 Token

就像搭积木：先有最小的积木块（单个字节），然后把经常一起出现的粘在一起，变成更大的积木块。

卸甲：这个比喻只是为了建立直观感受。计算机内部没有"积木"和"胶水"——BPE 是通过统计字节对的出现频率，迭代地将最高频的相邻字节对合并为新 Token，本质是频率统计加合并操作。

BPE 演示一

以语料 "low lower lowest low low lower" 为例，逐步演示合并过程

第 1 步：拆成字符

low    → [l, o, w]
lower  → [l, o, w, e, r]
lowest → [l, o, w, e, s, t]
low    → [l, o, w]
low    → [l, o, w]
lower  → [l, o, w, e, r]

第 2 步：统计相邻对频率

(l, o) → 6次  ← 最高频
(o, w) → 6次  ← 并列最高
(w, e) → 3次
(e, r) → 2次
(e, s) → 1次
(s, t) → 1次

当频次相同时，通常按 先出现的对 或 字典序 选择。这里选 (l, o)。

BPE 演示二

逐步合并，观察词表和序列如何变化

第 3 步：合并 (l, o) → lo，词表新增 1 个 Token

low    → [lo, w]
lower  → [lo, w, e, r]
lowest → [lo, w, e, s, t]

第 4 步：重新统计，(lo, w) 出现 6 次，合并 → low

low    → [low]
lower  → [low, e, r]
lowest → [low, e, s, t]

第 5 步：(e, r) 出现 2 次（最高频），合并 → er

lower  → [low, er]
lowest → [low, e, s, t]

以此类推，直到词表增长到目标大小（MiniMind 是 6400）。

BPE 处理新词

任何文本都能被编码，永远不会出现"无法处理"的情况

BPE 从字节级别开始构建，而字节只有 256 种。所以无论遇到什么文字——中文、日文、emoji、甚至火星文——都能编码。

BPE 四大优势

Part 4：训练

逐行拆解 trainer/train_tokenizer.py，看 MiniMind 如何训练自己的 Tokenizer。

整体流程图

常量与入口

训练脚本的顶部配置

DATA_PATH = '../dataset/sft_t2t_mini.jsonl'
TOKENIZER_DIR = '../model_learn_tokenizer/'
VOCAB_SIZE = 6400        # 词表目标大小
SPECIAL_TOKENS_NUM = 36  # 特殊 Token 数量

if __name__ == '__main__':
    train_tokenizer(DATA_PATH, TOKENIZER_DIR, VOCAB_SIZE)
    eval_tokenizer(TOKENIZER_DIR)

数据准备函数

get_texts() 用生成器逐行读取，避免一次性加载全部文本

def get_texts(data_path):
    with open(data_path, 'r', encoding='utf-8', errors='ignore') as f:
        for i, line in enumerate(f):
            if i >= 10000: break  # 最多取10000行
            try:
                data = json.loads(line)
                contents = [item.get('content')
                            for item in data.get('conversations', [])
                            if item.get('content')]
                if contents:
                    yield "\n".join(contents)
            except json.JSONDecodeError:
                continue

关键设计：

• 使用 yield 生成器而非 return 列表——10000 行文本可能有几百 MB，生成器逐条产出，内存友好。
• errors='ignore' 跳过编码异常字节——真实数据总有脏数据。
• try/except 跳过格式错误的行——保证流程不中断。

数据格式（JSONL，每行一条对话）：

{"conversations": [
    {"role": "user", "content": "你好"},
    {"role": "assistant", "content": "你好！有什么可以帮你的吗？"}
]}

特殊 Token

36 个特殊 Token 分为三组，每组承担不同功能

# 第1组：核心对话 + 多模态标记（21个）
special_tokens_list = [
    "##", "<|im_start|>", "<|im_end|>",
    "<|object_ref_start|>", "<|object_ref_end|>",
    "<|box_start|>", "<|box_end|>",
    "<|quad_start|>", "<|quad_end|>",
    "<|vision_start|>", "<|vision_end|>", "<|vision_pad|>",
    "<|image_pad|>", "<|video_pad|>",
    "<|audio_start|>", "<|audio_end|>", "<|audio_pad|>",
    "", "", "", ""
]

# 第2组：工具调用 + 思维链标记（6个）
additional_tokens_list = [
    "≶", "⋩",
    "ERRY", "INU",
    "KIN", "G"
]

# 第3组：预留 Buffer（9个）= 36 - 21 - 6
num_buffer = 36 - len(special_tokens_list + additional_tokens_list)
buffer_tokens = [f"<|buffer{i}|>" for i in range(1, num_buffer + 1)]

三组 Token 合并后总共 36 个。它们在训练阶段就被"锁定"，永远不会被 BPE 算法拆开或合并。

训练核心三步

创建模型 → 配置训练器 → 执行训练

# 第1步：创建空的 BPE 模型
tokenizer = Tokenizer(models.BPE())
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)

# 第2步：配置训练器
trainer = trainers.BpeTrainer(
    vocab_size=6400,                                    # 目标词表大小
    show_progress=True,                                  # 显示训练进度
    initial_alphabet=pre_tokenizers.ByteLevel.alphabet(), # 256个UTF-8字节作为初始词表
    special_tokens=all_special_tokens                    # 36个特殊Token
)

# 第3步：执行训练
texts = get_texts(data_path)
tokenizer.train_from_iterator(texts, trainer=trainer)
tokenizer.decoder = decoders.ByteLevel()

保存与后处理

训练完成后，需要保存 tokenizer.json 和 tokenizer_config.json

# 保存 tokenizer.json（BPE 模型文件）
os.makedirs(tokenizer_dir, exist_ok=True)
tokenizer.save(os.path.join(tokenizer_dir, "tokenizer.json"))

# 修正 added_tokens 的 special 标记
# additional_tokens（工具调用/思维链）不应该标记为 special
tokenizer_json_path = os.path.join(tokenizer_dir, "tokenizer.json")
with open(tokenizer_json_path, 'r', encoding='utf-8') as f:
    tokenizer_data = json.load(f)
for token_info in tokenizer_data.get('added_tokens', []):
    if token_info['content'] not in special_tokens_list:
        token_info['special'] = False  # 只有第1组才是真正的 special
with open(tokenizer_json_path, 'w', encoding='utf-8') as f:
    json.dump(tokenizer_data, f, ensure_ascii=False, indent=2)

为什么要修正 special 标记？ 因为 additional_tokens（工具调用的 ERY/INU/KIN/G 等）在 HuggingFace 的约定中不属于"特殊 Token"——它们是功能性标记，但不应该被 skip_special_tokens=True 过滤掉。

Part 5：词表

6400 个 Token 不是随意分配的——它由三层构成，每层职责不同。

三层构成

核心特殊 Token

最重要的 5 个特殊 Token 及其功能

36 个特殊 Token

按功能分组一览

为什么预留 9 个 Buffer？未来如果需要新增特殊 Token（比如新增模态支持），不用重新训练整个 Tokenizer——直接用预留位即可。

Part 6：模板

模型需要理解对话结构——哪些是系统指令、哪些是用户输入、哪些是模型回复。

对话格式化

一条多轮对话经过 Chat Template 后的样子

messages = [
    {"role": "system", "content": "你是一个优秀的聊天机器人"},
    {"role": "user", "content": "你来自哪里？"},
    {"role": "assistant", "content": "我来自月球"},
]

格式化后：

<|im_start|>system
你是一个优秀的聊天机器人<|im_end|>
<|im_start|>user
你来自哪里？<|im_end|>
<|im_start|>assistant
我来自月球<|im_end|>

通用模板格式：<|im_start|>{role}\n{content}<|im_end|>\n

格式规则解析

思维链模式

模型在回答之前先"思考"，推理更准确

MiniMind 的 Chat Template 内置了思维链（Chain of Thought）支持。当开启 open_thinking 时：

<|im_start|>assistant
KIN
让我分析一下这个问题...
首先考虑...
所以答案是...

G

我来自地球<|im_end|>

KIN 和 G 是思维链的起止标记。模型在 KIN 和 G 之间的内容是"思考过程"，之后才是最终回答。

工具调用格式

模型可以调用外部工具，结果通过特定格式嵌入对话

<|im_start|>assistant
ERY
{"name": "get_weather", "arguments": {"city": "北京"}}
INU<|im_end|>
<|im_start|>user
ERRY
{"temperature": 25, "condition": "晴"}
INU<|im_end|>

ERY 和 INU 标记 XML 样式的工具调用。模型输出调用请求，框架执行工具后把结果用 ERRY/INU 包裹，再交给模型继续生成。

代码调用方式

使用 HuggingFace 的 AutoTokenizer 一键应用 Chat Template

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("./model_learn_tokenizer/")

messages = [
    {"role": "system", "content": "你是一个优秀的聊天机器人"},
    {"role": "user", "content": "你来自哪里？"},
]

# 应用模板（tokenize=False 返回格式化后的文本）
formatted = tokenizer.apply_chat_template(messages, tokenize=False)
print(formatted)

# 直接编码为 Token IDs（tokenize=True，默认行为）
ids = tokenizer.apply_chat_template(messages, tokenize=True)
print("Token IDs:", ids)

Part 7：配置

train_tokenizer.py 生成的两个核心配置文件——tokenizer.json 和 tokenizer_config.json。

配置文件

HuggingFace Tokenizer 的全局配置文件

注意：model_max_length 是 Tokenizer 的理论上限。MiniMind 默认上下文窗口是 512，实际不能处理 128K 的输入。

解码器结构

36 个特殊 Token 的 ID 映射表

训练脚本在保存配置时，为每个特殊 Token 生成了详细的描述条目：

added_tokens_decoder = {}
for i, token in enumerate(all_special_tokens):
    idx = tokenizer.token_to_id(token)
    added_tokens_decoder[str(idx)] = {
        "content": token,
        "lstrip": False,        # 左侧不去空格
        "normalized": False,    # 不参与 BPE 归一化
        "rstrip": False,        # 右侧不去空格
        "single_word": False,   # 可以出现在词中间
        "special": True if token in special_tokens_list else False
    }

区分 special 标记：只有 special_tokens_list（第 1 组，核心对话 + 多模态）的 Token 的 special 字段为 True。additional_tokens（工具调用、思维链）设为 False——这样 decode(ids, skip_special_tokens=True) 时不会把它们过滤掉。

Part 8：测试

训练完 Tokenizer 后，怎么判断它好不好？四个维度的测试。

四项核心测试

模板测试

构造多轮对话，验证格式化输出正确

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir)
messages = [
    {"role": "system", "content": "你是一个优秀的聊天机器人"},
    {"role": "user", "content": "你来自哪里？"},
    {"role": "assistant", "content": "我来自月球"},
    {"role": "user", "content": "你到底来自哪里？"},
    {"role": "assistant", "content": "我来自地球"},
]

new_prompt = tokenizer.apply_chat_template(messages, tokenize=False)
print(new_prompt)

检查点：输出中每条消息都应该被 <|im_start|>role\ncontent<|im_end|> 正确包裹。

压缩率测试

衡量 Tokenizer 编码效率的核心指标

test_texts = [
    "人工智能是计算机科学的一个分支...",   # 中文样本
    "Large language models (LLMs) are...", # 英文样本
    "Python 是一种高级编程语言...",         # 中英混合
]

for i, text in enumerate(test_texts):
    encoded = tokenizer.encode(text)
    ratio = len(text) / len(encoded)
    print(f"样本 {i+1} | 字符数: {len(text):4} | Tokens: {len(encoded):3} | 压缩率: {ratio:.2f}")

编解码一致性

encode → decode 必须原样还原

model_inputs = tokenizer(new_prompt)
response = tokenizer.decode(model_inputs['input_ids'],
                           skip_special_tokens=False)
print('一致性:', response == new_prompt)  # 必须为 True

如果结果是 False，说明编解码过程中有信息丢失或额外字符混入。常见原因：

• Token 之间的空格被吃掉或多余
• 特殊 Token 的编解码规则不一致
• pre_tokenizer 和 decoder 不匹配

流式解码

解决逐 Token 生成时的 UTF-8 乱码问题

中文字符由 3 个 UTF-8 字节组成。如果模型每次只输出 1~2 个字节对应的 Token，直接 decode 会产生 �（乱码占位符）。

解决方法：字节缓冲。积累 Token，直到能完整解码为合法字符时才输出。

input_ids = model_inputs['input_ids']
token_cache = []
for tid in input_ids:
    token_cache.append(tid)
    current_decode = tokenizer.decode(token_cache)
    if current_decode and '�' not in current_decode:
        # 没有乱码 → 字符完整了，输出并清空缓冲区
        raw_tokens = [tokenizer.convert_ids_to_tokens(int(t)) for t in token_cache]
        print(f'Token IDs: {token_cache} -> {current_decode}')
        token_cache = []

Part 9：排错

训练和使用 Tokenizer 时最容易踩的坑。

训练阶段错误

使用阶段错误

重要提醒

Part 10：练习

理论学完了，动手验证才是真正的理解。

练习：编解码

任务：加载 MiniMind Tokenizer，完成以下操作并观察结果。

>>> from transformers import AutoTokenizer
>>> tok = AutoTokenizer.from_pretrained("./model/")

>>> # 1. 编码一段中文
>>> ids = tok.encode("你好世界")
>>> print("Token IDs:", ids)

>>> # 2. 解码回来
>>> text = tok.decode(ids)
>>> print("解码:", text)

>>> # 3. 逐个查看 Token
>>> for tid in ids:
...     print(f"ID {tid} -> {tok.decode([tid])}")

思考题

1. 每个中文字对应几个 Token？为什么不是一个汉字一个？
2. 计算压缩率：len("你好世界") / len(ids)，结果是几？
3. 试试编码 "Hello World"，对比中英文的压缩率差异。

练习：模板

任务：构造一段包含 system、user、assistant 三种角色的对话，用 apply_chat_template 格式化，观察输出。

messages = [
    {"role": "system", "content": "你是一个翻译助手"},
    {"role": "user", "content": "请把'人工智能'翻译成英文"},
    {"role": "assistant", "content": "Artificial Intelligence"},
]

formatted = tok.apply_chat_template(messages, tokenize=False)
print(formatted)

# 数一数有多少个 <|im_start|> 和 <|im_end|>
print("im_start 数量:", formatted.count("<|im_start|>"))
print("im_end 数量:", formatted.count("<|im_end|>"))

思考题

1. 为什么 im_start 和 im_end 的数量相同？
2. 如果把 tokenize=False 改成 True，返回值变成了什么？
3. 尝试添加一条 role: "tool" 的消息，观察模板如何处理。

练习：压缩率

任务：用下面的测试代码对比中文、英文、混合文本的压缩率。

test_texts = {
    "中文": "人工智能是计算机科学的一个分支，它企图了解智能的实质。",
    "英文": "Artificial intelligence is a branch of computer science.",
    "混合": "Python是一种高级编程语言，widely used in data science.",
    "代码": "def hello_world():\n    print('Hello, World!')",
    "Emoji": "你好👋世界🌍今天天气☀️真好",
}

for label, text in test_texts.items():
    encoded = tok.encode(text)
    ratio = len(text) / len(encoded)
    print(f"{label:4} | 字符: {len(text):3} | Tokens: {len(encoded):3} | 压缩率: {ratio:.2f}")

思考题

1. 哪种类型的压缩率最高？为什么？
2. Emoji 的压缩率为什么可能比普通中文还低？
3. 如果压缩率低于 1.0，意味着什么？

关键要点回顾

延伸阅读