LLM 复习笔记(1)
写在前面
这是 LLM 系列的第一篇,本文从一串文字进入模型开始,一路走到模型吐出下一个词,最后引出 KV cache。
你需要知道的:
- 线性代数基础:矩阵乘法、点积、转置
- 能读简单的 Python,知道
@是矩阵乘法 - 大致了解神经网络怎么训练:loss、梯度、反向传播。文中会提到训练,但不展开
- 不需要事先了解 Transformer
本篇包含:
- 文本 → token → 向量 → logits
- 一个层的骨架:注意力、FFN、残差
- 单头注意力的完整手算(5 步)
- 模型的最终输出 logits
- 推理的两个阶段:prefill 和 decode
- KV cache 大小的初步估算
本篇不包含(部分会在后续篇章补上):
- 多头注意力、GQA 等(下一篇)
- 位置编码(RoPE)
- 训练本身:反向传播推导、优化器、SFT / RL 的具体做法
- 采样策略(temperature、top-p 等)
- 工程实现:kernel、并行、显存管理
Let's start
发给 LLM 的一句话,即一个 prompt,比如 "I am a dog",会被视为一串 token。把一串自然语言,翻译成一串数字(token),是 tokenizer 做的事。这一步与模型无关,是纯粹的查字典。查出来的结果本质上就是对应单词的 ID。
"I love cats" → ["I", " love", " cats"] → [40, 3021, 19987]
第二步,我们才进入模型。模型收到的是一串整数 ID [40, 3021, 19987],模型会把每个 token 转换成向量。这一步由参数矩阵W_E完成。准确地说就是拿 token ID 当 key,取出参数矩阵中对应的值。
小例子:参数矩阵里有 5 个词,维度为 3(即每个词对应的向量维度为 3)。
W_E = [[ 0.1, -0.3, 0.5], # id 0
[ 0.7, 0.2, -0.1], # id 1
[-0.4, 0.9, 0.3], # id 2
[ 0.0, 0.1, 0.8], # id 3
[ 0.6, -0.5, 0.2]] # id 4
输入 ids = [2, 0]
输出 = [W_E[2], W_E[0]] # 形状 [2, 3]
Note: 参数矩阵形状记作 [vocab_size, d_model]。这里如果学过线代,会有很迷惑的事:词对应的向量怎么是横着写的?如果是纵向量,参数矩阵形状就应该是 [d_model, vocab_size]- 3行5列,才对呀。
这是因为我们在代码里不再使用纵向量
而是横着记: [x1, x2, x3]。这样一来直觉上更外部的东西,代码里就会在更外层。比如 W_E[2],就是 ID 为 2 的 token 对应的向量。如果我们用数学上的纵向量,岂不是找第二个 token 需要 W_E[][2](其实会是W_E[:, 2])?
总之,现在我们小例子也合理了。
输入 ids = [2, 0]
输出 = [W_E[2], W_E[0]] # 形状 [2, 3]
数学上算是一个 one-hot 矩阵,比如 ids = [2, 0] 时,就是一个
[[0, 0, 1, 0, 0]
[1, 0, 0, 0, 0]]
跟W_E乘一下就得到输出的 [2, 3] 矩阵,但实际上一堆 0 乘法是空耗算力,所以不这样做。实际代码:
emb = nn.Embedding(vocab_size, d_model) # 内部就是一个 weight 张量
x = emb(ids) # 等价于 emb.weight[ids]
接下来我们先整体 high-level 地看后续每层的行为。
最宏观地视角下,每层是这样的 2 行:
def layer(x):
x = x + attention(norm(x)) # 第一步
x = x + ffn(norm(x)) # 第二步
return x
重复每层:
for layer in layers: # 重复 N 次
x = layer(x) # 形状不变
x = final_norm(x)
注意到,无论是 attention() 还是 ffn(),都是不改变 x 形状的。x 初始是 x = W_E[ids] 这样来的,所以是 [seq, d_model](seq 是输入的 token 数量)。按上文例子,就还是 [2, 3]。norm() 这种细节目前先忽略。
注意力层 attention()
现在看注意力层 attention()。
其中行为可以总结为:每个 token 根据"和别人有多相关",从别人那里加权取一些信息过来。
为此,每个 token 的向量会被投影成三个不同的向量:
- Q(query):我想找什么
- K(key):我身上贴的标签,供别人匹配
- V(value):我真正能提供的内容
三者都是用矩阵乘出来的,W_Q、W_K、W_V 是这一层的可学习参数:
Q = X @ W_Q
K = X @ W_K
V = X @ W_V
拆成 5 步
输入(每行一个 token):
X = [[1, 0], # token 1
[0, 1], # token 2
[1, 1]] # token 3
权重(随便选的,方便算):
W_Q = [[1, 0], W_K = [[1, 0], W_V = [[1, 1],
[0, 1]] [0, 2]] [0, 2]]
第 1 步:算 Q、K、V
Q = [[1, 0], K = [[1, 0], V = [[1, 1],
[0, 1], [0, 2], [0, 2],
[1, 1]] [1, 2]] [1, 3]]
下面只跟着 token 3 走一遍。最后一行才是用来预测下一个 token 的那一行。 (这句这样理解:训练过程中我们是让模型对它看到的每个词预测下一个 token,然后看到 data set 里真的下一个 token,算 loss...后向传播...etc.,所以训练材料里一个 1000 词的文本,模型会预测 999 次;但推理过程中,prompt 不需要预测,所以只需要看着 prompt 的最后一个词(例子里就是 token 3,预测回答的开头即可。(这里还涉及一点训练里的问答内容格式问题,下文再补充)
第 2 步:打分。 用 token 3 的 q 和每个 token 的 k 做点积:
q3 · k1 = [1,1]·[1,0] = 1
q3 · k2 = [1,1]·[0,2] = 2
q3 · k3 = [1,1]·[1,2] = 3
注意到,点积的逻辑是“两个向量方向越接近/向量值越大,点积结果越大”,所以这里从结果看,就是两个词越相关越匹配/越重要,分数越高。这一步的分数显然会为后续作铺垫。
第 3 步:缩放。 除以 √d_k = √2 ≈ 1.414:
[0.707, 1.414, 2.121]
(缩放是为了防止维度大时点积数值过大,让 softmax 变得接近 one-hot,梯度消失。)
第 4 步:softmax,变成权重。
exp: [2.028, 4.113, 8.342],总和 14.483
权重: [0.140, 0.284, 0.576] # 加起来是 1
token 3 认为自己最相关(0.576),其次 token 2,token 1 最不相关。这里使用 softmax 是因为它有几个优良的特性:
- 保证权重非负、加和为 1。
- softmax 是【期望最大】&【熵最大】的折中最优。
- 它可导,也就能训练。有机会我们继续深入探索这个函数。
第 5 步:用权重对 V 加权平均。 准确地说,是对到 token 3 为止的所有词的 V 取均值,但是是用点积来的 token 3 视角里前面每个词的重要程度作为权重的。
out3 = 0.140 × [1, 1] + 0.284 × [0, 2] + 0.576 × [1, 3]
= [0.716, 2.436]
从信息的角度看,out3 是对前文信息的总结归纳,前文信息的形状是 V 的形状,我们归纳自然也保持形状不变。换个视角,也可以说是前文的信息通过这样的方式流到了 out3。
这就是 token 3 的注意力输出。之后还会再乘一个输出投影 W_O,然后通过残差加回 x:x3 = x3 + out3 @ W_O。
注意力的输出就是 V 的加权平均,权重由 Q 和 K 决定。 看第 5 步:输出完全是 v1、v2、v3 的线性组合,系数加起来为 1。而系数是怎么来的?第 2 到 4 步,只用到了 q 和 k。所以 Q 和 K 只负责"决定看谁",V 负责"看到之后拿走什么"。
最终公式
把 5 步压到一起,对所有 token 同时算,就是那个著名的公式:
形状:
Q [seq, d_k]
K^T [d_k, seq]
QK^T [seq, seq] ← 每个 token 对每个 token 的分数,就是上文的点积
V [seq, d_v]
输出 [seq, d_v]
注意中间那个 [seq, seq] 的分数矩阵:这就是注意力的计算量随序列长度平方增长的来源。
其他细节
训练与推理的材料
预训练的材料就是普通文本,什么都有。问答训练在后训练,材料长这样:
<|user|>什么是注意力?<|end|><|assistant|>注意力是一种……<|end|>
所以机制没有变化,只是文本格式特殊,带上了特殊标记,使得模型每次看到<|end|><|assistant|>都知道接下来该回答了。
见下文#Prefill - Decode。
因果掩码 M
语言模型训练时,token 不应该看到它后面的 token。做法是在 softmax 之前,把分数矩阵右上三角设成 −∞:
k1 k2 k3
q1 [ s11, -∞, -∞ ]
q2 [ s21, s22, -∞ ]
q3 [ s31, s32, s33 ]
exp(−∞) = 0,所以这些位置的权重为 0。token 1 只能看自己,token 2 看 1 和 2,token 3 看全部。刚才手算 token 3 恰好不受掩码影响。
为什么是"Q, K, V"?
我有过一个问题:我们目前的思路算是把一个词包含的信息分作 2 类:
- K(key):我身上贴的标签,供别人匹配
- V(value):我真正能提供的内容
为什么偏偏是 2 类,不是 3 类或者更多?
AI 的回答:
历史来源:这个划分来自"键值记忆"(key-value memory)的思路,就是数据库和哈希表的那种结构。2016 年左右的 Key-Value Memory Networks 明确把记忆分成"用来匹配的 key"和"用来返回的 value"。更早的 Bahdanau 注意力里,key 和 value 其实是同一个向量。Transformer 把它们拆开,并加上了 query。
为什么至少要这三个:做一次"按内容查找",逻辑上需要三种角色:发起查找的一方(Q),被匹配的标签(K),匹配上之后交出的内容(V)。少一个就没法把"匹配什么"和"拿走什么"分开。
一个更深一点的视角:真正的功能单位是两个,不是三个。 回忆上一轮那个式子:
W_Q 和 W_K 永远是乘在一起出现的,单独看哪一个都没意义,有意义的只是乘积 W_Q W_K^T,它决定"谁看谁"。同理,W_V 和 W_O 也永远乘在一起,W_V W_O 决定"看到之后把什么搬过来"。Anthropic 的 A Mathematical Framework for Transformer Circuits 把这两部分叫做 QK 电路和 OV 电路。所以注意力真正在做的是两件事:路由(QK)和搬运(OV)。拆成四个矩阵是一种参数化方式,好处是每个矩阵都是低秩的,省参数、省计算。
能不能更多? 有人试过。比如 2-simplicial attention 让每个 query 同时匹配两个 key,打分从点积(两个向量)变成三个向量的三线性形式,用来捕捉三个 token 之间的关系。这类方向有研究,但计算量大得多,目前没有成为主流。
最后要提醒一点:"K 像标签,V 像内容"是帮助理解的解释,不是设计规定。模型只是被训练去降低 loss,W_K 和 W_V 学到什么完全由数据决定,不一定能干净地对应到人类能命名的概念上。至于"这种划分是不是最优的",据我所知,没有人证明过。它是一个足够简单、计算上高效、并且实际效果很好的设计,然后一直沿用下来了。
FFN
x = x + ffn(norm(x))
现在回来继续看这部分。
FFN 是 Feed-Forward Network,前馈神经网络。这部分本质就是一个两层的 MLP (Multi-Layer Perceptron 多层感知机)
h = activation(x_i @ W_1) # [d_model] → [d_ff]
out = h @ W_2 # [d_ff] → [d_model]
是两层线性变换夹着一个激活函数,常用 。
线性 (W_1) → 激活函数 → 线性 (W_2)
这是最基础的神经网络。我现在其实已经不记得神经网络、非线性激活函数是怎么回事了...
我还能理解的一种解释是
有一种很流行的解读(Geva 等人 2021 年的论文 Transformer Feed-Forward Layers Are Key-Value Memories):FFN 也是一个键值记忆,只不过 key 和 value 是训练时学到、存在参数里的。注意力从当前上下文里查信息,FFN 从模型自己的"长期记忆"里查信息。这也和上一轮说的"参数大头在 FFN、事实知识可能存在 FFN 里"对得上。
这里 d_ff 通常是 d_model 的几倍,就是为了有足够多的"记忆槽"。
最终输出
def model(ids, cache=None): # Prefill 时 Cache 为空
x = W_E[ids] # [seq, d_model] 查表
for i, layer in enumerate(layers):
x = layer(x, cache[i]) # [seq, d_model] 形状不变
# 顺便把这批 token 的 K、V 追加进 cache[i]
x = final_norm(x) # [seq, d_model]
logits = x @ W_U # [seq, vocab_size]
return logits, cache
经过多层 attention() + ffn(),以及最后一层 ffn() 之后再 final_norm() 一下,我们这时得到:n_layer 层的 K、V,以及,每个 token 对下一个 token 的预测。这个预测的形状是 [seq, vocab_size]。每一行对应一个输入位置,是"这个位置之后下一个词是谁"的打分,词表里每个词一个分。这个矩阵叫 logits.
见下文
Prefill - Decode
# prefill:整个 prompt 一次前向,顺便把所有 token 的 K、V 存进 cache
logits, cache = model(prompt_ids)
next_id = sample(logits[-1]) # 只取最后一行
# decode:每次只喂一个新 token
while next_id != EOS:
output.append(next_id)
logits, cache = model([next_id], cache) # 只算这一个新 token 的 q, k, v
next_id = sample(logits[-1])
所谓“推理”,分 2 个阶段。模型收到 prompt 时先 prefill,得到一堆 KV Cache,和一个 logits 矩阵,而因为我们实际上只需要根据最后一个 token 预测下一个 token,所以只需要最后一行 logits[-1]。decode 阶段就是开始往外蹦词的阶段。
推理时是逐个 token 预测的,每生成一个 token,都把新 token 接到输入末尾,根据它预测下一个 token。所谓“自回归生成”是也。
KV Cache
有了上面的基础,我们可以推出一个模型推理时产生的 KV Cache 大小了。
一个 prompt 里:token 数 x d_model x 2 (K+V) x 层数 x 字节数
但这里又要引入下一个概念了:
多头
This post is licensed under CC BY-NC-SA 4.0. Please credit the source when sharing.