跳轉到

Transformer 與注意力機制:Attention 在算什麼?為什麼要除以 √d?

難度:中偏難。需要矩陣乘法、softmax,以及〈深度學習訓練基礎〉裡的梯度消失。 本文的程式只用 numpy,數字來自 Python 3.12、numpy 亂數種子 0,2026-10-04 執行。只做前向計算,不涉及訓練。

1. 前言

介紹 Transformer 的文章,幾乎都會貼出這個公式:

Attention(Q, K, V) = softmax(Q Kᵀ / √d) V

接著說 Q 是 query、K 是 key、V 是 value,再放一張架構圖。公式沒錯,但讀完常常還是不知道:這一行到底在對每個詞做什麼?那個 √d 為什麼非除不可?而它又少了什麼,需要另外補?

本文想回答三個問題:

  • Attention 在算什麼?(先講結論:每個詞拿自己的 query,去跟所有詞的 key 算相似度,softmax 成權重,再把所有詞的 value 照權重平均。它是一個看內容決定權重的加權平均。)
  • 為什麼要除以 √d?(不除的話,相似度分數的標準差會跟著 √d 變大。d = 512 時 softmax 幾乎變成只挑一個,梯度不到除過的四分之一。)
  • Attention 少了什麼?(它不知道詞的順序。把輸入打亂,輸出只是跟著打亂,數值完全一樣。所以 Transformer 要另外加位置編碼。另一個代價是記憶體:序列長度翻倍,注意力矩陣變四倍。)

本文用兩個 numpy 實驗回答:一個看 √d,一個看順序。只討論 self-attention 的前向計算。

2. 先看它想解決什麼:RNN 的瓶頸

在 Transformer 之前,處理序列的主力是 RNN(包括 LSTM、GRU)。RNN 一次讀一個詞,把目前為止讀到的東西壓進一個固定長度的隱藏向量,再傳給下一步。

這有兩個問題。

第一,遠的資訊要走很多步。第 1 個詞的資訊要影響第 50 個詞,得經過 49 次更新,每一次都可能被沖淡。這和深層網路的梯度消失是同一件事。

第二,沒辦法平行。第 50 步要等第 49 步算完。GPU 擅長的是一次算一大批,RNN 用不到這個優勢。

Attention 的做法是:讓每個詞直接看所有其他詞。第 1 個詞和第 50 個詞之間只隔一步,而且所有詞可以同時算。

3. Attention 在算什麼

每個詞先被轉成一個向量(embedding)。這個向量分別乘上三個可學的矩陣,得到三個新向量:

  • query(Q):我在找什麼。
  • key(K):我能提供什麼,用來被比對。
  • value(V):被選中時,我實際交出去的內容。

然後對每個詞:

  1. 拿它的 query 和每一個詞的 key 做內積,得到一排相似度分數。
  2. 分數除以 √d(d 是 key 的維度),過 softmax,變成一排加總為 1 的權重。
  3. 用這排權重,把所有詞的 value 加權平均。結果就是這個詞的新表示。
import numpy as np

def softmax(z, axis=-1):
    z = z - z.max(axis=axis, keepdims=True)          # 數值穩定
    e = np.exp(z)
    return e / e.sum(axis=axis, keepdims=True)

def attention(Q, K, V, mask=None):
    scores = Q @ K.T / np.sqrt(K.shape[-1])          # (n, n):每對詞的相似度
    if mask is not None:
        scores = np.where(mask, scores, -np.inf)
    W = softmax(scores)                              # 每一列加總為 1
    return W @ V, W

rng = np.random.default_rng(0)
n, d = 5, 8                                          # 5 個詞,每個 8 維
X = rng.normal(size=(n, d))
Wq, Wk, Wv = (rng.normal(size=(d, d)) / np.sqrt(d) for _ in range(3))
out, W = attention(X @ Wq, X @ Wk, X @ Wv)

W 是一個 5×5 的矩陣。第 i 列是第 i 個詞「分給每個詞多少注意力」。out 的第 i 列,是照這一列權重混出來的新向量。

和一般的加權平均差在哪?權重不是固定的,是看內容算出來的。同一個「它」字,前面是「貓追老鼠,它跑得很快」或「它餓了」,query 和各詞 key 的相似度就不同,混出來的意思也不同。

實際的 Transformer 會同時跑好幾組 Wq, Wk, Wv,叫做 multi-head attention。每組維度比較小(例如 512 維拆成 8 組、每組 64 維),各自學不同的關係,最後接起來。原理和上面的單組一模一樣。

4. 實驗一:不除以 √d 會怎樣

我們讓 query 和 key 的每一維都是標準常態亂數,一個 query 對 16 個 key 算分數,重複 1,000 次。比較除和不除 √d:

for dk in [4, 64, 512]:
    q = rng.normal(size=(1000, dk))
    k = rng.normal(size=(1000, 16, dk))
    s = np.einsum("bd,bkd->bk", q, k)
    for name, sc in [("不縮放", s), ("÷√d", s / np.sqrt(dk))]:
        w = softmax(sc)
        # softmax 的 Jacobian = diag(w) − w wᵀ,用它的大小代表梯度能傳多少回去
        J = np.einsum("bi,ij->bij", w, np.eye(16)) - np.einsum("bi,bj->bij", w, w)
        print(dk, name, sc.std(), w.max(1).mean(), np.linalg.norm(J, axis=(1, 2)).mean())
d 縮放 分數的標準差 最大權重(平均) softmax 梯度大小
4 不縮放 2.01 0.431 0.319
4 ÷√d 1.00 0.238 0.297
64 不縮放 8.13 0.846 0.173
64 ÷√d 1.02 0.249 0.306
512 不縮放 22.49 0.948 0.069
512 ÷√d 0.99 0.249 0.305

兩件事。

第一,不縮放時,分數的標準差就是 √d(2.0、8.1、22.5,對應 √4 = 2、√64 = 8、√512 ≈ 22.6)。因為內積是 d 個「兩個獨立標準常態相乘」的和,每一項變異數是 1,加起來變異數是 d。

第二,分數一大,softmax 就幾乎只挑一個。d = 512 時,最大的那個權重平均拿走 95%。softmax 在這種地方很平:輸入怎麼小幅改變,輸出都還是那個 one-hot。梯度大小從 0.305 掉到 0.069,不到四分之一。訓練時,這代表 Q 和 K 的權重幾乎學不動。

除以 √d 之後,不管 d 多大,分數的標準差都穩在 1 附近,權重分布和梯度大小也跟著穩定。√d 不是調出來的超參數,是讓分數變異數不隨維度改變的那個數。

值得一提的是 d = 4 那一列:不縮放的梯度(0.319)反而比縮放後(0.297)大。維度小的時候分數本來就不大,縮放的好處還沒出現。這也說明它真正解決的是大維度的問題。

5. 實驗二:Attention 不知道順序

回頭看第 3 節的公式:每個詞的輸出,是「所有詞的 value 照相似度加權平均」。這裡面沒有任何一項跟「第幾個位置」有關。

所以把輸入打亂,會發生什麼事?

perm = np.array([4, 2, 0, 3, 1])
out_p, _ = attention(X[perm] @ Wq, X[perm] @ Wk, X[perm] @ Wv)
print(np.allclose(out_p, out[perm]))     # True

輸出只是跟著輸入一起被打亂,每個詞得到的向量一模一樣。對 attention 來說,「狗咬人」和「人咬狗」是同一句話。

這叫做 permutation equivariance。在某些任務上它是好事(例如處理一組沒有順序的點),但在語言上是大問題。

修法:在輸入裡加上位置的資訊。 原始論文用正弦和餘弦,每個位置產生一個獨特的向量,直接加到 embedding 上:

def sinusoidal(n, d):
    pos = np.arange(n)[:, None]
    i = np.arange(d // 2)[None, :]
    ang = pos / 10000 ** (2 * i / d)
    pe = np.zeros((n, d))
    pe[:, 0::2], pe[:, 1::2] = np.sin(ang), np.cos(ang)
    return pe

P = sinusoidal(n, d)
o1, _ = attention((X + P) @ Wq, (X + P) @ Wk, (X + P) @ Wv)
o2, _ = attention((X[perm] + P) @ Wq, (X[perm] + P) @ Wk, (X[perm] + P) @ Wv)
print(np.allclose(o2, o1[perm]))         # False:順序開始有影響了

加上位置編碼之後,同一個詞放在不同位置,向量就不同,輸出也不同。

現在的大型語言模型多半不再用這種加法式的編碼,改用 RoPE(rotary position embedding)這類做法:把位置資訊轉成對 query 和 key 的旋轉,讓兩個詞的相似度直接反映它們的相對距離。動機一樣,都是在補 attention 本身不知道順序的這個洞。

小節

Attention 是看內容決定權重的加權平均:query 和 key 算相似度,softmax 成權重,平均 value。 √d 讓分數的變異數不隨維度改變:d = 512 時不除,softmax 幾乎只挑一個,梯度不到四分之一。 Attention 本身不知道順序:打亂輸入,輸出只是跟著打亂。位置編碼是另外補上的。

6. 遮罩:讓模型不能偷看後面

寫文章的模型(像 GPT 這類 decoder)一次產生一個詞。訓練時整句一起餵進去,但第 3 個詞不應該看到第 4、5 個詞,不然就是偷看答案。

做法是在 softmax 前,把「後面的位置」的分數設成負無限大,softmax 之後權重就是 0:

mask = np.tril(np.ones((n, n), bool))        # 下三角:只能看自己和前面
_, Wc = attention(X @ Wq, X @ Wk, X @ Wv, mask)
[[1.   0.   0.   0.   0.  ]
 [0.88 0.12 0.   0.   0.  ]
 [0.42 0.29 0.29 0.   0.  ]
 [0.28 0.24 0.29 0.19 0.  ]
 [0.34 0.06 0.24 0.11 0.26]]

第 1 個詞只能看自己,所以權重是 1。第 2 個詞看前兩個,把 0.88 分給第 1 個詞。右上角全是 0。

這個遮罩就是 decoder 和 encoder(像 BERT)最主要的差別:encoder 每個詞可以看整句,decoder 只能往前看。

7. 一層 Transformer 長什麼樣

Attention 只是一層 Transformer 的一半。完整的一層是:

  1. Multi-head self-attention。
  2. 殘差連接:把輸入直接加回輸出,再做 LayerNorm。
  3. 前饋網路(FFN):每個詞各自過兩層全連接,中間通常放大成 4 倍寬。
  4. 再一次殘差連接加 LayerNorm。

殘差連接讓梯度可以繞過每一層直接往回傳,這是能疊幾十層的關鍵(和〈深度學習訓練基礎〉§4 講的梯度消失是同一個問題)。原始論文把 LayerNorm 放在殘差之後(post-LN);後來大多改放在每個子層之前(pre-LN),比較好訓練,不太需要 learning rate warmup。

分工可以這樣理解:attention 負責詞與詞之間交換資訊,FFN 負責每個詞自己消化。

8. 代價:O(n²)

第 3 節的 W 是 n×n。序列長度 n 翻倍,這個矩陣就變四倍。

用 16 位元浮點數存一個 head 的注意力矩陣:

序列長度 n 注意力矩陣大小(單一 head)
1,024 約 2 MB
4,096 約 34 MB
16,384 約 537 MB
131,072 約 34 GB

乘上 head 數和層數,長文本很快就裝不下。

FlashAttention 這類做法不改變數學結果,而是把矩陣切成小塊,在 GPU 的快取裡算完就丟,不把整個 n×n 存下來。記憶體因此變成跟 n 成線性,但計算量還是 n²。長上下文模型能做到幾十萬個 token,靠的是這類工程,加上其他近似方法。

9. 結論

回到前言的三個問題。

Attention 在算什麼? 每個詞用 query 和所有詞的 key 算相似度,softmax 成權重,加權平均所有詞的 value。權重看內容而定,所以同一個詞在不同句子裡會混出不同的意思。

為什麼要除以 √d? 不除的話,分數的標準差等於 √d。d = 512 時最大權重平均 0.95,softmax 梯度只剩 0.069(縮放後是 0.305)。除以 √d 讓分數穩在標準差 1。

它少了什麼? 詞序。打亂輸入,輸出只跟著打亂,所以要加位置編碼。另一個代價是 n×n 的注意力矩陣,長度翻倍、記憶體四倍。

延伸:這篇真正想留下的問題

注意力權重很容易被畫成熱力圖,然後解讀成「模型在看哪裡」。這很直覺,但不一定成立。

Jain 與 Wallace 在 2019 年的論文 Attention is not Explanation 發現,很多情況下可以換一組差很多的注意力權重,模型的預測卻幾乎不變。權重只是中間的一步,後面還有 value、FFN、好幾層的殘差。

這和〈模型可解釋性〉講的是同一件事:模型內部的某個數字很大,不代表它就是模型做決定的理由。 下次看到一張注意力熱力圖,值得停下來問一句:如果把這些權重換掉,答案會變嗎?


延伸閱讀(本站)

參考資料