---
tags: [nanochat, tokenizer, 分词粒度]
阶段: 03-分词器Tokenizer
难度: ★★☆
created: 2026-10-22
related: "[[字节对编码BPE原理]], [[词表与特殊token]], [[数据加载器dataloader]], [[Tokenizer与BPE]]"
---

# 为什么需要分词

## 定义

**分词器**（tokenizer）是一个确定性映射 $\pi:\Sigma^{*}\to\mathcal{V}^{*}$，把字节串（文本的 UTF-8 编码）映射为词表 $\mathcal{V}$ 上的整数 id 序列，并附带逆映射 $\mathrm{decode}:\mathcal{V}^{*}\to\Sigma^{*}$，满足 $\mathrm{decode}(\mathrm{encode}(s))=s$；**粒度**（granularity）指 $\mathcal{V}$ 中元素的构成单位，分字符级、词级、子词级三类。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $s$ | 原始文本，按 Unicode 字符串处理 |
| $B$ | $s$ 的 UTF-8 编码字节数，$B=\lvert\mathrm{utf8}(s)\rvert$ |
| $T$ | 分词后的 token 数，即送入模型的序列长度 |
| $\mathcal{V}$、$V$ | 词表与词表大小，$V=\lvert\mathcal{V}\rvert$ |
| $d$ | 模型隐藏维度；nanochat d24 中 $d=1536$ |
| $L$ | Transformer 层数；d24 中 $L=24$ |
| $\kappa$ | 压缩率，$\kappa=B/T$，单位是字节每 token |
| bpb | bits per byte，交叉熵按原始字节数归一化后的值 |
| $\bar{\mathcal{L}}$ | 每 token 的平均交叉熵，单位 nat |

其余术语在首次出现处定义：**未登录词**（out-of-vocabulary，OOV）指无法映射为单个词表条目的字符串；**子词**（subword）指介于字符与词之间的切分单元；**预切分**（pretokenization）指在 BPE 合并之前用正则把文本切成不可跨界的片段；**特殊 token** 指不参与频次统计、由字面量精确匹配的控制符号；**词表填充**（vocabulary padding）指把词表大小向上补齐到某个整数倍以便矩阵对齐。

## 为什么重要

分词器决定三个进入训练成本的量，而这三个量互相牵制：

1. 词表大小 $V$ 决定嵌入矩阵 `wte` 的参数量 $Vd$ 与输出投影 `lm_head` 的参数量 $Vd$。nanochat 的 `lm_head` 与 `wte` 不共享权重，因此输出侧同样占 $Vd$ 个参数。
2. 词表大小 $V$ 同时决定每 token 输出投影的乘加次数 $Vd$，以及 logits 张量的显存 $B\cdot T\cdot V$ 个元素。
3. 序列长度 $T$ 决定注意力的 $O(T^{2})$ 计算与 KV Cache 的 $O(T)$ 显存，见 [[KV Cache原理]]。压缩率 $\kappa$ 越高，同样上下文窗口能容纳的原始字节越多。

这三个量都不是预处理细节。改动词表会让 checkpoint 的嵌入矩阵尺寸、特殊 token 的 id、评测指标的分母同时变化，因此分词方案必须在训练开始前固定。nanochat 的整条流水线共享同一个 `tokenizer` 目录：`scripts/tok_train.py` 训练并写出 `tokenizer.pkl` 与 `token_bytes.pt`，`scripts/base_train.py` 读取 `tokenizer.get_vocab_size()` 建模型，`nanochat/dataloader.py` 用 `tokenizer.encode(..., prepend=bos)` 产出训练行，`scripts/chat_sft.py` 用 `render_conversation` 产出带 mask 的对话，`scripts/base_eval.py` 用 `token_bytes` 把损失换算成 bpb。任何一步用了不同词表，后续产物都不可复用。

nanochat 取 $V=32768=2^{15}$，这一取值与三处代码直接相关：`scripts/tok_train.py` 的 `--vocab-size` 默认值 32768；`nanochat/gpt.py` 中 `GPTConfig.vocab_size` 的默认值 32768；`nanochat/tokenizer.py` 的断言 `vocab_size_no_special >= 256`，即 32768 减 9 个特殊 token 后仍必须覆盖全部单字节。README 没有给出成文理由，但从代码与实验记录可以还原三条依据。其一，32768 是 $2^{15}$ 且是 64 的倍数，与 `GPT.__init__` 的 `pad_vocab_size_to=64` 对齐，词表不需要补齐，嵌入矩阵行数即 32768。其二，$V=32768$、$d=1536$ 时 `wte` 与 `lm_head` 合计约 $1.0\times10^{8}$ 个参数，约为 d24 主体参数 $6.8\times10^{8}$ 的 15%；若扩到 100K 词表，这两项合计约 $3.1\times10^{8}$，约为原来的 3 倍，在 4e19 FLOPs 的 speedrun 预算下不划算。其三，`dev/LOG.md` 2026-01-13 在 d12、32K 词表上验证预切分粒度时，`\p{N}{1,2}` 取得 0.965 的 val_bpb，优于 `{1,1}` 的 0.969 与 `{1,3}` 的 0.972，说明 32768 与预切分粒度是一起选定的。因此 32768 不是孤立常数，而是与模型深度、预切分规则、训练预算共同确定的。

没有分词器或词表不一致的后果是具体的：模型输入没有定义；`<|bos|>` 作为文档分隔符无法插入；SFT 的 assistant 侧掩码无从构造；bpb 的分母缺失，只能报告依赖词表大小的平均损失，跨词表不可比较；加载旧 checkpoint 时 `wte` 的行数与新 id 不对齐，越界 id 会直接触发索引错误或静默读到错误的嵌入行。

## 原理与推导

### 1 三种粒度的形式化

设文本的字节串为 $x=\mathrm{utf8}(s)$，长度 $B$。分词器把 $x$ 切成 $T$ 段 $x=p_{1}p_{2}\cdots p_{T}$，每段映射到 $\mathcal{V}$ 中一个 id。三种粒度的区别在于允许的切分单元：

- 字符级：$\mathcal{V}\supseteq\Sigma_{\text{char}}$，$\Sigma_{\text{char}}$ 为字符集，$T$ 等于 Unicode 码点数。若改为字节级但以 256 个字节为基础符号且不做合并，则 $T=B$。
- 词级：先用空白与标点切出词，$\mathcal{V}$ 为词表，$T$ 等于词数。词表外的词只能映射到 `[UNK]`，该字符串的原始信息在编码时丢失。
- 子词级：$\mathcal{V}=$ 基础符号集 $\cup$ 合并产物 $\cup$ 特殊 token，$T$ 由合并表与预切分规则共同决定，介于前两者之间。

三种粒度对中文的差异由 UTF-8 的编码长度放大。常用汉字占 3 字节，拉丁字母占 1 字节，具体长度由码点范围决定：

| 码点范围 | 字节数 | 典型内容 |
|---|---|---|
| U+0000–U+007F | 1 | ASCII 字母、数字、英文标点 |
| U+0080–U+07FF | 2 | 拉丁扩展字母、希腊字母、西里尔字母 |
| U+0800–U+FFFF | 3 | 汉字、假名、谚文 |
| U+10000–U+10FFFF | 4 | 表情符号、部分数学符号 |

以 GPT-2 的 byte-level 词表为例，汉语文本平均约 1.8 个 token 对应 1 个汉字（$\kappa\approx1.5$ 字节每 token），英文文本约 0.18 个 token 对应 1 个字符（$\kappa\approx5.5$ 字节每 token，99 字符的英文样例为 18 个 token）；改用 100K 词表后汉语降到约 1.2 token 每字（$\kappa\approx2.3$）。因此同样字数下中文的 token 数是英文的 5 至 10 倍，上下文窗口与按 token 计费的推理成本同比例变化。

词级分词的问题不在压缩率而在覆盖。开放词表的 $V$ 可达 $10^{6}$，嵌入参数 $Vd$ 在 $d=1536$ 时为 $1.5\times10^{9}$，超过 d24 主体参数的两倍；闭词表则把未登录词折叠为 `[UNK]`，专有名词、大小写变体、屈折形式全部失去区分。字符级分词没有 OOV，但英文文本的 $T$ 约为子词级的 4 至 6 倍（上段 99 字符的样例在字符级为 99 个 token，在 GPT-2 下为 18 个），注意力成本按 $T^{2}$ 增长，长上下文不可行。子词级是唯一同时控制 $V$ 与 $T$ 的方案，这是当代语言模型统一采用子词分词的原因。子词级是唯一同时控制 $V$ 与 $T$ 的方案，这是当代语言模型统一采用子词分词的原因。

纯字节方案可以看作子词级在合并次数为 0 时的特例：词表只有 256 个字节与特殊 token，$T=B$。对例 1 的样本 $T=218$，是 `cl100k_base` 的 2.66 倍，注意力成本为 $2.66^{2}=7.07$ 倍；2048 的上下文只容纳 2048 字节，约 682 个汉字。它对任意输入可编码且实现最简单，但序列长度与注意力开销使其不适合作为训练的主方案。nanochat 以字节为基础符号，再通过 32503 次合并把常见字节串折叠为单 token，目的是在保留「任意输入可编码」这一性质的同时把 $T$ 压到可用范围。

### 2 词表大小进入计算图的位置

设输入 id 为 $\mathbf{t}\in\{0,\dots,V-1\}^{T}$，词嵌入矩阵 $E\in\mathbb{R}^{V\times d}$，输出投影 $W_{\text{out}}\in\mathbb{R}^{V\times d}$。三处成本：

$$
\text{嵌入参数}=Vd,\qquad
\text{输出投影参数}=Vd,\qquad
\text{每 token 输出乘加}=Vd .
$$

nanochat 的 `GPT` 中 `self.transformer.wte = nn.Embedding(padded_vocab_size, config.n_embd)` 与 `self.lm_head = Linear(config.n_embd, padded_vocab_size, bias=False)`，二者不共享权重，所以参数合计 $2Vd$。logits 张量形状为 $(B,T,V)$，其显存为

$$
M_{\text{logits}}=B\cdot T\cdot V\cdot b
$$

其中 $b$ 为每个元素的字节数；bf16 下 $b=2$。代入 $B=16$、$T=2048$、$V=32768$：

$$
M_{\text{logits}}=16\times2048\times32768\times2=2\,147\,483\,648\ \text{字节}=2\ \text{GiB}.
$$

这一项与激活、KV Cache 并列，是限制 `--device-batch-size` 的三个主要因素之一。`nanochat/gpt.py` 在 `forward` 中对 `logits = self.lm_head(x)` 的注释写明 "very big tensor, large amount of memory"，并在下一行 `logits = logits[..., :self.config.vocab_size]` 切掉填充部分；切片只改变返回张量的形状，不改变前向时已分配的显存。

输出投影与注意力的相对量级可以用一个比值概括。每层注意力每 token 的乘加约为 $2Td$，输出投影每 token 为 $Vd$，因此

$$
R=\frac{Vd}{2LTd}=\frac{V}{2LT}.
$$

$V=32768$、$L=24$、$T=2048$ 时 $R=0.333$：输出投影约为单层注意力的三分之一，24 层注意力合计约为输出投影的 3 倍。若把词表扩到 100277，$R=1.02$，输出投影与单层注意力同量级；若 $T$ 缩到 512，$R$ 升为 1.33，词表成为更突出的开销。这解释了为何扩大词表必须同时考虑上下文长度与层数。

### 3 序列长度进入注意力与 KV Cache

对长度 $T$ 的序列，第 $l$ 层注意力打分为 $\mathbf{Q}\mathbf{K}^{\top}$，形状 $T\times T$，计算量约 $2T^{2}d_k$ 乘加；softmax 后再乘 $\mathbf{V}$ 为同量级。因此单层计算随 $T^{2}$ 增长。若把文本从子词级换成字符级，$T$ 变为约 3 至 4 倍，注意力计算变为 9 至 16 倍。

推理时的 KV Cache 随 $T$ 线性增长。d24 的配置为 $n_{\text{head}}=12$、$\text{head\_dim}=128$、$n_{\text{kv\_head}}=12$（GQA 中等于查询头数），每 token 需保存每层每头的 K 与 V：

$$
\text{KV}_{\text{token}}=2\cdot L\cdot n_{\text{kv\_head}}\cdot d_{\text{head}}\cdot b
=2\times24\times12\times128\times2=147\,456\ \text{字节}.
$$

2048 个 token 即 $147\,456\times2048=302\,055\,424$ 字节，约 288 MiB，与 batch 无关的这部分只是单序列开销。压缩率提高一倍意味着同一段文本的 $T$ 减半，KV Cache 与注意力计算同时减半，这是分词方案对推理成本的直接影响。

### 4 三个约束的联合权衡与评测的可比性

词表大小与序列长度不能独立优化。把 $V$ 从 32768 提到 100277：参数量增加 $2d(V'-V)=2\times1536\times67509\approx2.07\times10^{8}$，相对 d24 主体参数增加约 30%；作为回报，同一段中英混排文本的 token 数可能下降三成左右。是否划算要用同一个指标比较，即 bpb。

设每 token 平均交叉熵为 $\bar{\mathcal{L}}$ nat，则一段文本的总 nats 为 $\bar{\mathcal{L}}T$，bpb 定义为

$$
\text{bpb}=\frac{\bar{\mathcal{L}}T}{\ln 2\cdot B}=\frac{\bar{\mathcal{L}}}{\ln 2\cdot\kappa}.
$$

该式说明两件事：平均损失 $\bar{\mathcal{L}}$ 依赖词表大小（每 token 预测的候选数不同），因此不可跨分词器比较；除以 $\ln2\cdot\kappa$ 之后，指标回到「每个原始字节需要多少比特」，与 $V$ 无关。nanochat 的 `nanochat/loss_eval.py` 正是按此实现：累加 `total_nats` 与 `total_bytes`，最后返回 `total_nats / (math.log(2) * total_bytes)`，其中 `total_bytes` 由 `token_bytes[y]` 查表得到，特殊 token 的字节数被记为 0。

### 在 nanochat 中的落地

- 训练入口 `scripts/tok_train.py`：`--max-chars` 默认 $2\times10^{9}$，`--doc-cap` 默认 10000，`--vocab-size` 默认 32768。文本来自 `nanochat.dataset.parquets_iter_batched(split="train")`，每个文档超过 `doc_cap` 个字符即截断，累计字符数超过 `max_chars` 即停止。截断与采样上限共同决定词表学到的分布。
- 词表构造 `nanochat/tokenizer.py` 的 `RustBPETokenizer.train_from_iterator`：`vocab_size_no_special = vocab_size - len(SPECIAL_TOKENS)`，随后断言 `vocab_size_no_special >= 256`。这条断言的含义是：256 个单字节 token 必须全部在词表中，否则某些 UTF-8 字节序列无法编码。
- 模型侧 `nanochat/gpt.py`：`GPTConfig.sequence_len` 默认 2048，`vocab_size` 默认 32768；`GPT.__init__` 按 `pad_vocab_size_to=64` 把词表补齐，32768 本身是 64 的倍数，打印语句不会触发；`forward` 末尾把 logits 切回 `config.vocab_size`。
- 数据侧 `nanochat/dataloader.py`：`row_capacity = T + 1`，`tokenizer.encode(doc_batch, prepend=bos_token, num_threads=tokenizer_threads)`，因此每一行的第一个 token 是 BOS；best-fit 打包保证 100% 利用率，代价是约 34.6% 的 token 在裁剪中丢弃（T=2048 的 repo 实测口径）。
- 评测侧 `nanochat/loss_eval.py`：bpb 用字节数归一化，`token_bytes` 由 `scripts/tok_train.py` 末尾写出，路径为 `~/.cache/nanochat/tokenizer/token_bytes.pt`（`NANOCHAT_BASE_DIR` 可改）。

## 关键直觉

> [!tip] 分词是在两个预算之间做交换
> 分词器把「每个 token 需要预测多少信息」与「一段文本要占多少个位置」绑定在一起：压缩率 $\kappa$ 提高使同样的 $T$ 覆盖更多字节，但词表 $V$ 增大同时抬高 $2Vd$ 的参数与每 token $Vd$ 的输出投影成本。严格定义中的 $\kappa=B/T$ 描述前者，$2Vd$ 与 $Vd$ 描述后者；bpb $=\bar{\mathcal{L}}/(\ln2\cdot\kappa)$ 把两者折算到「每字节比特数」这同一单位，因此选词表的判据不是 token 数最少，而是在固定参数与计算预算下 bpb 或 CORE 最优。

## 例子与代码

### 例 1：同一段中英混排文本在四种切分下的 token 数

样本固定为下面这一行，便于逐项复核：

```text
nanochat 用 32768 个 token 的词表训练 GPT-2 级模型。Mixture of experts 与 self-attention 都有明确成本：上下文 2048 时，注意力成本按平方增长，而词表只影响嵌入与输出投影。
```

统计脚本如下。字符级按 Unicode 码点计数；词级按「字母串、数字串、连续汉字串、单个标点」切分；子词级用 `tiktoken` 的 `gpt2` 与 `cl100k_base` 两个编码实测，分别对应 50257 与 100277 的词表。

```python
import re, tiktoken

text = ("nanochat 用 32768 个 token 的词表训练 GPT-2 级模型。Mixture of experts 与 "
        "self-attention 都有明确成本：上下文 2048 时，注意力成本按平方增长，而词表只影响嵌入与输出投影。")
print("字符级", len(text))                      # Unicode 码点数
print("字节数", len(text.encode("utf-8")))       # UTF-8 字节数
word_pat = r"[A-Za-z]+|\d+|[\u4e00-\u9fff]+|[^\sA-Za-z\d\u4e00-\u9fff]"
print("词级", len(re.findall(word_pat, text)))  # 连续汉字串算一个词
for name in ["gpt2", "cl100k_base"]:
    enc = tiktoken.get_encoding(name)
    ids = enc.encode_ordinary(text)
    print(name, enc.n_vocab, len(ids), round(len(text.encode()) / len(ids), 2))
```

本机运行输出（`tiktoken` 0.14.0）：

```text
字符级 120
字节数 218
词级 28
gpt2 50257 135 1.61
cl100k_base 100277 82 2.66
```

汇总为下表。相对 token 数以 `cl100k_base` 为 1，压缩率 $\kappa=B/T$ 用同一 $B=218$ 计算。

| 粒度 | 切分单元 | $T$ | $\kappa$ | 相对 $T$ | 主要问题 |
|---|---|---|---|---|---|
| 字符级 | Unicode 码点 | 120 | 1.82 | 1.46 | 序列最长；字节级不合并时 $T=218$ |
| 词级 | 字母串、数字串、汉字串、标点 | 28 | 7.79 | 0.34 | $V$ 需覆盖全部词，OOV 无解 |
| 子词（GPT-2，50257） | byte-level BPE | 135 | 1.61 | 1.65 | 中文压缩率低，$T$ 反超字符级 |
| 子词（GPT-4，100277） | byte-level BPE | 82 | 2.66 | 1.00 | 词表大，$2Vd$ 参数高 |

这张表给出三个可检验的观察。第一，GPT-2 的词表以英文为主，中文汉字的字节序列大多未合并，因此中英混排文本在 GPT-2 下反而比字符级多 15 个 token；这说明「子词一定比字符级短」不成立，压缩率取决于训练语料与词表覆盖。第二，词级只有 28 个 token，$\kappa=7.79$，但它的 28 个条目里包含 10 个中文词，任何换一个说法或出现新专有名词就产生 OOV，而 $V$ 要覆盖开放词表则参数不可承受。第三，$V$ 从 50257 增到 100277 使 $T$ 下降 39%，代价是 `wte` 与 `lm_head` 各多 $7.7\times10^{7}$ 个参数。

### 例 2：d24 配置下的参数、logits 与 KV 核算

```python
V, d, L, T, B = 32768, 1536, 24, 2048, 16
head = V * d
print("wte 参数", head)
print("wte+lm_head", 2 * head, "相对 12Ld^2 的比例", round(2 * head / (12 * L * d * d), 3))
print("logits 显存 GiB", B * T * V * 2 / 2**30)
print("输出投影/单层注意力", round(V / (2 * L * T), 3))
kv = 2 * L * 12 * 128 * 2
print("每 token KV 字节", kv, "2048 token MiB", round(kv * T / 2**20, 1))
```

```text
wte 参数 50331648
wte+lm_head 100663296 相对 12Ld^2 的比例 0.148
logits 显存 GiB 2.0
输出投影/单层注意力 0.333
每 token KV 字节 147456 2048 token MiB 288.0
```

这五项分别对应一个工程约束。$2Vd=1.0\times10^{8}$ 是模型加载后常驻显存的一部分；2 GiB 的 logits 随 $B\cdot T$ 线性增长，是 `--device-batch-size=16` 时的主要激活开销；$R=0.333$ 说明在这个上下文长度下输出投影不是主导项，但 $T=512$ 时会升到 1.33；288 MiB 是单序列 2048 上下文的 KV 开销，乘以并发数即得推理显存下限。四项都可由行列数直接复算，无需运行模型。

### 例 3：训练入口与默认值核对

```bash
python -m scripts.tok_train --max-chars 2000000000 --doc-cap 10000 --vocab-size 32768
# 输出包含 max_chars / doc_cap / vocab_size 三个打印行、Training time，
# 以及 ~/.cache/nanochat/tokenizer 下的 tokenizer.pkl 与 token_bytes.pt
python -m scripts.tok_eval
# 输出 GPT-2、GPT-4、Ours 三种词表大小，以及 news/korean/code/math/science 等文本的
# bytes、tokens、ratio 对比表
```

`tok_eval.py` 对每段文本同时打印字节数、token 数与比值 `len(encoded_bytes) / len(encoded)`，并断言 `decode(encode(text)) == text`。该脚本的比较对象是 `gpt2`、`cl100k_base` 与 `ours`，因此它同时是词表压缩率的回归测试：重训 tokenizer 后若中文比值下降，应先检查 `SPLIT_PATTERN` 与训练语料是否被截断。

## 易错点

> [!warning] 以下六条均可在实现或核算中直接检验
> 1. 用平均损失比较不同词表的分词器。交叉熵按 token 归一，词表越大每 token 的候选越多、平均损失不可比；必须换 bpb $=\text{total\_nats}/(\ln2\cdot\text{total\_bytes})$。
> 2. 把 32768 当作 BPE 合并次数。实际合并次数为 $32768-256-9=32503$，见 [[字节对编码BPE原理]] 的词表分解。
> 3. 用字符数估算 token 数。本样本每字符 1.82 字节，中文每字 3 字节；中文占比越高，按字符估算的偏差越大。
> 4. 认为 `--vocab-size` 可以随意改。`GPT.__init__` 会按 64 补齐并打印 `Padding vocab_size from ... to ...`，`forward` 再切回 `config.vocab_size`；若只改 tokenizer 而不重训模型，嵌入行数与 id 不匹配。
> 5. 认为字符级分词没有 OOV。字符级仍要求词表覆盖全部字符，新增字符即 OOV；只有以 256 个字节为基础符号的字节级方案对任意输入都可编码。
> 6. 忽略 `tok_train.py` 的 `--doc-cap 10000`。词表在截断后的文档上训练，长文档尾部的模式覆盖不足，压缩率与 bpb 会同时偏高。

## 关联笔记

- 后续 [[字节对编码BPE原理]]：本篇说明为什么需要子词级，后者给出从字节序列到合并表的具体训练与推理算法。
- 后续 [[词表与特殊token]]：$V=32768$ 中 256 个字节、32503 个合并 token 与 9 个特殊 token 的分段与 id 分配。
- 后续 [[数据加载器dataloader]]：`prepend=bos` 与 best-fit 打包如何把本篇的 $T$ 与裁剪率落到训练行上。
- 跨库 [[Tokenizer与BPE]]：通用 BPE、WordPiece、Unigram 的完整教程；本篇只写 nanochat 的取值与工程后果。
- 对照 [[对比GPT-2核心指标]]：bpb 与 CORE 两个指标如何共同约束词表与训练 token 数的选择。

## 达标检测

- [ ] 写出字符级、词级、子词级三种粒度的形式化定义，并说明每一种的 $T$ 由什么决定。
- [ ] 对例 1 的样本独立复算字符数、字节数、词数与 `cl100k_base` 的 token 数，误差不超过 0。
- [ ] 推导 $\text{bpb}=\bar{\mathcal{L}}/(\ln2\cdot\kappa)$，并解释为什么平均损失不可跨词表比较。
- [ ] 计算 $V=32768$、$d=1536$ 时的 $2Vd$、$R=V/(2LT)$（$T=2048$）与 logits 显存（$B=16$），三项均与例 2 一致。
- [ ] 解释 `vocab_size_no_special >= 256` 这条断言为什么必须存在，去掉后哪类输入无法编码。
- [ ] 指出「GPT-2 词表下中英混排 token 数多于字符级」的原因，并说明这对多语言语料配比的影响。
- [ ] 说明纯字节方案（$T=B$）与字符级方案在可编码性与序列长度上的差别，并解释 nanochat 为什么保留字节作为基础符号。
- [ ] 给定一次要把 `--vocab-size` 改为 40960 的改动，列出必须同步重训或修改的产物。

## 参考来源

- Sennrich et al., "Neural Machine Translation of Rare Words with Subword Units", arXiv:1508.07909 —— 对应本篇第 1 节子词粒度的来源与第 4 节压缩率权衡。
- Radford et al., "Language Models are Unsupervised Multitask Learners", 2019 —— 对应字节级 BPE 与 50257 词表的构成，例 1 的 `gpt2` 行。
- OpenAI, *tiktoken* 仓库（`tiktoken_ext/openai_public.py`、README 中 GPT-4 分词器说明）—— 对应 `cl100k_base` 的 100277 词表与例 1 的实测计数。
- Karpathy, *nanochat* 仓库（commit 92d63d4）：`nanochat/tokenizer.py`、`scripts/tok_train.py`、`nanochat/gpt.py`、`nanochat/loss_eval.py` —— 对应本篇「在 nanochat 中的落地」全部代码位置与默认值。
- Karpathy, *nanochat* `dev/LOG.md`，2026-01-13「Number Token Split Pattern」条 —— 对应第 4 节 32K 词表下预切分粒度的 bpb 对比。
