用 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 个数各自平方,求平均;
  • 开根号,得到均方根;
  • 每个数除以这个均方根;
  • 每个位置再乘一个固定权重。

写成公式就是:

\[H_i = w_i \cdot \frac{X_i}{\sqrt{\frac{1}{896}\sum_{j=1}^{896} X_j^2 + \epsilon}} \]

这里 \(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 = H W_Q^T,\qquad K = H W_K^T,\qquad V = H W_V^T \]

输出 权重矩阵 权重形状 输出形状 作用
\(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\) 做二维旋转:

\[a' = a\cos\theta - b\sin\theta \]

\[b' = a\sin\theta + b\cos\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\) 的分数表。

整张分数表可以写成:

\[S = \frac{Q K^T}{\sqrt{d_k}} \]

这里 \(d_k=64\),所以 \(\sqrt{d_k}=8\)。先除以 8,是为了防止点积数值太大,softmax 后过于极端。

第二步:遮住未来

第 \(i\) 个 token 只能看位置 0 到 \(i\),不能看后面的 token。做法是给分数表加一个 mask 矩阵 \(M\):

\[M_{ij} = \begin{cases} 0, & j \le i \\ -\infty, & j > i \end{cases} \]

看第 1 个 K 看第 2 个 K 看第 3 个 K 看第 4 个 K
第 1 个 Q 可见 遮住 遮住 遮住
第 2 个 Q 可见 可见 遮住 遮住
第 3 个 Q 可见 可见 可见 遮住
第 4 个 Q 可见 可见 可见 可见

被遮住的格子加上 \(-\infty\),后面 softmax 会给它 0 权重。

第三步:softmax 成权重

对每一行的分数做 softmax:

\[P = \operatorname{softmax}(S + M) \]

结果 \(P\) 的每一行非负,且加起来等于 1;被遮住的位置权重为 0。

例子:一行可见分数是 \(0, 0\),取指数后是 \(1, 1\),权重是 \(0.5, 0.5\)。如果一行有 3 个可见位置且分数都是 0,每个权重是 \(1/3\)。

第四步:加权 \(V\)

这个头的输出是:

\[O = P V \]

第 1 个 token 的输出展开就是:

\[\text{权重}_1 \times V_{\text{第1行}} + \text{权重}_2 \times V_{\text{第2行}} + \dots \]

每个 \(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 = X + \operatorname{Concat}(O_0,\dots,O_{13}) W_O^T \]

加的是这一层最开始的 \(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\)

写成公式就是:

\[G = H_{\text{mlp}} W_{\text{gate}}^T \]

\[U = H_{\text{mlp}} W_{\text{up}}^T \]

\[Y = \big(\operatorname{SiLU}(G) \odot U\big) W_{\text{down}}^T \]

\[X = X + Y \]

其中 \(\odot\) 表示逐元素相乘,SiLU 是:

\[\operatorname{SiLU}(x) = x \cdot \frac{1}{1+e^{-x}} \]

它提供非线性。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 选分数最高的编号。

写成公式:

\[\text{logits} = h_{\text{last}} E^T \]

其中 \(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、每层约:

\[2 \times n_{\text{kv\_heads}} \times d_{\text{head}} \times 2 = 2 \times 2 \times 64 \times 2 = 512 \text{ 字节} \]

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]\),两条独立序列
posted @ 2026-10-29 13:11  _nibel  阅读(29)  评论(0)    收藏  举报