用 Qwen2.5-0.5B-Instruct 认识 decoder-only Transformer
用 Qwen2.5-0.5B-Instruct 认识 decoder-only Transformer
0. 先约定几个词
本文只用一条请求、4 个输入 token 举例,生成 3 个新 token。换成 8 个 token,就把下面所有的 4 换成 8。
| 词 | 意思 |
|---|---|
| token | 文本切分后的整数编号;不一定等于一个字或一个词 |
| forward | 把一批 token 送进模型,完整算一遍 |
| prefill | 第一次把整段输入一起算 |
| decode | 之后每次只算 1 个新 token |
| KV cache | 请求期间保存在显存里的历史 K/V |
| logits | 模型最后输出的候选分数,不是概率 |
| sampler | 从 logits 里选出下一个 token 的步骤 |
本文给几个矩阵起名字,第一次出现时解释,后面不换符号:
- 词表矩阵叫 \(E\);
- 输入矩阵叫 \(X\);
- 归一化后的临时副本叫 \(H\);
- 查询矩阵叫 \(Q\),键矩阵叫 \(K\),内容矩阵叫 \(V\);
- 生产它们的权重矩阵分别叫 \(W_Q\)、\(W_K\)、\(W_V\);
- attention 输出投影的权重叫 \(W_O\)。
1. 输入:从 token 编号到矩阵 \(X\)
模型有一张词表,记作 \(E\)。\(E\) 是一张 \(151936\) 行 \(\times 896\) 列的表:
- \(151936\) 行:词表里每个 token 一行;
- \(896\) 列:每个 token 用 \(896\) 个数表示。
一个 token 编号就是行号。输入 4 个 token,就是取出 4 行,排成一个新矩阵,记作 \(X\):
| 矩阵 | 形状 | 含义 |
|---|---|---|
| \(E\) | \(151936 \times 896\) | 词表 |
| \(X\) | \(4 \times 896\) | 4 个 token,每个 896 个数 |
加上“几条请求”这一维,\(X\) 也可以写成 \([1, 4, 896]\):
- 1:1 条请求;
- 4:4 个 token;
- 896:每个 token 的向量长度。
token 编号只是地址,不代表语义顺序。896 个数是训练学出来的向量,单个维度通常没有人类可读的名字。
两条请求各 8 个 token 时,\(X\) 是 \([2, 8, 896]\),不是 \([2, 16, 896]\)。两条请求是两条独立序列,attention 不能跨请求互相看。
2. 第一层:先把 \(X\) 规范化成 \(H\)
进入第一层,先不直接拿 \(X\) 去算 Q/K/V,而是先做一次 RMSNorm,得到一个临时副本,记作 \(H\)。
RMSNorm 对 \(X\) 的每一行独立处理。每一行有 896 个数:
- 这 896 个数各自平方,求平均;
- 开根号,得到均方根;
- 每个数除以这个均方根;
- 每个位置再乘一个固定权重。
写成公式就是:
这里 \(X_i\) 是这一行的第 \(i\) 个数,\(w_i\) 是这一维的权重,\(\epsilon\) 是一个很小的数,防止除以 0。
例子:一行只有两个数 \([3, 4]\),平方平均是 \(12.5\),开根号约 \(3.5355\);权重都取 1 时,结果是 \([0.8485, 1.1314]\)。
关键点:
- \(H\) 还是 \(4 \times 896\),形状没变;
- 4 个 token 各算各的,不混合;
- \(H\) 只是临时副本,不是新的主干;
- 主干仍然是 \(X\),后面残差加回的是 \(X\),不是 \(H\)。
3. 从 \(H\) 得到 \(Q\)、\(K\)、\(V\)
现在手里是 \(H\),形状 \(4 \times 896\)。用三个不同的权重矩阵去乘它:
| 输出 | 权重矩阵 | 权重形状 | 输出形状 | 作用 |
|---|---|---|---|---|
| \(Q\) | \(W_Q\) | \(896 \times 896\) | \(4 \times 896\) | 当前 token 拿什么去查历史 K |
| \(K\) | \(W_K\) | \(128 \times 896\) | \(4 \times 128\) | 历史 token 拿什么被查 |
| \(V\) | \(W_V\) | \(128 \times 896\) | \(4 \times 128\) | 查到后取走的内容 |
用文字说:
- \(H\) 的每一行 896 个数,乘 \(W_Q\),得到 \(Q\) 的对应行,还是 896 个数;
- 同一行乘 \(W_K\),得到 \(K\) 的对应行,变成 128 个数;
- 同一行乘 \(W_V\),得到 \(V\) 的对应行,也是 128 个数。
所以:
- \(Q\) 是 4 行 \(\times\) 896 列;
- \(K\) 是 4 行 \(\times\) 128 列;
- \(V\) 是 4 行 \(\times\) 128 列。
要区分两个东西:
| 名字 | 是什么 |
|---|---|
| \(W_Q\) | \(896 \times 896\) 的权重矩阵,生产 Q 的机器 |
| \(Q\) | \(4 \times 896\) 的输出矩阵,机器产出的产品 |
同一层里,4 个 token 共用同一套 \(W_Q\)、\(W_K\)、\(W_V\),但每个 token 各自乘一次。
4. 拆头:\(Q\) 有 14 个头,\(K/V\) 有 2 个头
\(Q\) 的 896 列不是揉成一团用,而是切成 14 段,每段 64 列。每一段叫一个头。
- \(Q\):\(896 = 14 \times 64\),所以 14 个头,每头 64 个数;
- \(K\):\(128 = 2 \times 64\),所以 2 个头,每头 64 个数;
- \(V\):\(128 = 2 \times 64\),所以 2 个头,每头 64 个数。
“头”是同一个 token 的向量被切成的段,不是 14 个 token,也不是 14 个模型。
14 个 Q 头共享 2 个 KV 头:
| Q 头 | 使用哪个 KV 头 |
|---|---|
| 0–6 | KV 头 0 |
| 7–13 | KV 头 1 |
编号从 0 开始。头 6 用 \(Q\) 的第 384–447 个数,头 7 用第 448–511 个数;边界在 6 和 7 之间。
拆头后,如果只看一个头:
- 这个头的 \(Q\) 是 4 行 \(\times 64\) 列;
- 这个头的 \(K\) 是 4 行 \(\times 64\) 列;
- 这个头的 \(V\) 是 4 行 \(\times 64\) 列。
GQA 的收益:\(Q\) 保留 14 个头,查询角度多;\(K/V\) 只留 2 个头,缓存和带宽小。
5. RoPE:把位置写进 \(Q\) 和 \(K\)
\(Q\) 和 \(K\) 在拆头后、写入缓存前,会按 token 的位置做旋转;\(V\) 不旋转。
每个头有 64 个数,前后对半配成 32 对:
- 第 1 个配第 33 个;
- 第 2 个配第 34 个;
- ……
- 第 32 个配第 64 个。
对每一对 \((a, b)\),按位置对应的角度 \(\theta\) 做二维旋转:
位置不同,角度不同。这样 \(Q\) 和 \(K\) 做匹配时,结果会受相对位置影响,“上天”和“天上”才能被区分。
哪些数据旋转、哪些进缓存:
| 数据 | 做旋转 | 进缓存 |
|---|---|---|
| \(Q\) | 是 | 否 |
| \(K\) | 是 | 是 |
| \(V\) | 否 | 是 |
每个 token 都会重新算自己的 \(Q\);历史 \(Q\) 对后面的 token 没有用。后面的 token 需要历史 \(K\) 做匹配,历史 \(V\) 取内容。所以缓存里只有 \(K/V\),没有 \(Q\)。
6. Attention:打分、遮未来、softmax、加权 \(V\)
仍然只看一个头。设当前序列长度为 \(T\),每个头维度 \(d_k=64\)。
手里有:
- 这个头的 \(Q\):\(T \times 64\);
- 这个头对应的 \(K\):\(T \times 64\);
- 这个头对应的 \(V\):\(T \times 64\)。
第一步:打分
第 1 个 token 的 \(Q\) 那一行有 64 个数,第 1 个 token 的 \(K\) 那一行也有 64 个数。两行对应位置相乘再相加,得到一个数,叫点积。
这个数表示:第 1 个 token 的查询和第 1 个 token 的键有多匹配。
第 1 个 \(Q\) 分别和第 1、2、3、4 个 \(K\) 做点积,得到 4 个数;4 个 \(Q\) 都这样做,得到一张 \(4 \times 4\) 的分数表。
整张分数表可以写成:
这里 \(d_k=64\),所以 \(\sqrt{d_k}=8\)。先除以 8,是为了防止点积数值太大,softmax 后过于极端。
第二步:遮住未来
第 \(i\) 个 token 只能看位置 0 到 \(i\),不能看后面的 token。做法是给分数表加一个 mask 矩阵 \(M\):
| 看第 1 个 K | 看第 2 个 K | 看第 3 个 K | 看第 4 个 K | |
|---|---|---|---|---|
| 第 1 个 Q | 可见 | 遮住 | 遮住 | 遮住 |
| 第 2 个 Q | 可见 | 可见 | 遮住 | 遮住 |
| 第 3 个 Q | 可见 | 可见 | 可见 | 遮住 |
| 第 4 个 Q | 可见 | 可见 | 可见 | 可见 |
被遮住的格子加上 \(-\infty\),后面 softmax 会给它 0 权重。
第三步:softmax 成权重
对每一行的分数做 softmax:
结果 \(P\) 的每一行非负,且加起来等于 1;被遮住的位置权重为 0。
例子:一行可见分数是 \(0, 0\),取指数后是 \(1, 1\),权重是 \(0.5, 0.5\)。如果一行有 3 个可见位置且分数都是 0,每个权重是 \(1/3\)。
第四步:加权 \(V\)
这个头的输出是:
第 1 个 token 的输出展开就是:
每个 \(V\) 行是 64 个数,权重是一个数。结果还是 64 个数。它不是从 \(V\) 里挑一个,而是按权重混合。
4 个 token 都这样做,这个头得到 4 行 \(\times 64\) 列的输出。
第五步:拼头、投影、加残差
14 个头各自得到 \(4 \times 64\),沿列方向拼起来,得到 \(4 \times 896\)。
然后乘 \(W_O\)(\(896 \times 896\)),还是 \(4 \times 896\)。\(W_O\) 让 14 个头的信息互相混合。
最后加残差:
加的是这一层最开始的 \(X\),不是 \(H\)。
attention 读取缓存里的 \(K/V\),但不改写历史 \(K/V\)。
decode 时只有 1 个新 token,所以 \(Q\) 只有 1 行,分数表是 1 行 \(\times\) 历史长度列。
7. MLP:每个 token 自己加工
attention 结束后,对更新后的 \(X\) 再做一次 RMSNorm,得到新的临时副本,记作 \(H_{\text{mlp}}\)。
然后:
| 步骤 | 操作 | 形状 |
|---|---|---|
| 1 | \(H_{\text{mlp}}\) 乘 gate 权重,得到 \(G\) | \(4 \times 4864\) |
| 2 | \(H_{\text{mlp}}\) 乘 up 权重,得到 \(U\) | \(4 \times 4864\) |
| 3 | \(G\) 过 SiLU,再和 \(U\) 逐元素相乘 | \(4 \times 4864\) |
| 4 | 乘 down 权重,压回 896 | \(4 \times 896\) |
| 5 | 加回 \(X\) | \(4 \times 896\) |
写成公式就是:
其中 \(\odot\) 表示逐元素相乘,SiLU 是:
它提供非线性。gate 当缩放因子,控制 up 的每一维通过多少;两者逐元素相乘,再压回 896。
MLP 到底在做什么
attention 是横向交流:每个 token 读取其他 token 的 \(V\),把上下文混进自己的向量。
MLP 是纵向加工:它不再看别的 token,只处理当前 token 已经混合好的 896 维向量。
可以这样理解:
- attention 像开会,收集别人说的话;
- MLP 像回工位整理笔记:哪些信息放大,哪些压低,哪些组合成新特征;
- 整理完的结果加回原来的 \(X\),成为这个 token 更新后的表示。
矩阵上也能看出来:MLP 是对每一行独立乘权重,行与行之间没有相加,所以不跨 token;attention 是拿权重表去乘 \(V\),会把不同行的 \(V\) 混在一起,所以跨 token。
4864 只是临时工作区,用完压回 896,不会留在主干里。
MLP 的权重数量比 attention 大得多:
| 部分 | 每层权重数量 |
|---|---|
| MLP 的 gate、up、down | 约 1307 万 |
| attention 的 Q、K、V、O | 约 184 万 |
24 层放大后,MLP 约 3.14 亿,attention 约 0.44 亿,embedding 约 1.36 亿,合起来接近 5 亿。所以 MLP 是参数大头。
8. 24 层之后:输出分数
24 层重复同样的结构,每层输出仍然是 \(4 \times 896\)。
最后:
- 做一次 RMSNorm;
- 只取最后一行,得到 \(1 \times 896\);
- 乘词表矩阵的转置,得到 \(1 \times 151936\) 个分数;
- sampler 选分数最高的编号。
写成公式:
其中 \(h_{\text{last}}\) 是最后一行归一化后的向量,形状 \(1 \times 896\);\(E^T\) 形状 \(896 \times 151936\);所以 logits 是 \(1 \times 151936\)。
为什么只取最后一行:它对应“整段输入之后的下一个 token”;前面几行对应已经知道的 token,生成时不用。
词表矩阵 \(E\) 是 \(151936 \times 896\)。lm_head 和它共享同一份权重,所以不额外存一份 \(151936 \times 896\) 的矩阵。用法不同:查表是按编号取一行;lm_head 是拿 896 个数去乘 \(E\) 的转置,得到 151936 个分数。它不是“反向查表”。
模型输出的是 token 编号,tokenizer 再把它解码成文本。
9. prefill、decode 和 KV cache
| 阶段 | 输入 | 做什么 |
|---|---|---|
| prefill | 整段 4 个 token | 一次算完,建立各层 K/V 缓存,选出第 1 个新 token |
| decode | 只送 1 个新 token | 算它的 Q/K/V,追加 K/V,读历史缓存,选出下一个 token |
4 个输入、生成 3 个新 token:
- 3 次 forward;
- 1 次 prefill + 2 次 decode;
- 缓存有效长度 6;
- 容量 7。
容量是开头预留的位置数,等于输入长度 + 最大新生成数。有效长度是真正进过 forward、写进缓存的 token 数。最后一个输出不再回填缓存,所以有效长度比序列总数少 1。
KV cache 每个 token、每一层存:
| 数据 | 数量 |
|---|---|
| K | 2 个头 \(\times\) 64 维 = 128 个数 |
| V | 2 个头 \(\times\) 64 维 = 128 个数 |
| 合计 | 256 个数 |
FP16 下每个数 2 字节,所以每个 token、每层约:
24 层约 \(24 \times 512 = 12288\) 字节,即 12 KiB/token;4096 token 约 \(4096 \times 12\text{ KiB} = 48\text{ MiB}\)/请求。这只是 KV cache,不含模型权重和临时激活。
prefill 一次算很多 token,矩阵大,通常更受算力限制;decode 一次只算 1 个 token,却要读整份 KV 缓存,单请求、短 batch 下通常更受显存带宽限制。
10. 设计理由
| 组件 | 一句话理由 |
|---|---|
| RMSNorm | 稳定数值尺度;不减均值,比 LayerNorm 少一步 |
| RoPE | 让 Q/K 的匹配带相对位置 |
| 因果 mask | 不许看未来,训练和生成一致 |
| softmax | 把分数变成和为 1 的权重 |
| GQA | 少存 KV 头,省显存和带宽 |
| 残差 | 每层学“加什么修正”,保住原信息 |
| SwiGLU | 先扩宽再压回,给非线性特征更多空间 |
| KV cache | 历史不重算,省算力但占显存 |
11. 最容易混的几处
| 容易混 | 正确说法 |
|---|---|
| \(W_Q\) 和 \(Q\) | \(W_Q\) 是权重矩阵;\(Q\) 是 \(4 \times 896\) 的输出 |
| \(X\) 和 \(H\) | \(X\) 是主干;\(H\) 是临时归一化副本,残差不加 \(H\) |
| Q 进不进缓存 | Q 不缓存;K、V 进缓存 |
| “Q 和 K 写缓存前旋转” | Q、K 都旋转;只有 K、V 写缓存 |
| LayerNorm 和 RMSNorm | 这个模型用 RMSNorm,不减均值 |
| GELU 和 SiLU | 这个项目用 SiLU,不是 GELU |
| profile 和 prefill | 第一阶段叫 prefill,不是 profile |
| lm_head 反向查表 | 它是前向投影,输出 151936 个分数 |
| 头的编号 | 从 0 开始;Q 头 0–6 对 KV 0,7–13 对 KV 1 |
| MLP 跨 token | MLP 不跨 token;跨 token 的是 attention |
| 两条请求拼成一条 | 两条各 8 个 token 是 \([2, 8, 896]\),不是 \([2, 16, 896]\) |
12. 形状速查
| 手里是什么 | 形状 | 含义 |
|---|---|---|
| \(E\) | \(151936 \times 896\) | 词表矩阵 |
| \(X\) | \(4 \times 896\) | 4 个 token 的向量 |
| \(H\) | \(4 \times 896\) | 归一化副本 |
| \(Q\) | \(4 \times 896\) | 查询矩阵 |
| \(K\) | \(4 \times 128\) | 键矩阵 |
| \(V\) | \(4 \times 128\) | 内容矩阵 |
| 一个头的 Q | \(4 \times 64\) | 一个 Q 头 |
| 一个头的 K/V | \(4 \times 64\) | 一个 KV 头 |
| 分数表 | \(4 \times 4\) | 4 个 query 对 4 个 key |
| 拼头后的输出 | \(4 \times 896\) | 14 个头拼回 |
| gate / up | \(4 \times 4864\) | MLP 中间 |
| MLP 输出 | \(4 \times 896\) | 压回主干 |
| 最终分数 | \(1 \times 151936\) | 词表候选分数 |
13. 30 秒口述版
Qwen2.5-0.5B 是 decoder-only Transformer,24 层,隐藏维度 896,14 个 Q 头、2 个 KV 头,每头 64 维,MLP 中间宽度 4864。输入 token 先查词表变成 896 维向量;每层先 RMSNorm,投影出 Q/K/V,拆头后对 Q/K 做 RoPE,用 \(QK^T/\sqrt{64}\) 算分数,加因果 mask,softmax 得权重,加权 V,拼回 14 个头,乘 \(W_O\) 并加残差;再做一次 RMSNorm,进 SwiGLU MLP,896 展开到 4864,SiLU(gate) 乘 up,压回 896,加残差。24 层后取最后一个位置,lm_head 输出 151936 个分数,sampler 选下一个 token。生成分 prefill 和 decode;decode 只算新 token,历史 K/V 从缓存读。
14. 闭卷自测
| 问题 | 答案 |
|---|---|
| RoPE 作用于哪些数据? | Q 和 K;V 不旋转 |
| 为什么 Q 不缓存? | 每个新 token 重算自己的 Q;历史只需要 K/V |
| K 和 V 谁旋转? | K 旋转后缓存;V 不旋转,直接缓存 |
| softmax 前为什么要 mask? | 防止当前 token 看到未来,训练和生成一致 |
| GQA 省的是什么? | KV cache 的显存和读取带宽;Q 头仍保留 14 个 |
| MLP 跨 token 吗? | 不跨;它只处理每个 token 自己的 896 维向量 |
| 残差加的是 X 还是 H? | 加 X;H 只是临时归一化副本 |
| 为什么 lm_head 只取最后位置? | 它对应整段输入之后的下一个 token |
| prefill 和 decode 的区别? | prefill 一次算整段;decode 每次只算 1 个新 token,读历史 KV cache |
| 两条请求各 8 个 token 的形状? | \([2, 8, 896]\),两条独立序列 |

浙公网安备 33010602011771号