← PyTorch From First Principles

注意力:哪个位置在和哪个位置比?

从张量几何构建多头注意力,说清每个 query、key、head、位置轴,验证掩码、softmax、缩放与头往返,用从形状到行为干预的四层证据定位第一次语义失败。

这里有一批序列表示和把它拆成头的代码。

B, T, E, Nh = 1, 4, 8, 2
Dh = E // Nh                       # 4

x = torch.arange(B * T * E).reshape(B, T, E)
heads = x.reshape(B, Nh, T, Dh)
x: (1, 4, 8)
heads: (1, 2, 4, 4)

这正是多头注意力要的形状:batch、头、位置、头维。没抛。每个形状断言过。

现在同样拆分换种写法:

good = x.reshape(B, T, Nh, Dh).transpose(1, 2)
heads shape (1, 2, 4, 4)
good  shape (1, 2, 4, 4)
same shape           : True
same dtype           : True
same element multiset: True
same values          : False

两张量,形状相同,dtype 相同,装着同样 32 个数,不同一张量。同样注意力算子跑两遍,输出不同:

reshape 能改形状。它做不了你忘了表达的转置。

这就是本章,最小尺度陈述。注意力是一串被表示向量间的显式关系,几乎每阶段都能在产出恰好预测的形状的情况下错。

我们在哪

第 8 章用跑层前推导每个通道与空间变换、推导与观测对比,去掉 [B, C, H, W] 的最后 ambiguity。第 9 章去掉空间格,剩下:

[B, T, D]

B   how examples are grouped
T   positions within one example
D   coordinates describing the represented object at one position

第 9 章还 concrete 了一个算子。两 D 向量的点积是沿方向的分数,不自动是相似度、余弦或距离。末尾注意到 learned 方向 w 从不特殊:它是与 x 同一空间的向量,batch 里一向量与同样 batch 里另一向量打分没什么拦着。

[B, T, D] 每样本 T 个这种向量。每两两打分产出 T × T 数格,接下来发生什么就是本章回答的:

注意力把 [B, T, E] 变成两两比较时,每阶段每轴什么意思,关系第一次在哪不再是我们想要的意思?

注意这个问题不是什么。它不是“注意力是什么”。很多人背得出 Q、K、V、softmax、多头,还会在头轴装错值的模型上丢一天。有用的技能是打开没见过的注意力代码,说出每轴名字,说出每算子后什么该 true。

环境

本章每形状、数、异常、对比都来自跑出的代码,种子固定,PyTorch 2.13.0、Python 3.12.3、Linux CPU。

注意力 API 版本异常敏感,掩码约定同一 release 里函数间不同。这里关于 F.scaled_dot_product_attention 与 nn.MultiheadAttention 的每个断言都对着装的版本文档查过再跑过。

先说名字

第 8 章 H 指图像高,Transformer 文献 H 指头数。这个 collision 在算 transpose 动了哪轴时真伤人,本章全程用显式名字:

B    batch, or any leading grouping axis
Tq   query positions
Tk   key / value positions
E    model dimension, the size of one position's representation
Nh   number of heads
Dh   head dimension for queries and keys
Dv   head dimension for values

本章建的普通多头自注意力实现里:

E = Nh * Dh
Tq = Tk = T
Dv = Dh

这是这个实现的契约,不是注意力的 law:grouped-query、多 query 注意力 key/value 头少于 query 头,有的结构 value 维与 key 维不同。下面推导把 Tq、Tk、Dh、Dv 分开,正为这个,只在具体实现要求处合并。

坏 reshape 实际做了什么

“值乱了”不是解释。这里是机制,用开篇小确定性张量。

输入是四位置各八特征:

tensor([[ 0,  1,  2,  3,  4,  5,  6,  7],      position 0
        [ 8,  9, 10, 11, 12, 13, 14, 15],      position 1
        [16, 17, 18, 19, 20, 21, 22, 23],      position 2
        [24, 25, 26, 27, 28, 29, 30, 31]])     position 3

头拆分的意图是划分特征轴。每位置八特征变两组四,一头一组:

position 0:   head 0 <- [ 0  1  2  3]     head 1 <- [ 4  5  6  7]
position 1:   head 0 <- [ 8  9 10 11]     head 1 <- [12 13 14 15]
position 2:   head 0 <- [16 17 18 19]     head 1 <- [20 21 22 23]
position 3:   head 0 <- [24 25 26 27]     head 1 <- [28 29 30 31]

reshape(B, T, Nh, Dh) 正做这个,因为它拆末轴、之前一切不动。transpose(1, 2) 再把已存在的头轴移到位置轴前:

good[0, 0]  (head 0)          good[0, 1]  (head 1)
tensor([[ 0,  1,  2,  3],     tensor([[ 4,  5,  6,  7],
        [ 8,  9, 10, 11],             [12, 13, 14, 15],
        [16, 17, 18, 19],             [20, 21, 22, 23],
        [24, 25, 26, 27]])            [28, 29, 30, 31]])

每头四行,一位置一行,装该位置该头的特征切片。这就是 [B, Nh, T, Dh] 该有的意思。

现在 reshape(B, Nh, T, Dh)。reshape 按内存顺序读元、填进新形状,32 个数扁平序列切成两块 16。内存这里位置主序,前 16 个数是位置 0、1 全体:

heads[0, 0]  (head 0)         heads[0, 1]  (head 1)
tensor([[ 0,  1,  2,  3],     tensor([[16, 17, 18, 19],
        [ 4,  5,  6,  7],             [20, 21, 22, 23],
        [ 8,  9, 10, 11],             [24, 25, 26, 27],
        [12, 13, 14, 15]])            [28, 29, 30, 31]])

“头 0”现在装位置 0、1,“头 1”装位置 2、3。更糟,每头里一位置的两特征半变成 Tq 轴上两个独立行。张量声称每头四 query 位置;装着两位置各切一半。

算子根本没拆特征轴。它拆了序列。后面每阶段 happily 跑:分数矩阵拿半位置和半位置比,softmax 在错候选上归一化,输出形状对。

一般形式值得带走:

reshape 重解释已有元顺序。transpose 改变元顺序。要 reshape 给出需要置换的轴排布,得到的是形状不是排布。

存储机制归第 2 章:步长、连续、view vs reshape。本章讲轴含义,lean 在第 2 章不重复。实用指针,下面用两次:transpose 后张量可能非连续,用 reshape,或 .contiguous().view(...) 显式拷贝。

技术:四层正确性

每章加一种调查法。第 2 章要第一个错的张量而不是第一个不合法的。第 3 章问梯度通路第一次消失处。第 5 章问哪套结构对归属不一致。第 7 章问样本在哪不再满足契约。第 8 章问推导与观测几何第一次分歧处。第 9 章问一向量表示什么、哪个轴装坐标。

第 10 章加:

算子跑之前说出每个注意力轴。再验证它后该成立的第一个不变式。第一个不变式失败处停。

形状自己带不动这里,开篇失败就是证明:它产出恰好推导的形状。所以建任何东西前,值得精确说注意力张量的“正确”是什么意思,因为它在四个深度是四种意思。

LEVEL 1  SHAPE               Does the tensor have the dimensions I derived?
                             caught by: an assertion on .shape

LEVEL 2  AXIS SEMANTICS      Do those dimensions hold the objects I intended?
                             caught by: deterministic tensors, value comparison,
                             round-trip properties

LEVEL 3  NUMERICAL           Do query rows sum to one over the key axis?
         INVARIANTS          Are forbidden weights zero? Is everything finite?
                             caught by: assertions on values, not shapes

LEVEL 4  BEHAVIOR            Does changing a future input move a past output?
                             Does this match a trusted reference implementation?
                             caught by: interventions and differential tests

每层容易错当上一层,层间不可互换。第 8 章的形状台账故意集中 Level 1,因为它的问题是卷积几何。注意力让那个证据的极限无法忽视:开篇失败 Level 1 畅通、Level 2 死,后面失败能过 Level 1 到 3 仍违反意图算子。

所以循环是第 8 章的,加宽:

DERIVE THE AXES
    ↓
EXECUTE ONE STAGE
    ↓
VERIFY THE INVARIANT THAT STAGE INTRODUCES
    ↓
STOP AT THE FIRST FAILURE

本章剩下逐阶段建注意力,说出每阶段引入的不变式,每个故意失败标最早暴露它的层。要点不是每失败有唯一层,而是单层不够。

Q、K、V 是三个投影

从输入契约与三 learned 线性映射开始。

B, T, E = 2, 5, 12
x = torch.randn(B, T, E)

q_proj = nn.Linear(E, E, bias=False)
k_proj = nn.Linear(E, E, bias=False)
v_proj = nn.Linear(E, E, bias=False)

q, k, v = q_proj(x), k_proj(x), v_proj(x)
x   (2, 5, 12)
q   (2, 5, 12)   k (2, 5, 12)   v (2, 5, 12)

第 9 章已推导:nn.Linear 映 [..., E_in] -> [..., E_out] 并保留每前导轴,10 个位置向量独立变换,形状不变。注意力-specific 的事还没发生。Q、K、V 是同样输入的三 learned 表示,张量系统看来目前可互换。

常用比喻用一次就丢。query 叫“这个位置在找什么”、key 叫“这个位置提供什么”、value 叫“这个位置贡献什么”是 serviceable 的 mnemonic,不是定义。机械内容是:

Q and K   produce pairwise compatibility scores
V         holds the vectors that get mixed according to those scores

这够推导下面一切,不像比喻可检查。

一 query 对所有 key

头、掩码之前,核心对象。取一头的 query 与 key,Tq、Tk 故意不同:

Q = torch.randn(2, 3, 4)      # [B, Tq, Dh]
K = torch.randn(2, 5, 4)      # [B, Tk, Dh]

跑之前推导乘积。矩阵乘把左操作数末轴与右操作数倒数第二轴收缩,两必须碰的轴是装 Dh 坐标的轴。K 的 Dh 在末尾,得动:

K                     [B, Tk, Dh]                    observed (2, 5, 4)
K.transpose(-2, -1)   [B, Dh, Tk]                    observed (2, 4, 5)

Q @ Kᵀ    [B, Tq, Dh] @ [B, Dh, Tk]  ->  [B, Tq, Tk]  observed (2, 3, 5)

这是第 10 章引入的新对象,值得逐条大声读:

scores[b, i, j]

b   which example
i   which query position is asking
j   which key position is being scored

一标量是样本 b 里 query 位置 i 与 key 位置 j 的兼容度。这不是解释,是算术,可查:第 10 章拿 Tq 向量和 Tk 向量比,得到 Tq × Tk 标量。这就是全部结构区别,分数矩阵一般矩形,只在 query、key 序列恰好同一序列时方形。普通自注意力 Tq = Tk = T,显式分数格每样本每头 T² 条,序列长翻倍格四倍。怎么办归性能章;形状是这里要紧的。

哪两轴必须动

transpose(-2, -1) 不是注意力咒语。它断言末两轴装 key 位置与头坐标,必须换的是这两。一旦张量 [B, Nh, Tk, Dh],k.transpose(1, 2) 换的是头与 key 位置:

k                    (2, 3, 5, 4)   axes [B, Nh, Tk, Dh]
k.transpose(-2, -1)  (2, 3, 4, 5)   axes [B, Nh, Dh, Tk]     <- what we want
k.transpose(1, 2)    (2, 5, 3, 4)   axes [B, Tk, Nh, Dh]     <- heads and keys swapped

q @ k.transpose(1, 2)
RuntimeError: The size of tensor a (3) must match the size of tensor b (5)
at non-singleton dimension 1

这里抛是幸运情形。Nh、Tk、Dh 恰好相等时什么都不抛:

Nh = Tk = Dh = 4
good (2, 4, 4, 4)   bad (2, 4, 4, 4)   shapes equal: True
values equal: False   max abs diff: 14.6166

Level 1 看不见。与正确推导参照的值比看得见。

为什么 sqrt(Dh) 缩放存在

第 9 章末尾注意到点积大小依赖两向量范数,成分尺度大致固定时随坐标数系统变大。注意力立刻撞上,因为 Dh 是换模型就变的设计选择。

论证短。Q、K 成分独立均值 0 方差 1,每项 q_d k_d 均值 0 方差 1,加 Dh 项方差约 Dh、标准差约 sqrt(Dh)。每维 64×32 query、key 向量测得:

    Dh   raw std   scaled std   sqrt(Dh)   raw maxp   scaled maxp   raw H   scaled H
     8    2.8247       0.9987     2.8284     0.4889        0.1604   1.6781     3.0271
    32    5.6665       1.0017     5.6569     0.7355        0.1628   0.7572     3.0186
   128   11.3023       0.9990    11.3137     0.8710        0.1656   0.3323     3.0103
   512   22.6109       0.9993    22.6274     0.9346        0.1645   0.1606     3.0138

未缩放标准差 64 倍头维范围紧跟 sqrt(Dh)。除以 sqrt(Dh) 钉在约 1。

右两对列说为什么在乎。maxp 是每 query 行平均最大 softmax 概率;H 是 32 key 上平均 softmax 熵,均匀分布给 ln(32) = 3.4657。未缩放最大概率 0.49 爬到 0.93、熵 1.68 塌到 0.16,纯因头维变大。缩放后两者平。

因果链,假设附上:

larger Dh
    ↓  assuming roughly unit-variance, independent components
larger unscaled dot-product variance
    ↓
larger differences between the logits in one query row
    ↓
sharper softmax

两 caution。sqrt(Dh) 关系是这个实验方差假设的后果,不是任意 learned 表示的保证,它们的成分一般既非单位方差也非独立。低熵不是缺陷;学到 sharp attend 的模型在干活。实验说的更窄更有用:没缩放,softmax 锐度随形状参数变,而不是随模型学到的变。

这个留着,本章的 Level 4 失败。缺缩放本地可查的不变式全不 broken。只参照对比抓住。

Softmax 引入本章最有用的不变式

分数是无界实数。注意力把每 query 的一行变成混合系数,softmax over key 轴:

weights = torch.softmax(scores, dim=-1)

分数形状 [B, Nh, Tq, Tk],末轴是 Tk,对候选 key 归一化,每 (batch, head, query) 三元组一次。得到本章最倚重的不变式:

每个 valid query 行变成允许 key 位置上的分布。

因而一行诊断:

weights.sum(dim=-1)      # should be 1 for every valid row

锚:错 softmax 轴——Level 3 失败

softmax 要 dim,会接受错的。第 9 章对 F.normalize 说过同样的话;这里后果更大。

good = torch.softmax(scores, dim=-1)
bad  = torch.softmax(scores, dim=-2)
shapes equal: True (1, 2, 4, 4)     both finite: True     values equal: False

good.sum(dim=-1)  max abs error from 1: 1.19e-07
bad.sum(dim=-1) : [0.8446, 1.1353, 0.7004, 1.3197]
bad.sum(dim=-2)   max abs error from 1: 5.96e-08

两合法算子,形状相同,值全有限,都 well-defined。归一化的关系不同:

dim=-1   for each query, distribute weight across the keys
dim=-2   for each key, distribute weight across the queries

第二个是 coherent 算子。不是这里意图的注意力,模型里任何形状断言分不出区别。行和检查一行分开,正是从 Level 1 到 Level 3 的跳跃。

值把权重变成输出向量

最后一块。key 上有权重、key 索引 value 向量:

weights   [B, Nh, Tq, Tk]
V         [B, Nh, Tk, Dv]

weights @ V   ->   [B, Nh, Tq, Dv]

收缩轴是 Tk,正对:权重分布在它上,求和里消失。一输出向量 out[b, h, i] 是 Tk 个 value 向量的加权组合,用 query i 的权重。

两 value 向量与手选权重让它 physical:

V        (1, 2, 2)     [[1, 0], [0, 1]]
weights  (1, 1, 2)     [[0.75, 0.25]]
out      (1, 1, 2)     [[0.75, 0.25]]

三 key 上真 softmax 权重、五维,matmul 与手写加权和对比:

weights[0,1]: [0.1721, 0.4352, 0.3927]
out[0,1]    : [-0.1035, 0.1147, 0.7471, 0.5384, 0.1653]
manual sum  : [-0.1035, 0.1147, 0.7471, 0.5384, 0.1653]   match: True
every output coordinate within the per-coordinate min/max of V: True

末行点名真属性。普通 softmax 后权重非负和一,每输出是该 query 的 value 向量的凸组合,落不出它们的逐坐标 min/max。softmax 前加性分数偏置与掩码不改这个属性,只要行里至少一个有限允许 key。系数在归一化后被改成负或和不为一,属性停止成立。

整个机制三行装下:

score the keys against the query
normalize those scores over the keys
use the normalized scores to mix the values

注意力其余都是周围 bookkeeping。

现在讲头

头不是新对象。多一结构轴,存在因为把 E 切成 Nh 组让模型在 Nh 个不同 Dh 维子空间上跑 Nh 个独立分数矩阵,而不是一个大的。

[B, T, E]
    ↓  split the feature axis:  E = Nh * Dh
[B, T, Nh, Dh]
    ↓  move the head axis outward
[B, Nh, T, Dh]

写成一对函数:

def split_heads(x, num_heads):
    B, T, E = x.shape
    assert E % num_heads == 0, f"E={E} not divisible by num_heads={num_heads}"
    Dh = E // num_heads
    return x.reshape(B, T, num_heads, Dh).transpose(1, 2)

def merge_heads(x):
    B, Nh, T, Dh = x.shape
    return x.transpose(1, 2).reshape(B, T, Nh * Dh)

拆分后每阶段多一前导轴,其余与单头推导不变:

Q        [B, Nh, Tq, Dh]
K        [B, Nh, Tk, Dh]
V        [B, Nh, Tk, Dv]
scores   [B, Nh, Tq, Tk]
weights  [B, Nh, Tq, Tk]
context  [B, Nh, Tq, Dv]

锚:拆/合往返——Level 2 失败

这里是开篇失败一行抓住的检查,注意力跑之前。拆合头是纯重排:必须精确返回原张量。


确定性 `[2, 5, 12]` 张量,整除 12 的每头数:

```text
  Nh=1    split (2,  1, 5, 12)   merge (2, 5, 12)   round trip exact: True
  Nh=2    split (2,  2, 5,  6)   merge (2, 5, 12)   round trip exact: True
  Nh=3    split (2,  3, 5,  4)   merge (2, 5, 12)   round trip exact: True
  Nh=4    split (2,  4, 5,  3)   merge (2, 5, 12)   round trip exact: True
  Nh=6    split (2,  6, 5,  2)   merge (2, 5, 12)   round trip exact: True
  Nh=12   split (2, 12, 5,  1)   merge (2, 5, 12)   round trip exact: True

用 arange 之类的确定性张量,不用随机数据,比值不比形状。形状对比正确与坏拆分都过;值比不过。这是 Level 2 最纯的形式,本章最便宜的高价值测试。

测注意力前,证明拆合头是无损重排。

属性异常值钱因为它一族实现全挂:进来漏转置、出去漏转置、转错轴对、合的头数与拆的不对。

合是反方向的同样错

[B, Nh, T, Dh] 回 [B, T, E],头轴先搬回里面再合末两轴:

[B, Nh, T, Dh]
    ↓  transpose(1, 2)
[B, T, Nh, Dh]
    ↓  reshape the final two axes into one
[B, T, Nh*Dh]

跳过转置从 [B, Nh, T, Dh] 直接 reshape,形状对张量错:

wrong shape: (2, 5, 12)   equals x: False
x[0,0]     : [0, 1, 2, 3,  4,  5,  6,  7,  8,  9, 10, 11]
wrong[0,0] : [0, 1, 2, 3, 12, 13, 14, 15, 24, 25, 26, 27]

位置 0 的十二特征从三位置的头切片重建。往返断言也抓住这个,这就是值得写一次而不是每个函数分别推理的原因。

掩码是关系

掩码回答对偶的问题,问哪个掩码意思不同。这个区分是大多数掩码 bug 的来源,先于代码。

CAUSAL / ATTENTION RELATION            KEY PADDING
Can query i use key j?                 Is key j real data for example b?
natural axes [Tq, Tk]                  natural axes [B, Tk]

两者最终都影响 [B, Nh, Tq, Tk] 分数张量。这不让它们成同一对象,合在一起意味着把两不同关系 deliberate 广播到同一格。

因果从分数矩阵读

scores[b, h, i, j] 意思是“query i 对 key j”一定,因果自回归是关于下标的陈述:

query i may use     keys j <= i
query i must not use keys j >  i

轴 label 画出来,因为没 label 的三角形说不出哪个角是未来:

allowed (rows = queries, cols = keys)      blocked = ~allowed
        k0 k1 k2 k3 k4                             k0 k1 k2 k3 k4
  q0     1  0  0  0  0                       q0     0  1  1  1  1
  q1     1  1  0  0  0                       q1     0  0  1  1  1
  q2     1  1  1  0  0                       q2     0  0  0  1  1
  q3     1  1  1  1  0                       q3     0  0  0  0  1
  q4     1  1  1  1  1                       q4     0  0  0  0  0

allowed keys per query: [1, 2, 3, 4, 5]

右上区是未来因为列是 key,列下标 j 大于行下标 i 就是 query 之后的 key。代码里 allow 关系是含对角线的下三角,torch.triu(ones, diagonal=1) 可验证是它的精确补:

allowed = torch.ones(T, T, dtype=torch.bool).tril(diagonal=0)
blocked = ~allowed
triu(ones, diagonal=1) equals blocked: True

变量按意思命名。mask 是引起下个问题的名字。

锚:掩码极性——Level 3 或 Level 4 失败,看 API

同一 release 两 PyTorch 注意力 API 布尔掩码极性相反。有文档,不是 bug,还会花你一下午。

装的 F.scaled_dot_product_attention 文档:布尔 attn_mask 值 True 表示该元参与注意力。装的 nn.MultiheadAttention 文档:二值 attn_mask 里 True 表示该位置不允许 attend,key_padding_mask 里 True 表示该 key 被忽略。

同样张量送不同函数意思相反。同样 Q、K、V、T=4 因果关系跑起来:

SDPA is_causal=True vs allow-mask : allclose True
SDPA is_causal=True vs block-mask : allclose False

max abs diff with inverted polarity: 3.4084601
inverted-polarity output finite: True    shape (2, 2, 4, 4)

经 SDPA 错极性产出形状正确、有限、与因果参照实质不同的张量,本地行和不变式全不 broken:它仍是某 key 集上的 valid softmax。参照对比或因果干预暴露语义错。这是 Level 4。

经 nn.MultiheadAttention 同样错误早一层浮现。这里是两极性返回的逐头权重:

blocked-polarity mask (correct for MHA), weights[0,0]:
tensor([[1.0000, 0.0000, 0.0000, 0.0000],
        [0.5173, 0.4827, 0.0000, 0.0000],
        [0.2602, 0.3738, 0.3661, 0.0000],
        [0.2756, 0.2385, 0.2327, 0.2532]])

allow-polarity mask (wrong for MHA), weights[0,0]:
tensor([[0.0000, 0.3521, 0.3015, 0.3464],
        [0.0000, 0.0000, 0.4802, 0.5198],
        [0.0000, 0.0000, 0.0000, 1.0000],
        [   nan,    nan,    nan,    nan]])

第二矩阵就是失败全文。query 0 只 attend 未来。query 3 每个 key block,无 valid 分布可归一化,回来 NaN——Level 3 抓住。未来 forbidden key 上最大权重 1.0:模型在读绝不能看的词元。

趁权重在眼前说个实用注。nn.MultiheadAttention 默认头上平均注意力权重;传 average_attn_weights=False 得逐头如上。平均看起来完全合理时可能一头在干 pathological 的事,平均还毁掉逐头检查 forbidden 权重为零要的逐头结构。

转换函数名字带上约定,调用处读成关于目标 API 的断言而不是关于张量的:

def allowed_to_sdpa_mask(allowed):        # SDPA: True participates
    return allowed

def allowed_to_mha_mask(allowed):         # MHA: True is blocked
    return ~allowed

布尔掩码没有通用含义。含义属于收它的 API。

只打印 mask.shape 的掩码诊断不是诊断。独立对错的东西是:

shape         does it broadcast onto [B, Nh, Tq, Tk]?
dtype         boolean relation, or additive float bias?
device        same as the scores?
polarity      does True mean allowed or blocked, for this exact function?
counts        how many pairs are allowed, and does any query have none?

掩码可以形状、dtype、设备全对,极性错,程序跑完。

显式广播 padding 掩码

key padding 掩码带着天生轴到来,必须告诉它分数格里沿哪轴常量:

[B, Tk]
    ↓  it varies with neither head nor query position
[B, 1, 1, Tk]
    ↓  broadcasts against
[B, Nh, Tq, Tk]
pad_valid = torch.tensor([[True,  True,  True,  True],
                          [True,  True,  False, False]])    # True = real token
expanded = pad_valid[:, None, None, :]
combined = expanded & allowed                                # both in ALLOW polarity
pad_valid  (2, 4)        expanded  (2, 1, 1, 4)
allowed    (4, 4)        combined  (2, 1, 4, 4)
masked scores            (2, 2, 4, 4)

row sums max error from 1        : 5.96e-08
weight on padded keys, example 1 : 0.0
allowed keys per query, example 1: [1, 2, 2, 2]

两处赚回位置。用 & 合关系只因两者同极性,变量才叫 allowed 与 pad_valid 而不是 mask、mask2。样本 1 允许 key 数停在 2 不涨因为位置 2、3 是 padding:两关系都 honor,计数证明。

第 2 章确立广播规则。注意力的规则更窄:

轴有语义时,广播轴自己插。别让 [B, Tk] 张量自己对四轴分数格找对齐。

全掩盖行

某 query 每个 key 都 forbidden,无分布可归一化。发生什么是实现细节,手工流水线与 PyTorch API 不同。手工 masked_fill(-inf) 后 softmax:

manual masked scores row 1: [-inf, -inf, -inf]
manual softmax row 1      : [nan, nan, nan]
manual weights all finite : False
row sums                  : [1.0, nan, 1.0]

NaN 经 weights @ V 污染模型剩下。这个 build 里同样关系过 F.scaled_dot_product_attention 行为不同:

SDPA output finite  : True
SDPA output row 1   : [0.0, 0.0, 0.0, 0.0]
non-finite count in SDPA output: 0

两结果都别 generalize。手工的是 softmax 在全 -inf 行上的属性;SDPA 的是这个 API、版本、后端的观测行为。全掩盖 query 是模型契约必须 account 的东西,不是该猜的后端行为。

每 query 都要产出有意义分布,显式拒绝全 block 行:

手工写出来。手写的要点不是 PyTorch 版不够,是中间件须可检查。

def manual_attention(q, k, v, allow_mask=None, scale=None):
    """q [.., Tq, Dh]   k [.., Tk, Dh]   v [.., Tk, Dv]
    allow_mask: boolean, True = this (query, key) pair may participate."""
    Dh = q.shape[-1]
    scale = 1.0 / math.sqrt(Dh) if scale is None else scale

    scores = q @ k.transpose(-2, -1) * scale
    masked = scores if allow_mask is None else scores.masked_fill(~allow_mask, float("-inf"))
    weights = torch.softmax(masked, dim=-1)
    out = weights @ v

    return out, {"scores": scores, "masked_scores": masked, "weights": weights}

两决定 deliberate。掩码参数叫 allow_mask,调用处读者不打开函数知道极性。中间件 dict 回来,对比失败时知道哪个阶段分歧,不只输出不同。

注意顺序:先掩码分数,再归一化。softmax 后把 forbidden 权重零掉,活下来的行和不足一,行和检查要保护的不变式 broken。

Level 4 测试:与可信实现对比

同样 Q、K、V,同样 scale,SDPA 极性下等价掩码,dropout 关:

mine, stages = manual_attention(q, k, v, allow_mask=allowed)
theirs = F.scaled_dot_product_attention(q, k, v, attn_mask=allowed, dropout_p=0.0)
torch.testing.assert_close(mine, theirs)
unmasked  max abs diff                : 2.38e-07    assert_close passed
causal    max abs diff, allow mask    : 1.19e-07    assert_close passed
causal    max abs diff, is_causal     : 1.19e-07    assert_close passed
forbidden weight max                  : 0.0

因果关系的两条路线都与手工实现、互相一致。这是真结果:头排布、转置、缩放、掩码极性、softmax 轴、值聚合全与参照一致。

现在去掉缩放看活下来什么:

unscaled vs SDPA max abs diff : 0.7033
unscaled rows still sum to 1  : 1.19e-07

形状对,值有限,行和一。本章 Level 1、2、3 检查全过。只有差分对比抓住,工具箱里有 Level 4 的全部论证。

对比有意义的 control 重要,无控变量的 mismatch 什么都教不了:

same Q, K, V tensors          same dtype and device
same scale                    dropout disabled on both sides
one equivalent mask, converted to each API's polarity

输出不一致,按顺序比中间件而不是猜:分数,再掩码分数,再权重,再输出。第一个不一致的阶段就是诊断。

多头自注意力模块

每阶段验证完,模块很短。

  in (2,  8, 32) -> out (2,  8, 32)  finite True
  in (1,  1, 32) -> out (1,  1, 32)  finite True
  in (3, 17, 32) -> out (3, 17, 32)  finite True
  in (5,  2, 32) -> out (5,  2, 32)  finite True

  MultiHeadSelfAttention(embed_dim=10, num_heads=3)
  ValueError: embed_dim=10 not divisible by num_heads=3

序列长 1 与 batch 1 在列表里 deliberate:某处 squeeze 轴的注意力代码 T=8 活、T=1 死,80000 步才发现不如在这里发现。可整除检查归构造器而不是四十行后的 reshape,第 5 章显式声明结构的理由一样:在构造时违反的契约产出点名真正问题的报错。

forward 里两行 quiet 干活

第一是 dropout_p=self.dropout if self.training else 0.0。函数式 API 拿 dropout_p 就施加;它不看外层模块的 .training flag,因为它没有外层模块——它是函数。装的文档直说并推荐 exactly 这个模式。两模块,一按建议一不按,都 .eval() 后调:

  NaiveDropoutAttn     eval() two calls identical: False
  CorrectDropoutAttn   eval() two calls identical: True

天真版评估时还在丢注意力权重,预测随机,验证指标 noisy,两次跑互相不一致。model.eval() 做了它一直做的事,即置 flag。没重写传给函数调用的参数,没东西会重写。

第二是 assert y.shape == x.shape,值得留也值得诚实。它保存 [B, T, E]。头轴 scramble 的版、query 上归一化的版、掩码极性反的版、无缩放的版都保存。

注意力能在几乎每内部阶段错的情况下保外部形状。

断言到 Level 1。这就是只断言输出形状的注意力模块感觉安全其实不安全的原因。

外部契约本身能被误读

nn.MultiheadAttention 默认 batch_first=False,意思是 [T, B, E]。[B, T, E] 张量传进去:

  batch_first=True   input (2, 5, 8) -> out (2, 5, 8)   weights (2, 5, 5)
  batch_first=False  input (2, 5, 8) -> out (2, 5, 8)   weights (5, 2, 2)

输出形状相同。模块把第一轴当序列、第二轴当 batch,2 位置跨 5 独立样本而不是 5 位置跨 2。唯一可见证据是注意力权重形状,从 [B, Tq, Tk] 变 [T, B, B]。边界 Level 1 过;里面 Level 2 挂。

每模块边界写下期待的外部排布。从习惯推测。

干预测因果

三角掩码是因果的一表示。它为之存在的契约是关于行为的陈述:

位置 i 的输出不得依赖任何 j > i 位置的输入。

直接可测,比看掩码强得多。因果模块 eval 模式 dropout 关,跑一序列,只改 i 之后位置,重跑:

i = 2
x2 = x.clone()
x2[:, i + 1:] = torch.randn(B, T - i - 1, E)

y1 = attn(x,  is_causal=True)
y2 = attn(x2, is_causal=True)
torch.testing.assert_close(y1[:, :i + 1], y2[:, :i + 1])
changed positions: [3, 4, 5]      inputs identical up to i: True

max |y1-y2| over positions 0..i  : 0.0
max |y1-y2| over positions i+1.. : 0.3916566
assert_close passed for the causal prefix

前缀精确零,后面明显非零。第二数与第一同样重要:两者都零,测试因干预什么都没做而过,是 trivial 通过。

两 control 确认测试能挂。同样模块关因果掩码,同样模块给结构对、这个 API 极性错的掩码:

causal masking disabled, max |y1-y2| over positions 0..i: 0.3799190
blocked-polarity mask,   max |y1-y2| over positions 0..i: 0.6628050

第二行是掩码极性锚在 Level 4 到来。掩码三角形,图对,信息照样从未来往回流,盯 torch.triu 再久找不到。一次干预找到。

手工实现还能直接查权重矩阵:

forbidden = stages["weights"][..., ~allowed].abs().max()      # observed 0.0

那是真证据,Level 3 而不是 Level 4,因为它测内部系数矩阵而不是输入输出行为。两者都有,prefer 干预。

看起来因果的掩码是断言。未来变了过去输出不动才是证据。

交叉注意力打破方形

自注意力 query、key、value 用一序列,Tq == Tk,分数矩阵方形。这个巧合吸进心智模型,交叉注意力一到假设全倒。先推导:

Q  [B, Nh, Tq, Dh]   = (2, 4,  7, 16)
K  [B, Nh, Tk, Dh]   = (2, 4, 11, 16)
V  [B, Nh, Tk, Dv]   = (2, 4, 11,  5)

scores   [B, Nh, Tq, Tk]   ->  (2, 4, 7, 11)
weights  [B, Nh, Tq, Tk]   ->  (2, 4, 7, 11)
out      [B, Nh, Tq, Dv]   ->  (2, 4, 7,  5)

再跑:

derived scores (2, 4, 7, 11)   observed (2, 4, 7, 11)
derived out    (2, 4, 7,  5)   observed (2, 4, 7,  5)
row sums max error: 1.19e-07

Dv 与 Dh 不同什么都不反对,因为 Dh 在 Q @ Kᵀ 收缩掉,Dv 经值聚合 ride。两者受不同东西约束:Dh 在 Q、K 间 match,Tk 在 K、V 间 match。

掩码后果直接。方形因果掩码装不上:

RuntimeError: The size of tensor a (7) must match the size of tensor b (11)
at non-singleton dimension 3

key padding 掩码装得上,因为它的天生轴一直是 [B, Tk]:

cross padding mask  (2, 11) -> (2, 1, 1, 11)
broadcasts against  (2, 4, 7, 11)
padded-key weight max, example 1: 0.0

所以带走的定义不是 T × T:

分数矩阵是 query 位置 × key 位置。自注意力是两者同一序列的特例。

注意力台账

第 7 章有预处理阶段报告,第 8 章有形状台账,第 9 章有特征空间检查器。注意力也要一个,必须记形状之外的东西,因为本章最危险的失败保期待形状。每行带三样:形状、轴含义、该点可查的不变式。

def attention_ledger(x, num_heads, projections, allow_mask=None, splitter=split_heads):
    q_proj, k_proj, v_proj, out_proj = projections
    B, T, E = x.shape
    Nh, Dh = num_heads, E // num_heads
    first = None

    def row(name, shape, axes, *checks):
        nonlocal first
        print(f"  {name:<14} {str(tuple(shape)):<16} {axes:<16} "
              + "; ".join(text for text, _ in checks))
        for text, ok in checks:
            if not ok and first is None:
                first = name
                print(f"  {'':<14} {'':<16} {'':<16} ^^ FIRST DIVERGENCE: {text}")
                break

    print(f"  ATTENTION LEDGER  B={B} T={T} E={E} Nh={Nh} Dh={Dh}")
    row("input", x.shape, "[B,T,E]", (f"E == Nh*Dh {E == Nh*Dh}", E == Nh * Dh))

    rt = merge_heads(splitter(x, Nh))
    row("head roundtrip", rt.shape, "[B,T,E]",
        (f"merge(split(x)) == x {torch.equal(rt, x)}", torch.equal(rt, x)))

    q, k, v = (splitter(p(x), Nh) for p in (q_proj, k_proj, v_proj))
    row("Q", q.shape, "[B,Nh,Tq,Dh]")
    row("K", k.shape, "[B,Nh,Tk,Dh]",
        (f"Dh matches Q {q.shape[-1] == k.shape[-1]}", q.shape[-1] == k.shape[-1]))
    row("V", v.shape, "[B,Nh,Tk,Dv]",
        (f"Tk matches K {k.shape[-2] == v.shape[-2]}", k.shape[-2] == v.shape[-2]))

    scores = q @ k.transpose(-2, -1) / math.sqrt(Dh)
    fin = bool(torch.isfinite(scores).all())
    row("scores", scores.shape, "[B,Nh,Tq,Tk]",
        (f"finite {fin}", fin), (f"std {scores.std():.3f}", True))

        if allow_mask is None:
        masked = scores
        row("masked_scores", masked.shape, "[B,Nh,Tq,Tk]", ("no mask", True))
    else:
        masked = scores.masked_fill(~allow_mask, float("-inf"))
        dead = bool((~allow_mask).all(dim=-1).any())
        row("masked_scores", masked.shape, "[B,Nh,Tq,Tk]",
            (f"allowed {int(allow_mask.sum())}/{allow_mask.numel()}", True),
            (f"no fully blocked query {not dead}", not dead))

    weights = torch.softmax(masked, dim=-1)
    err = (weights.sum(-1) - 1).abs().max().item()
    blocked = None if allow_mask is None else (~allow_mask).expand_as(weights)
    forbidden = 0.0 if blocked is None or not blocked.any() \
        else weights[blocked].abs().max().item()
    fin = bool(torch.isfinite(weights).all())
    forbidden_ok = math.isfinite(forbidden) and forbidden <= 1e-6
    row("weights", weights.shape, "[B,Nh,Tq,Tk]",
        (f"key-row sum error {err:.1e}", math.isfinite(err) and err < 1e-5),
        (f"forbidden weight max {forbidden:.1e}", forbidden_ok),
        (f"finite {fin}", fin))

    context = weights @ v
    row("context", context.shape, "[B,Nh,Tq,Dv]",
        (f"finite {bool(torch.isfinite(context).all())}", bool(torch.isfinite(context).all())))
    row("merged", merge_heads(context).shape, "[B,Tq,Nh*Dv]")
    out = out_proj(merge_heads(context))
    row("output", out.shape, "[B,Tq,E]",
        (f"external layout preserved {out.shape == x.shape}", out.shape == x.shape))
    print("  first divergence:", first or "none")
    return out

健康因果 setup 上:

  ATTENTION LEDGER  B=2 T=5 E=12 Nh=3 Dh=4
  input          (2, 5, 12)       [B,T,E]          E == Nh*Dh True
  head roundtrip (2, 5, 12)       [B,T,E]          merge(split(x)) == x True
  Q              (2, 3, 5, 4)     [B,Nh,Tq,Dh]
  K              (2, 3, 5, 4)     [B,Nh,Tk,Dh]     Dh matches Q True
  V              (2, 3, 5, 4)     [B,Nh,Tk,Dv]     Tk matches K True
  scores         (2, 3, 5, 5)     [B,Nh,Tq,Tk]     finite True; std 0.269
  masked_scores  (2, 3, 5, 5)     [B,Nh,Tq,Tk]     allowed 15/25; no fully blocked query True
  weights        (2, 3, 5, 5)     [B,Nh,Tq,Tk]     key-row sum error 1.2e-07; forbidden weight max 0.0e+00; finite True
  context        (2, 3, 5, 4)     [B,Nh,Tq,Dv]     finite True
  merged         (2, 5, 12)       [B,Tq,Nh*Dv]
  output         (2, 5, 12)       [B,Tq,E]         external layout preserved True
  first divergence: none

开篇 bug,头拆分只用 reshape:

  ATTENTION LEDGER  B=2 T=5 E=12 Nh=3 Dh=4
  input          (2, 5, 12)       [B,T,E]          E == Nh*Dh True
  head roundtrip (2, 5, 12)       [B,T,E]          merge(split(x)) == x False
                                                   ^^ FIRST DIVERGENCE: merge(split(x)) == x False
  Q              (2, 3, 5, 4)     [B,Nh,Tq,Dh]
  K              (2, 3, 5, 4)     [B,Nh,Tk,Dh]     Dh matches Q True
  V              (2, 3, 5, 4)     [B,Nh,Tk,Dv]     Tk matches K True
  scores         (2, 3, 5, 5)     [B,Nh,Tq,Tk]     finite True; std 0.267
  masked_scores  (2, 3, 5, 5)     [B,Nh,Tq,Tk]     allowed 15/25; no fully blocked query True
  weights        (2, 3, 5, 5)     [B,Nh,Tq,Tk]     key-row sum error 1.2e-07; forbidden weight max 0.0e+00; finite True
  context        (2, 3, 5, 4)     [B,Nh,Tq,Dv]     finite True
  merged         (2, 5, 12)       [B,Tq,Nh*Dv]
  output         (2, 5, 12)       [B,Tq,E]         external layout preserved True
  first divergence: head roundtrip

看剩下台账说什么。每形状对。分数有限标准差完全 ordinary。行和一。forbidden 权重零。输出保外部排布。十一行十行报告健康,模型在半位置上 attend。这就是 Level 2 抓住剩下十行结构上看不见的东西。

一 query 被所有 key block 的掩码:

  masked_scores  (2, 3, 5, 5)     [B,Nh,Tq,Tk]     allowed 11/25; no fully blocked query False
                                                   ^^ FIRST DIVERGENCE: no fully blocked query False
  weights        (2, 3, 5, 5)     [B,Nh,Tq,Tk]     key-row sum error nan; forbidden weight max nan; finite False
  context        (2, 3, 5, 4)     [B,Nh,Tq,Dv]     finite False
  first divergence: masked_scores

weights 与 context 也非有限,都不是诊断。掩码是。第 8 章 first-divergence 纪律一样:先挂的行是修的行,之后每行都是下游证据。

极性反的掩码落同样位置,因为因果关系取反把 query 0 从每个 key block:

  masked_scores  (2, 3, 5, 5)     [B,Nh,Tq,Tk]     allowed 10/25; no fully blocked query False
                                                   ^^ FIRST DIVERGENCE: no fully blocked query False
  first divergence: masked_scores

台账便宜覆盖 Level 1 到 3,每阶段,轴名字写在数旁边。到不了 Level 4,参照对比与因果干预是独立工具而不是更多台账行。

一次反向

只推理 work 的注意力没完。单 smoke 测试确立模块支持训练:

x = torch.randn(2, 8, 32, requires_grad=True)
loss = attn(x, is_causal=True).square().mean()
loss.backward()
loss: 0.033648        x.grad finite: True   norm 0.010129
  q_proj.weight    grad present  finite True  norm 0.008869
  k_proj.weight    grad present  finite True  norm 0.008957
  v_proj.weight    grad present  finite True  norm 0.087069
  out_proj.weight  grad present  finite True  norm 0.064535

四参数收到有限梯度,有限梯度到达输入。第 3 章的机器解释这个证据:每期待参数到损失有通路,这个 smoke 测试没 detach 图。上面打印的梯度范数是一次初始化的观测,不是 Q、K、V、输出投影梯度大小的一般排名。

训练讲到这里止。那些梯度大小有用吗,优化器拥有参数吗,损失真降吗,是第 11 章的主题。

在注意力代码上用 AI

助手读注意力代码看到逐个正确的算子,因为它们正确。reshape 正确。softmax 正确。掩码形状合法。代码里没有的是每轴本该什么意思,修之前得确立。

Here is a PyTorch attention implementation.
Do not rewrite it and do not propose fixes yet.

For every intermediate tensor:
  1. Write its exact shape symbolically.
  2. Give every axis a semantic name from: B, Nh, Tq, Tk, E, Dh, Dv.
  3. State what ONE scalar or ONE vector at that stage represents.
  4. State the invariant that should become true after that operation.

In particular:
  - prove that split_heads followed by merge_heads is a value-preserving
    round trip on a deterministic tensor, before analyzing anything else;
  - derive the shape of Q @ K.transpose(-2, -1) and say which two axes moved;
  - identify which axis holds the candidate keys, and verify that softmax
    normalizes over that axis;
  - state the boolean-mask convention for the exact PyTorch function being
    called, and quote the documentation for that function;
  - verify that forbidden positions receive zero probability, and check
    whether any query has every key masked;
  - say whether 1/sqrt(Dh) scaling is present and what it stabilizes;
  - derive the shape of weights @ V and say which axis is contracted;
  - verify that the merged result restores the intended external layout.

Identify the FIRST stage whose shape, axis meaning, value arrangement or
invariant disagrees with the intended computation.
Do not suggest fixes downstream of that first divergence.

赚回位置的是引文档那句。掩码极性正是助手凭记忆跨 API 搞混的细节;具体函数的契约比回忆强。

这个 prompt 到 Level 1 到 3。Level 4 要实验不要 opinion:

This attention module is supposed to be causal. Do not inspect the mask.

Write an experiment that changes only input positions after index i, reruns
the module in eval mode with dropout disabled, and reports the maximum
absolute change in the output at positions 0..i and at positions i+1 onward.

Before running it, tell me what each of those two numbers would have to be
for the causal contract to hold, and what it would mean if the second one
were also zero.

末句是要紧的。两数都零的实验没证明因果;证明了干预什么都没做。

让 AI 先说出 query 与 key 轴,再让它修注意力。

注意力调试序列

 1. State the external contract: [B, T, E], and which axis is which.      L1

 2. Verify E is deliberately split: E == Nh * Dh.                         L1

 3. Prove split_heads -> merge_heads is an exact round trip on a
    deterministic tensor. Compare values, not shapes.                     L2

 4. Label Q [..., Tq, Dh] and K [..., Tk, Dh], then derive
    Q @ K.transpose(-2, -1) -> [..., Tq, Tk] and say which axes moved.    L1/L2

 5. Inspect score scale before softmax. Is 1/sqrt(Dh) present?            L4

 6. State the mask semantics for the exact API being called.
    Does True mean allowed or blocked, for this function?                 L2

 7. Apply the mask, prove the intended relations are excluded, and
    check that no query has every key blocked.                            L3

 8. Softmax over Tk. Verify every valid query row sums to one.            L3

 9. Derive weights [..., Tq, Tk] @ V [..., Tk, Dv] -> [..., Tq, Dv].      L1

10. Merge heads and verify the external output layout.                    L1/L2

11. For causal attention, run the future-token intervention test.         L4

12. Compare against F.scaled_dot_product_attention under identical
    Q, K, V, scale, equivalent mask and zero dropout.                     L4

13. Fix the FIRST failed invariant. Rerun. Do not fix two things at once.

步骤 1 到 4 抓住开篇失败。步骤 6 到 8 抓住掩码锚。步骤 11、12 抓住之前什么都抓不住的。

练习

  1. 同样形状,错头。 确定性 arange 张量复现开篇拆分。证明形状、dtype、元多重集相等而张量不等。同样注意力跑两遍报告最大输出差,写下坏拆分下“头 0”里到底哪些位置。
  2. 拆/合往返。 实现两函数,几个 [B, T, E] 形状、整除 E 的每 Nh 属性测 merge_heads(split_heads(x, Nh)) == x。再从 [B, Nh, T, Dh] 直接 reshape 弄坏合,确认测试抓住。
  3. 缩放 sweep。 Dh 取 {8, 32, 128, 512},有无 1/sqrt(Dh) 各测分数标准差、平均最大 softmax 概率、平均 softmax 熵。未缩放标准差与 sqrt(Dh) 比。说清关系成立的假设。
  4. 错 softmax 轴。 分数在 dim=-2 而不是 dim=-1 上归一化。证明哪些和变一,解释每归一化描述什么关系,解释为什么形状断言分不出它们。
  5. 掩码极性。 建一因果 allow 关系,manual_attention、F.scaled_dot_product_attention、nn.MultiheadAttention 各送一遍,每家显式转极性。再错极性各送一遍,记哪家出错误有限数、哪家出 NaN、哪些 query 行受影响。
  6. 因果干预。 因果模块 eval 模式。只改 i 之后位置,证明 0..i 输出不动、i 之后动。关因果、极性反各重复,记三组数。
  7. 交叉注意力。 Tq = 7、Tk = 11、Dh = 16、Dv = 5,跑前推导每形状。再证明方形因果掩码广播不上,建正确 key-padding 掩码,验证 padding key 权重零。
  8. 失败按层排序。 manual_attention 逐个弄坏:去缩放、softmax 轴反、头转置跳过、掩码反。每个记四层里哪层先检出,哪些检查一路全过。

下一步:全跑,还学不会

注意力不再是形状契约的黑盒。它是被表示向量间的短关系序列,每阶段可命名、可推导、可检查:

x           [B, T, E]        T represented vectors per example
Q, K, V     [B, T, E]        three learned projections, nothing new yet
split       [B, Nh, T, Dh]   feature axis partitioned, head axis moved outward
scores      [B, Nh, Tq, Tk]  query i against key j, scaled by 1/sqrt(Dh)
masked      [B, Nh, Tq, Tk]  forbidden relations excluded before normalization
weights     [B, Nh, Tq, Tk]  each valid query row a distribution over keys
context     [B, Nh, Tq, Dv]  a convex combination of value vectors per query
merged      [B, Tq, E]       head order restored, round trip provable
output      [B, Tq, E]       external contract preserved

五故意失败跑过这个流水线,一起说明层为什么要叠而不是塌成一检查:

形状告诉你多少关系存在。它不告诉你关系对不对。说出 query 与 key 轴,推导每变换,验证该阶段引入的不变式,在关系第一次不再是你想要的意思处停。

这是真进展,精确说清 progress 多少。现在能确立头值排布对,掩码意思是这个 API 以为的意思,干预下因果成立,每 query 行是允许 key 上的 proper 分布,实现与 PyTorch 自带一致,外部排布保存,有限梯度到达每参数。

这些都不确立模型会学到东西。机械正确的注意力块坐在有数据、目标、损失、优化器、学习率、schedule 的系统里,任一坏了都不异常。注意力-specific 的四层梯子不够了。下一章为训练系统本身发展另一套实验——从更难的情形开始:整个程序跑,损失有限,优化器 step,模型还是没用。

进跑而不学的模型。