Agent 全栈实战

1.9 Transformer 与 Attention:模型怎么“看见”前文#

前面八节,咱们一直在用模型,但还没拆开它最核心的那个零件。

这一节拆。

先问一个问题。

“订单 A1024 退款金额 3000 元,超过 2000 元,需要人工审核。”

这句话里,“人工审核”这四个字,为什么能跟“3000”“超过”“2000”对上?

模型读到最后四个字的时候,它怎么知道前面哪几个词重要?

答案就是 Attention(注意力)。

先看一个能跑的最小实现#

代码在:

text
Node/第一章/09-transformer-attention-demo/attention-demo.js

零依赖,直接跑:

bash
node attention-demo.js

输出:

text
Attention Head:金额审核关系头
目标 Token:人工审核
Query: [ '0.50', '0.50', '1.00', '1.00', '0.00' ]

注意力权重 Top 6:
人工审核: 18.97%
需要: 15.17%
超过: 10.61%
退款金额: 8.48%
3000: 8.48%
2000: 8.48%

加权汇总 Value 后,得到的新表示:
[ '0.329', '0.245', '0.448', '0.341', '0.000' ]

这 10 个 Token 是写死的(attention-demo.js:2-13):

js
const tokens = [
	'订单', 'A1024', '退款金额', '3000', '元',
	'超过', '2000', '元', '需要', '人工审核'
]

每个 Token 有一个 5 维向量(attention-demo.js:17-27),最后一维表示“是不是订单号”之类:

js
const features = {
	订单: [0, 0, 0, 0, 1],
	退款金额: [1, 0, 0, 0, 0],
	3000: [1, 0, 0, 0, 0],
	超过: [0, 0, 1, 0, 0],
	2000: [0, 1, 0, 0, 0],
	需要: [0, 0, 1, 1, 0],
	人工审核: [0.5, 0.5, 1, 1, 0]
}

真实模型里的向量是训练出来的,这里是手写的,只为演示。

Q、K、V:三个角色#

Attention 里,每个 Token 会生成三个向量:

  • Query(Q):我在找什么?
  • Key(K):我有什么标签?
  • Value(V):我实际携带什么信息?

打个比方。

你去图书馆找书。

  • 你脑子里的需求是 Q:“我想找一本讲退款规则的书”;
  • 书脊上的分类标签是 K:“法律 / 电商 / 售后”;
  • 书里的内容是 V。

你拿 Q 去和每本书的 K 比对,越匹配,越值得翻开。最后你把几本书的内容按匹配度加权汇总——这就是 Attention 的输出。

代码里用三组权重模拟(attention-demo.js:31-36):

js
const head = {
	name: '金额审核关系头',
	queryWeights: [1, 1, 1, 1, 0],
	keyWeights: [1, 1, 1, 0.8, 0],
	valueWeights: [1, 1, 1, 1, 0]
}

投影就是逐元素相乘(attention-demo.js:39-41):

js
function project(vector, weights) {
	return vector.map((value, index) => value * weights[index])
}

四步算完一次 Attention#

runAttention 在 attention-demo.js:71-103,四步。

第一步:当前 Token 生成 Q,前文生成 K 和 V。

js
const visibleTokens = tokens.slice(0, targetIndex + 1)
const query = project(features[targetToken], head.queryWeights)
const keys = visibleTokens.map((token) => project(features[token], head.keyWeights))
const values = visibleTokens.map((token) => project(features[token], head.valueWeights))

注意 slice(0, targetIndex + 1)——只能看自己和前面。

这就是“因果掩码”(causal mask)。

为什么?因为生成是自回归的:预测第 10 个 Token 时,第 11 个还不存在。模型不能偷看未来。

第二步:Q 和每个 K 点积,算相关性。

js
const scores = keys.map((key) => dot(query, key) / Math.sqrt(query.length))

点积越大,方向越接近,相关性越高。

除以 sqrt(维度) 是为了防止数值过大。维度一高,点积容易爆,Softmax 会变成“几乎全给一个”。

第三步:Softmax 变成权重。

js
const weights = softmax(scores)

scores 是任意实数,weights 是加起来等于 1 的概率分布。

第四步:按权重汇总 V。

js
const newRepresentation = weightedSum(values, weights)

“人工审核”的新表示 [0.329, 0.245, 0.448, 0.341, 0.000],就是前文所有 Value 的加权平均。

它不再是“人工审核”四个字本身,而是“人工审核 + 它关注到的金额、阈值、比较关系”的混合体。

这就是上下文信息被“吸收”进来的过程。

为什么权重最高的是自己#

看输出:人工审核 自己 18.97%,排第一。

正常吗?正常。

因为它的向量 [0.5,0.5,1,1,0] 和 Q 最接近,点积自然大。

但更有意思的是后面几个:

  • 需要 15.17%——语法上直接修饰;
  • 超过 10.61%——比较关系;
  • 退款金额、3000、2000 各 8.48%——金额和阈值。

这个 Head 学到的,就是“审核结论要看金额和比较”。

真实模型有几十个 Head,每个关注不同的关系:有的管指代,有的管时态,有的管数字比较。

Multi-Head:为什么要多个头#

一个头只能学一种关系。

“人工审核”既要知道金额,也要知道是谁的订单,还要知道是退款还是换货。

一个头装不下,就用多个头并行,最后拼接。

text
头 1:金额关系
头 2:订单归属
头 3:动作类型
...
拼接 → 线性层 → 输出

每个头的 Q/K/V 权重不同,所以看到的东西不同。

一层 Transformer 还有什么#

Attention 只是其中一块。完整的一层通常是:

text
输入
 → Multi-Head Attention
 → 残差连接 + LayerNorm
 → Feed Forward(两层线性 + 激活)
 → 残差连接 + LayerNorm
 → 输出

还有位置编码:Attention 本身不知道谁在前谁在后,得把位置信息加进向量里。

这些细节不用背,但要记住一件事:

Attention 负责“看哪”,Feed Forward 负责“想什么”。

一个工程上的后果:长上下文为什么贵#

Attention 要算“每个 Token 和其他所有 Token”的相关性。

序列长度 n,计算量大致是 O(n²)。

上下文从 8K 涨到 128K,长度 16 倍,Attention 计算量约 256 倍。

这就是为什么:

  • 长上下文按更高档位计费;
  • 首字延迟随输入变长明显上升;
  • KV Cache 能省重复计算,但省不了显存。

也是为什么上一节讲 Context Budget:不是能塞多少就塞多少。

几个容易误解的点#

PS 1:注意力权重不是“解释”。

权重高不代表因果重要。很多 Head 的权重看起来很平均,但模型照样工作。别拿一张注意力热力图就当模型解释。

PS 2:这个 demo 没有训练。

Q/K/V 权重是手写的,所以结果“刚好合理”。真实模型的权重是梯度下降学出来的,没人手动指定“这个头管金额”。

PS 3:Transformer 不是唯一架构。

现在主流大模型基本都是 Transformer 变体(Decoder-only),但 Mamba、RWKV 这类状态空间模型也在发展。面试时说“主流是 Transformer”就够了,别说“所有模型都是”。

总结#

这一节咱们把 Attention 拆成了四步:

  • 当前 Token 出 Q,前文出 K 和 V;
  • Q·K 算相关性,除 sqrt(d) 防溢出;
  • Softmax 转权重;
  • 按权重汇总 V,得到融合了上下文的新表示。

再加三件事:因果掩码、多头、O(n²) 的代价。

到这儿,第一章的“原理部分”就讲完了。

下一节,咱们换个视角:这些知识,怎么写成简历上的一行字,以及面试官会怎么问。