Alan
← All posts

LLM 复习笔记(1)

Alan#AI#基础

写在前面

这是 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列,才对呀。

这是因为我们在代码里不再使用纵向量

[x1x2x3]\begin{bmatrix} x_1 \\ x_2 \\ x_3 \end{bmatrix}

而是横着记: [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

注意到,点积的逻辑是“两个向量方向越接近/向量值越大,点积结果越大”,所以这里从结果看,就是两个词越相关越匹配/kik_i越重要,分数越高。这一步的分数显然会为后续作铺垫。

第 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. 保证权重非负、加和为 1。
  2. softmax 是【期望最大】&【熵最大】的折中最优。
  3. 它可导,也就能训练。有机会我们继续深入探索这个函数。

第 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 同时算,就是那个著名的公式:

Attention(Q,K,V)=softmax(QKTdk+M)V\text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} + M\right) V

形状:

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)。少一个就没法把"匹配什么"和"拿走什么"分开。

一个更深一点的视角:真正的功能单位是两个,不是三个。 回忆上一轮那个式子:

qi⋅kj=xi (WQWKT) xjTq_i \cdot k_j = x_i \,(W_Q W_K^T)\, x_j^T

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]

是两层线性变换夹着一个激活函数,常用 ReLU(z)=max⁡(0,z)\text{ReLU}(z) = \max(0, z)。

线性 (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.