1. 子词 tokenizer 的基本动机#

直接按词切分会遇到很多问题：

• 词表会非常大。
• 新词、错别字、罕见词很难处理。
• 中文、日文等语言没有天然空格边界。
• 代码、数字、URL、emoji、符号混合文本很复杂。
• 多语言模型要在不同语言之间分配词表容量。

因此现代 LLM（Large Language Model，大语言模型）通常使用子词 tokenizer。它允许常见词整体成为 token，也允许罕见词拆成更小片段。

例如：

1
unhappiness -> un + happi + ness
2
大语言模型 -> 大 + 语言 + 模型
3
get_user_id -> get + _user + _id

实际切法取决于 tokenizer 算法、训练语料和词表大小。

2. BPE 合并规则#

BPE，全称 Byte Pair Encoding，是常见 tokenizer 算法之一。

它的核心流程是：

1
从字符或字节等最小单位开始
2
-> 统计语料中相邻片段的出现频率
3
-> 合并最高频的相邻片段
4
-> 把新片段加入词表
5
-> 记录这条 merge rule
6
-> 不断重复，直到达到目标词表大小

一个简化例子：

1
语料：
2
low
3
lower
4
lowest

初始拆成字符：

1
l o w
2
l o w e r
3
l o w e s t

统计相邻片段频率：

1
(l, o) 出现 3 次
2
(o, w) 出现 3 次
3
(w, e) 出现 2 次
4
...

先合并 (l, o)：

1
lo w
2
lo w e r
3
lo w e s t

再合并 (lo, w)：

1
low
2
low e r
3
low e s t

最后词表可能保留：

1
low
2
er
3
est
4
...

于是 lowest 可以被编码成：

1
low + est

BPE 学到的不是语义规则，而是基于频率的压缩规则。高频片段更容易成为一个 token，低频片段会被拆开。

3. Byte-level BPE#

GPT 系模型里常见 byte-level BPE。它从字节出发，而不是从 Unicode 字符出发。

优势是几乎任何文本都能编码，因为任意字符串最终都能表示成字节序列。这样可以减少 [UNK] 这类未知 token 的问题。

代价是某些语言、emoji 或特殊符号可能被拆得很碎，导致同样一段文本占用更多 token。

Byte-level BPE 还常常把空格编码进 token。英文模型中经常能看到类似"带前导空格的 token"，比如：

1
" hello"
2
" world"

这解释了一个现象：同一个单词出现在句首和句中，可能对应不同 token，因为句中单词前面带空格。

4. WordPiece 与 Unigram#

WordPiece

BERT 使用 WordPiece。它也会学习子词片段，但合并标准更接近"让语料似然提升更大"的片段，而不是单纯最高频相邻对。

常见表示：

1
playing -> play + ##ing

其中 ##ing 表示它是接在词内部的子词。

Unigram / SentencePiece

SentencePiece 常用 Unigram Language Model。它通常先构造一个较大的候选子词集合，再不断删除对语料 likelihood 影响较小的子词，最后保留目标词表大小。

SentencePiece 的重要特点是可以直接从原始文本训练，不强依赖空格分词，所以在中文、日文、多语言模型中很常见。它经常用 ▁ 表示空格边界，例如：

1
▁Transformer

5. 特殊 token#

tokenizer 训练或配置时还会加入特殊 token。常见特殊 token 包括：

1
<pad>
2
<unk>
3
<bos>
4
<eos>
5
<system>
6
<user>
7
<assistant>
8
<tool>

这些 token 不一定来自普通语料频率统计，而是人为加入，用来表达控制信息。

例如 chat model 会依赖 chat template，把结构化消息：

1
[
2
  {"role": "user", "content": "解释 DPO（Direct Preference Optimization）"},
3
  {"role": "assistant", "content": "DPO（Direct Preference Optimization）是..."}
4
]

渲染成带特殊 token 的文本序列。模型并不是天然理解 role=user 这种 JSON 字段，而是学习特殊 token 序列对应的对话模式。

6. 词表大小与多语言取舍#

vocab_size 是 tokenizer 设计里的关键超参。

这里有点直觉上的变扭，我们思考一下，如果词表小，很可能只收录了"我 / 喜 / 欢 / T / r / a / n / s / f / o / r / m / e / r"，这样"我喜欢 Transformer"会被切的很碎；反过来如果词表很大的话，可能收录了"我 / 喜欢 / Transformer"，而分词算法中是尽量用高频片段覆盖文本，很多算法会让常见长词变成一个token，所以这样会切的更大块。

多语言模型还要考虑词表公平性。如果英文词表质量很好，中文却经常被拆成单字甚至字节，那么中文文本会占更多 token，同样上下文长度能容纳的信息更少，训练和推理成本也更高。

7. Tokenizer 固定后的结构约束#

tokenizer 一旦确定，模型结构也会跟着确定：

1
vocab_size = tokenizer 词表大小
2
embedding matrix shape = [vocab_size, hidden_size]
3
LM Head output shape = [hidden_size, vocab_size]

如果预训练中途改变 tokenizer，使同一个字符串对应不同 id，原先学到的 embedding 行和输出头都会失去对应关系。

因此标准流程是：

1
先训练 tokenizer
2
-> 固定 vocabulary、merge rules、special tokens
3
-> 初始化 embedding 和 LM Head
4
-> 开始语言模型预训练

1. 文本规范化#

normalization 会把文本做统一处理，例如：

• Unicode 规范化。
• 全角半角处理。
• 多余空白处理。
• 大小写处理。
• 特殊控制字符处理。

不同 tokenizer 的规范化策略不同。BERT uncased 会转小写；很多 GPT 类模型会尽量保留原始大小写和空格，因为生成任务需要还原文本形式。

2. 初步切分#

pre-tokenization 会先按照空格、标点、字节边界或其他规则进行粗切分。

例如：

1
我喜欢 Transformer。

可能先形成：

1
我喜欢
2
Transformer
3
。

然后再进入子词切分。

3. 子词切分#

以 BPE 为例，编码时会按照训练阶段记录的 merge rank，把字符或字节逐步合并成词表中的 token。

假设词表里有：

1
喜欢
2
Transform
3
er
4
 Transformer
5
。

那么：

1
我喜欢 Transformer。

可能被切成：

1
["我", "喜欢", " Transformer", "。"]

也可能被切成：

1
["我", "喜欢", " Transform", "er", "。"]

切法取决于 tokenizer 的词表和 merge rules。

4. token 到 id#

切好的 token 会映射成整数 id：

1
["我", "喜欢", " Transformer", "。"]
2
-> [37046, 106632, 44535, 1773]

这里的 id 只是示意。不同模型的 tokenizer 不同，同一个 token 的 id 也不同。

这些整数 id 不能直接当连续数值使用。106632 不代表比 37046 语义更大，它只是词表中的编号。

5. special tokens 和序列边界#

训练样本还可能加入 <bos>、<eos> 等特殊 token：

1
<bos> 我 喜欢 Transformer 。 <eos>

对 chat model，则会加入 system/user/assistant 相关特殊 token。SFT（Supervised Fine-Tuning）阶段尤其依赖这一点。

预训练阶段是否加入特殊 token，取决于模型设计和数据拼接方式。很多训练会把长文本拼接成固定长度 block，并用 eos 标记文档边界。

6. 解码过程#

tokenizer 也负责把模型生成的 token ids 转回字符串：

1
[37046, 106632, 44535, 1773]
2
-> ["我", "喜欢", " Transformer", "。"]
3
-> "我喜欢 Transformer。"

这一步叫 decoding。生成式模型最终输出人类可读文本，就是不断预测 token id，再由 tokenizer 解码成字符串。

1. 模型结构实例：一个 tiny Llama#

为了把上面的概念落到真实文件上，可以看一个本地下载的小模型：

1
/home/ubuntu/owen/models/tiny-random-llama

这个模型来自 hf-internal-testing/tiny-random-LlamaForCausalLM。它是 LlamaForCausalLM 架构的极小随机模型，适合用来观察模型文件结构和权重命名；但它不是经过充分训练的可用聊天模型，所以不要用它的生成效果判断 Llama 系模型能力。

下载后的目录大致包括：

它的 config.json 里有这些关键结构参数：

由这些配置可以还原出这个模型的主干形状：

1
token ids
2
-> model.embed_tokens: [vocab_size, hidden_size] = [32000, 16]
3
-> 第 0 层 LlamaDecoderLayer
4
   -> input RMSNorm
5
   -> self-attention: q_proj / k_proj / v_proj / o_proj
6
   -> post-attention RMSNorm
7
   -> MLP: gate_proj / up_proj / down_proj
8
-> 第 1 层 LlamaDecoderLayer
9
   -> input RMSNorm
10
   -> self-attention: q_proj / k_proj / v_proj / o_proj
11
   -> post-attention RMSNorm
12
   -> MLP: gate_proj / up_proj / down_proj
13
-> final RMSNorm
14
-> lm_head.weight: [vocab_size, hidden_size]，把 hidden state 映射成词表 logits

model.safetensors 里保存的张量名可以直接对应到这些模块：

第 1 层也有同样一套 self_attn、mlp 和 layernorm 权重，只是名字从 model.layers.0... 变成 model.layers.1...。

这个例子可以很好地说明一个容易混淆的点：下载下来的模型文件里保存的是 q_proj.weight / k_proj.weight / v_proj.weight 这些投影矩阵，也就是 W_Q/W_K/W_V；而不是某次输入文本算出来的 Q/K/V。当输入一句话时，模型会临时计算：

1
Q = X W_Q
2
K = X W_K
3
V = X W_V

这里的 Q/K/V 是 forward 过程中的激活值，会随输入变化；W_Q/W_K/W_V 才是训练后保存在 model.safetensors 里的参数。

真实大模型的 hidden size、层数、参数量会大很多，权重文件也可能被切成多个 shard，例如 model-00001-of-000xx.safetensors。但整体结构关系是类似的：config.json 描述模型骨架，tokenizer.* 负责字符串和 token id 的互转，model.safetensors 保存 Transformer、embedding 和 LM Head 的权重。

1. 正余弦位置编码#

你之前学到的"用正弦值、余弦值表示位置"，通常指原始 Transformer 论文里的 sinusoidal position encoding。

它的做法是：为每个位置 pos 生成一个和 hidden state 同维度的位置向量 PE(pos)。这里的 PE 是 Positional Encoding，也就是位置编码。然后把它加到 token embedding 上：

1
x_pos = token_embedding + position_encoding

如果 hidden size 是 d_model，位置向量的偶数维使用 sin，奇数维使用 cos：

1
PE(pos, 2i)     = sin(pos / 10000^(2i / d_model))
2
PE(pos, 2i + 1) = cos(pos / 10000^(2i / d_model))

这里的 pos 是 token 在序列中的位置，i 是维度索引。不同维度使用不同频率的正弦/余弦波：有些维度变化很快，用来区分相邻位置；有些维度变化很慢，用来表达更长距离的位置关系。

一个非常简化的例子：

1
第 0 个位置的位置向量: [sin(0), cos(0), sin(0), cos(0), ...]
2
第 1 个位置的位置向量: [sin(a), cos(a), sin(b), cos(b), ...]
3
第 2 个位置的位置向量: [sin(2a), cos(2a), sin(2b), cos(2b), ...]

这样一来，即使两个 token 的内容完全相同，只要它们出现在不同位置，进入 Transformer 的向量也不同：

1
第 1 个位置的“我” = embedding("我") + PE(1)
2
第 5 个位置的“我” = embedding("我") + PE(5)

正余弦位置编码不是训练出来的参数，而是固定公式生成的。它的一个优点是理论上可以生成比训练长度更长的位置编码；但实际模型能不能稳定处理更长上下文，还取决于注意力、训练数据和外推能力，不能只看公式。

2. Learned positional embedding#

GPT-2 使用的是 learned positional embedding。它和 token embedding 很像，也是一个可训练查表矩阵：

1
position_id -> position_embedding

比如第 0 个位置查一行，第 1 个位置查另一行，然后加到 token embedding 上。它的特点是简单直接，但最大位置通常在训练时就固定好了。没有额外处理时，超过最大长度的位置没有对应的 learned embedding。

3. RoPE 旋转位置编码#

LLaMA、Qwen、DeepSeek 等很多现代 decoder-only LLM 更常用 RoPE。RoPE 不再把位置向量直接加到 token embedding 上，而是在 attention 里面对 Q 和 K 做和位置相关的旋转：

1
Q_pos = rotate(Q, pos)
2
K_pos = rotate(K, pos)

注意这里旋转的是每一层、每一个 attention head 里的 Q 和 K，不是原始 token embedding。假设某一层的某个 head 里：

1
Q: [seq_len, head_dim]
2
K: [seq_len, head_dim]
3
V: [seq_len, head_dim]

RoPE 会根据每个 token 的位置 pos，对这个位置上的 Q[pos] 和 K[pos] 做旋转。V 通常不旋转，因为位置主要是用来影响 attention score，也就是 Q 和 K 的相似度。

具体计算时，RoPE 会把向量的维度两两分组。比如 head_dim = 8，就把一个 head 内的向量分成 4 组：

1
(x0, x1), (x2, x3), (x4, x5), (x6, x7)

每一组都可以看成二维平面上的一个点。RoPE 根据当前位置 pos，把这个二维点旋转一个角度：

1
x'0 = x0 * cos(angle) - x1 * sin(angle)
2
x'1 = x0 * sin(angle) + x1 * cos(angle)

对第 i 组维度来说，角度通常是：

1
theta_i = 1 / base^(2i / head_dim)
2
angle_i = pos * theta_i

常见的 base 是 10000，不同模型和长上下文扩展方案可能会调整这个值或加入 scaling。可以看到，RoPE 和原始正余弦位置编码一样，也用到了 sin 和 cos，只是它不是把正余弦向量加到 embedding 上，而是用正余弦值去旋转 Q/K。

更完整地写，第 i 组二维坐标的旋转是：

1
x'_(2i)     = x_(2i)     * cos(pos * theta_i) - x_(2i + 1) * sin(pos * theta_i)
2
x'_(2i + 1) = x_(2i)     * sin(pos * theta_i) + x_(2i + 1) * cos(pos * theta_i)

举一个很小的例子。假设某个 head 的 head_dim = 4，某个 token 在位置 pos = 3，它的 Q 向量是：

1
Q = [q0, q1, q2, q3]

它会被分成两组：

1
(q0, q1), (q2, q3)

如果 base = 10000：

1
theta_0 = 1 / 10000^(0 / 4) = 1
2
theta_1 = 1 / 10000^(2 / 4) = 1 / 100
3

4
angle_0 = pos * theta_0 = 3
5
angle_1 = pos * theta_1 = 0.03

所以第一组维度旋转得更快，第二组维度旋转得更慢。推广到更高维时，低维频率更高，高维频率更低，模型就能同时感知近距离和远距离的位置变化。

RoPE 最关键的性质是：两个位置分别旋转后，它们的点积会自然带上相对位置关系。用简化写法表示：

1
score(pos_m, pos_n) = rotate(Q_m, pos_m) · rotate(K_n, pos_n)

由于旋转矩阵有特殊性质，这个点积可以理解成和 pos_m - pos_n 有关。也就是说，attention 在计算"第 m 个 token 要不要关注第 n 个 token"时，不只是比较内容相似度，还能感知二者相隔多远。

这就是 RoPE 相比 learned positional embedding 很重要的一点：它不是单纯给每个绝对位置查一个向量，而是把相对距离揉进了 attention score 的计算里。对于 decoder-only LLM 来说，这种方式和 causal self-attention 很契合，因此成为现代开源 LLM 的主流选择。

所以几种方式可以这样区分：

如果是 learned positional embedding，它也是训练参数；如果是 sinusoidal PE（sinusoidal positional encoding）、RoPE、ALiBi，它们通常不是通过反向传播学习出来的一张位置表，而是按照固定规则把位置信息注入模型。

1. Causal self-attention#

causal mask 保证第 t 个位置只能看见：

1
1, 2, ..., t

不能看未来 token。否则 next token prediction 会变成作弊。

注意力层内部会计算 Q/K/V，也就是 Query、Key、Value：

1
Q = X W_Q  # Query
2
K = X W_K  # Key
3
V = X W_V  # Value

这里要区分"中间结果"和"模型参数"：

• Q/K/V 是某次输入 X 经过线性变换后算出来的中间激活值。
• W_Q/W_K/W_V 才是模型保存和训练的参数矩阵。

也就是说，模型不是提前存好一份固定的 Q/K/V。每次输入不同，算出来的 Q/K/V 都会不同；但用于计算它们的 W_Q/W_K/W_V 是模型权重，会在训练中被反向传播更新。

然后用 Query 和 Key 的相似度决定每个位置关注哪些历史 token，再把对应 Value 加权求和。

2. Decoder-only 和 Encoder-Decoder 的 Q/K/V（Query/Key/Value）区别#

如果学习的是原始 Transformer 或机器翻译模型，常见结构是 encoder-decoder：

1
源句子 -> Encoder -> encoder hidden states
2
已生成的目标前缀 -> Decoder -> 下一个 token 的 hidden state

在 decoder 的 cross-attention 里，Query 来自 decoder 当前状态，Key / Value 来自 encoder 输出：

1
Q = decoder hidden states
2
K = encoder hidden states
3
V = encoder hidden states

所以可以说：encoder 把源句子编码成一组 Key / Value，decoder 拿自己的 Query 去检索这些信息。

但 GPT、LLaMA、Qwen 这类 decoder-only 语言模型没有单独的 encoder。它们的 self-attention 里，Query、Key、Value 都来自同一段前文 hidden states：

1
Q = X W_Q
2
K = X W_K
3
V = X W_V

生成时，模型会一步一步追加 token。每一步都会用当前前缀算出最后位置的 hidden state，再通过 LM Head（Language Modeling Head）映射成词表 logits，选出下一个 token。

所以这两个理解可以并存：

3. FFN（Feed-Forward Network，也常叫 MLP）#

FFN（Feed-Forward Network）就是原始 Transformer 论文图里的 Feed Forward 模块。现代 LLM（Large Language Model）的代码实现里，经常把这一块命名为 MLP（Multi-Layer Perceptron）。所以这里不是两个不同模块，而是同一类结构的两种叫法。

它负责在每个位置上做非线性特征变换。Attention 负责从上下文取信息，FFN / MLP 负责把取到的信息进一步加工。很多现代 LLM 的 FFN 中间维度比 hidden size 大很多，模型大量参数其实都在这一块里。

4. Residual 和 Norm#

残差连接让梯度更容易传播，LayerNorm（Layer Normalization）/ RMSNorm（Root Mean Square Layer Normalization）让数值分布更稳定。没有这些结构，几十层甚至上百层 Transformer 很难稳定训练。