Giải thích đầy đủ từ bài báo gốc "Attention Is All You Need" — kèm sơ đồ và biểu đồ tương tác
Nguồn gốc: Vaswani et al., NeurIPS 2017 · Phong cách trực quan: Stanford CS231n Lecture 8
Trước Transformer, các mô hình sequence transduction (dịch máy, mô hình ngôn ngữ, tóm tắt...) tốt nhất là RNN / LSTM / GRU kết hợp encoder–decoder và một cơ chế attention bổ trợ. RNN có một hạn chế cốt lõi:
Trạng thái ẩn tại bước $t$ phụ thuộc vào trạng thái $t-1$: $$ h_t = f(h_{t-1}, x_t) $$ Tính chất tuần tự này ngăn cản song song hóa trong một mẫu huấn luyện và gây khó khăn khi học phụ thuộc xa (long-range dependencies) — gradient phải lan truyền qua $O(n)$ bước, dễ vanishing/exploding.
Các kiến trúc dựa trên CNN (ByteNet, ConvS2S) cải thiện song song hóa nhưng số phép toán cần để liên hệ hai vị trí cách xa $n$ tăng tuyến tính ($O(n)$ với ConvS2S) hoặc logarit ($O(\log_k n)$ với ByteNet).
Transformer loại bỏ hoàn toàn recurrence và convolution, chỉ dùng self-attention. Hệ quả:
Hình 1. RNN encoder–decoder Sutskever 2014: toàn bộ thông tin chuỗi nguồn phải đi qua một c duy nhất kích thước cố định. Decoder dùng cùng c cho mọi bước → information bottleneck.
Cho chuỗi đầu vào (các symbol/token) $(x_1, \ldots, x_n)$, Transformer ánh xạ:
Để residual cộng được, mọi sub-layer và embedding đều có chiều output $d_{\text{model}} = 512$.
Hình. Sơ đồ luồng dữ liệu end-to-end. Lane trên (xanh): encoder biến chuỗi nguồn $(x_1, \ldots, x_n)$ thành biểu diễn $\mathbf{z}$. Lane dưới (hồng): decoder dùng chuỗi target shifted-right + $\mathbf{z}$ để sinh phân bố xác suất token tiếp theo. Mũi tên đỏ đứt: K, V của cross-attention được lấy từ $\mathbf{z}$.
Một hàm attention ánh xạ một query $q$ và một tập hợp các cặp (key, value) thành một output:
Transformer dùng scaled dot-product làm hàm score. Đóng gói các query, key, value thành ma trận:
Công thức trung tâm của bài báo (Eq. 1):
Diễn giải từng bước (sơ đồ dưới đây hiển thị đúng luồng tính toán theo công thức):
4. Nhân với $V$: tổng hợp value có trọng số: $\text{output}_i = \sum_{j=1}^{n} \alpha_{ij}\, v_j$.
Hình 2. Sơ đồ scaled dot-product attention theo đúng cấu trúc Figure 2 của paper gốc.
4 phép tính (operation boxes có viền đậm): ① MatMul sinh ra raw scores QKᵀ, ② Scale chia $\sqrt{d_k}$ sinh ra E (scaled scores), ③ Softmax sinh ra A (attention weights), ④ MatMul với V sinh ra Output. Mỗi tensor trung gian nằm giữa hai operation kế tiếp.
Giả sử các thành phần của $q$ và $k$ là biến ngẫu nhiên độc lập, mean 0, variance 1. Khi đó:
$$ q \cdot k = \sum_{i=1}^{d_k} q_i k_i $$có mean 0 và variance $d_k$ (variance của tổng các biến độc lập = tổng các variance, và $\text{Var}(q_i k_i) = \mathbb{E}[q_i^2]\mathbb{E}[k_i^2] = 1$).
Khi $d_k$ lớn, $q\cdot k$ có độ lệch chuẩn $\sqrt{d_k}$ → một số phần tử rất lớn → softmax bão hòa (gần one-hot) → gradient gần 0, học rất chậm.
Chia cho $\sqrt{d_k}$ đưa variance về 1 → softmax ở vùng có gradient hữu ích.
So sánh softmax trên cùng một logits $q^\top k_j$ (sinh từ $\mathcal{N}(0,1)^{d_k}$). Trái: không scale → khi $d_k$ lớn, phân bố cực sắc (gần one-hot). Phải: chia $\sqrt{d_k}$ → phân bố mềm, giữ được gradient.
Đặt $\mathbf{s} \in \mathbb{R}^n$ là vector logit, $\mathbf{p} = \text{softmax}(\mathbf{s})$, tức $p_i = e^{s_i}/\sum_l e^{s_l}$.
Jacobian của softmax:
$$ \frac{\partial p_i}{\partial s_j} = \begin{cases} p_i(1 - p_i) & i = j \\ -p_i p_j & i \mathrel{\char"2260} j \end{cases} $$Viết gọn: $J = \text{diag}(\mathbf{p}) - \mathbf{p}\mathbf{p}^\top$.
Khi softmax bão hòa — $s_{j^*}$ lớn vượt trội, $p_{j^*} \approx 1$, $p_i \approx 0$ với $i \mathrel{\char"2260} j^*$:
$$ J_{ij} \approx 0 \quad \forall i, j $$vì $p_i(1-p_i) \to 0$ và $p_i p_j \to 0$.
Hệ quả: $\partial \mathcal{L}/\partial s_j = \sum_i (\partial \mathcal{L}/\partial p_i) J_{ij} \to 0$ → gradient gần như tắt hoàn toàn, mô hình không cập nhật được $W_i^Q, W_i^K$.
Phân tích định lượng phần đuôi:
$$ p_{j^*} = \frac{1}{1 + \sum_{l \mathrel{\char"2260} j^*} e^{s_l - s_{j^*}}} $$Nếu khoảng cách $s_{j^*} - s_l \sim \sqrt{d_k}$ (chưa scale), với $d_k = 64$, khoảng cách $\sim 8$, $e^{-8} \approx 3 \times 10^{-4}$ — softmax đã rất gần one-hot. Sau khi chia $\sqrt{d_k}$, khoảng cách giảm về $\sim 1$, $e^{-1} \approx 0.37$ — softmax vẫn "mềm".
Cho $d_k = 4$, $n = 3$, một query và 3 keys/values:
Token nguồn 1 (giống query nhất, score=2) chi phối kết quả. Khi $d_k$ rất lớn và không scale, logits cách nhau $\sim 20$ → softmax $\approx (1, 0, 0)$ → mất tính phân biệt.
Với decoder self-attention, ta cần ngăn vị trí $i$ "nhìn" vị trí $j > i$. Thực hiện bằng cách cộng một ma trận mask $M$ vào trước softmax:
$$ \text{Attention}(Q, K, V) = \text{softmax}\!\left(\frac{Q K^{\!\top}}{\sqrt{d_k}} + M\right) V $$ $$ M_{ij} = \begin{cases} 0 & j \le i \\ -\infty & j > i \end{cases} $$Khi $M_{ij} = -\infty$, $\exp(-\infty) = 0$ → trọng số attention bị dập về 0.
E + M
A (attention weights)
Mask tam giác đảm bảo Q₁ chỉ nhìn K₁; Q₂ nhìn K₁, K₂; Q₃ nhìn cả ba. Mỗi cột của A vẫn cộng bằng 1.
Cả hai có độ phức tạp lý thuyết tương đương, nhưng dot-product nhanh hơn nhiều trong thực tế vì tận dụng GEMM tối ưu trên GPU. Khi không scale, additive đánh bại dot-product với $d_k$ lớn — chính là vấn đề bão hòa softmax. Sau khi scale, dot-product ngang ngửa hoặc tốt hơn.
Một head attention duy nhất "trung bình hóa" thông tin, làm mất đi khả năng tập trung vào nhiều khía cạnh khác nhau của chuỗi (cú pháp, ngữ nghĩa, đồng tham chiếu...). Multi-head cho phép mô hình đồng thời chú ý đến thông tin từ các không gian biểu diễn con (subspace) khác nhau tại các vị trí khác nhau.
Thay vì attention duy nhất trên chiều $d_{\text{model}}$, ta chiếu tuyến tính $Q, K, V$ qua $h$ projection khác nhau xuống các chiều $d_k, d_k, d_v$, chạy attention song song, rồi concat + chiếu trở lại:
Tham số học được:
| Ma trận | Shape |
|---|---|
| $W_i^Q$ | $\mathbb{R}^{d_{\text{model}} \times d_k}$ |
| $W_i^K$ | $\mathbb{R}^{d_{\text{model}} \times d_k}$ |
| $W_i^V$ | $\mathbb{R}^{d_{\text{model}} \times d_v}$ |
| $W^O$ | $\mathbb{R}^{h d_v \times d_{\text{model}}}$ |
Mỗi head học một phép chiếu xuống một subspace 64 chiều, ở đó "khái niệm tương đồng" được định nghĩa khác nhau. Ví dụ ở layer 5 trong paper:
Hình 3. Sơ đồ Multi-Head Attention thể hiện đúng công thức $\text{Concat}(\text{head}_1, \ldots, \text{head}_h) W^O$. Mỗi head có $W^Q, W^K, W^V$ riêng, chạy scaled dot-product, kết quả concat thành ma trận $[N \times h \cdot d_v]$, rồi nhân $W^O$.
Single-head full-dim (giả sử có): $Q, K, V \in \mathbb{R}^{n \times d_{\text{model}}}$.
Multi-head với $h$ head, mỗi head có $d_k = d_v = d_{\text{model}}/h$:
→ Tương đương về độ phức tạp, nhưng multi-head có biểu diễn phong phú hơn nhờ học $h$ subspace khác nhau và một phép trộn $W^O$.
Với $d_{\text{model}}=512$, $h=8$, $d_k=d_v=64$:
Tổng: $4 d_{\text{model}}^2 = 4 \times 262{,}144 = 1{,}048{,}576 \approx 1.05$M tham số/mỗi attention block.
Lưu ý: có thể implement bằng một ma trận $W^Q \in \mathbb{R}^{d_{\text{model}} \times d_{\text{model}}}$ (stack của $W_i^Q$) rồi reshape — cách torch.nn.MultiheadAttention thực hiện.
| # | Loại | Query | Key, Value | Mục đích |
|---|---|---|---|---|
| 1 | Encoder self-attention | encoder layer trước | encoder layer trước | mỗi vị trí encoder nhìn toàn bộ chuỗi nguồn |
| 2 | Encoder–Decoder attention | decoder layer trước | output encoder $\mathbf{z}$ | mỗi vị trí decoder nhìn toàn bộ chuỗi nguồn |
| 3 | Masked decoder self-attention | decoder layer trước | decoder layer trước (đã mask) | mỗi vị trí decoder nhìn các vị trí $\le i$ |
Trường hợp (2) chính là kế thừa cơ chế attention cổ điển của Bahdanau et al., nhưng áp dụng tổng quát hóa thành multi-head scaled dot-product.
Sau attention, mỗi layer có một FFN áp dụng độc lập lên từng vị trí (như nhau cho mọi vị trí, nhưng khác nhau giữa các layer):
(Eq. 2 — đây là một MLP 2 lớp với ReLU ở giữa.)
Chiều:
Cách nhìn tương đương: hai phép convolution kernel size 1 trên chiều thời gian.
Vai trò: cung cấp phi tuyến tính và dung lượng tham số cho mỗi vị trí — attention là tổng tuyến tính có trọng số, còn FFN bổ sung khả năng biến đổi đặc trưng phi tuyến.
Hình 4. Sơ đồ FFN theo đúng công thức $\text{FFN}(x) = \max(0, xW_1+b_1)W_2+b_2$. Mở rộng 4× tại lớp giữa rồi chiếu lại.
Mỗi token được ánh xạ qua embedding học được $E \in \mathbb{R}^{|V| \times d_{\text{model}}}$:
$$ e_t = E_{x_t} $$Theo Press & Wolf (2017), paper chia sẻ ma trận trọng số giữa:
Trong các lớp embedding, các trọng số được nhân với $\sqrt{d_{\text{model}}}$:
$$ e_t \leftarrow \sqrt{d_{\text{model}}} \cdot E_{x_t} $$Tại sao $\sqrt{d_{\text{model}}}$? Khi tying weights, lớp pre-softmax mong các embedding có chuẩn đủ lớn để logit có giá trị có ý nghĩa; nếu embedding được khởi tạo với variance $1/d_{\text{model}}$ (chuẩn Xavier), nhân với $\sqrt{d_{\text{model}}}$ đưa norm trung bình về $O(1)$, cùng cấp với positional encoding để hai thành phần cộng vào nhau cân bằng.
Tại đỉnh decoder:
$$ p(y_t = w \mid y_{\lt t}, \mathbf{z}) = \text{softmax}\!\big(h_t^{\text{dec}} E^\top\big)_w $$trong đó $h_t^{\text{dec}} \in \mathbb{R}^{d_{\text{model}}}$ là biểu diễn của decoder tại vị trí $t$, và $E$ là embedding đã chia sẻ.
Self-attention là hoán vị bất biến (permutation-equivariant) — nếu ta hoán đổi các token đầu vào, output cũng bị hoán đổi tương ứng nhưng không thay đổi bản chất. Vì Transformer không có recurrence/convolution để mã hóa thứ tự, ta phải tiêm thông tin vị trí vào input.
với $B = 10000$ trong paper gốc. Trong đó:
Bước sóng tạo thành cấp số nhân từ $2\pi$ đến $B \cdot 2\pi$. PE được cộng trực tiếp vào embedding của token:
$$ x_t^{(0)} = \sqrt{d_{\text{model}}}\, E_{x_t} + PE_t $$Mỗi hàng = một vị trí $pos$; mỗi cột = một chiều embedding $2i$ (sin) hoặc $2i+1$ (cos). Cột thấp = tần số cao (đổi màu nhanh theo $pos$), cột cao = tần số thấp.
Với mỗi offset cố định $k$, $PE_{pos+k}$ có thể viết như một biến đổi tuyến tính của $PE_{pos}$. Lý do: dùng công thức cộng góc:
$$ \sin(\omega(pos+k)) = \sin(\omega pos)\cos(\omega k) + \cos(\omega pos)\sin(\omega k) $$ $$ \cos(\omega(pos+k)) = \cos(\omega pos)\cos(\omega k) - \sin(\omega pos)\sin(\omega k) $$Với mỗi cặp chiều $(2i, 2i+1)$ tại tần số $\omega_i = 1/B^{2i/d_{\text{model}}}$:
$$ \begin{bmatrix} PE_{(pos+k,\,2i)} \\ PE_{(pos+k,\,2i+1)} \end{bmatrix} = \underbrace{\begin{bmatrix} \cos(\omega_i k) & \sin(\omega_i k) \\ -\sin(\omega_i k) & \cos(\omega_i k) \end{bmatrix}}_{R(\omega_i k)} \begin{bmatrix} PE_{(pos,\,2i)} \\ PE_{(pos,\,2i+1)} \end{bmatrix} $$Đây là một ma trận xoay trong $\mathbb{R}^2$ phụ thuộc chỉ vào $k$. Điều này khiến mô hình dễ dàng học các quan hệ vị trí tương đối — chỉ cần học một biến đổi tuyến tính tương ứng với offset.
Hai chiều $(2i, 2i+1)$ vẽ trên đường tròn đơn vị. Điểm xanh: $(PE_{pos,2i}, PE_{pos,2i+1}) = (\sin(\omega_i\, pos), \cos(\omega_i\, pos))$. Điểm đỏ: $PE_{pos+k}$. Kéo $k$ → điểm đỏ xoay theo cung tròn một góc $\omega_i k$.
Hằng số $10000$ kiểm soát dải bước sóng. Với $d_{\text{model}}=512$:
Phổ rộng này giúp mô hình ngoại suy sang chuỗi dài hơn lúc huấn luyện.
Một tính chất then chốt của PE sinusoidal: tích vô hướng $\langle PE_{pos}, PE_{pos+k}\rangle$ chỉ phụ thuộc vào $k$, không phụ thuộc $pos$.
Chứng minh: với mỗi cặp chiều $(2i, 2i+1)$:
$$ PE_{pos,2i} \cdot PE_{pos+k,2i} + PE_{pos,2i+1} \cdot PE_{pos+k,2i+1} $$ $$ = \sin(\omega_i pos)\sin(\omega_i (pos+k)) + \cos(\omega_i pos)\cos(\omega_i (pos+k)) $$ $$ = \cos(\omega_i (pos+k) - \omega_i pos) = \cos(\omega_i k) $$(Dùng công thức $\cos(A-B) = \cos A \cos B + \sin A \sin B$.) Tổng trên tất cả $d_{\text{model}}/2$ cặp:
Hệ quả:
$\langle PE_{pos}, PE_{pos+k}\rangle$ vẽ theo $k$. Hàm chẵn, cực đại tại $k=0$, giảm theo $|k|$ — chính là "kernel khoảng cách" mà attention dùng.
Paper thử cả hai (Table 3 hàng E): kết quả gần như giống hệt. Họ chọn sinusoidal vì khả năng ngoại suy chuỗi dài.
Mỗi sub-layer:
$$ y = x + \text{Sublayer}(x) $$Lợi ích: gradient chảy thẳng qua connection bậc nhất → giảm vanishing gradient trong stack 6 layer × 2-3 sub-layer.
Sau residual, áp dụng LayerNorm (Ba et al., 2016) trên chiều đặc trưng $d_{\text{model}}$ của mỗi vị trí độc lập:
$$ \text{LayerNorm}(x) = \gamma \odot \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta $$ $$ \mu = \frac{1}{d_{\text{model}}}\sum_{k=1}^{d_{\text{model}}} x_k, \qquad \sigma^2 = \frac{1}{d_{\text{model}}}\sum_{k=1}^{d_{\text{model}}} (x_k - \mu)^2 $$$\gamma, \beta \in \mathbb{R}^{d_{\text{model}}}$ là tham số học được (scale + shift). Khác với BatchNorm, LayerNorm không phụ thuộc batch size → ổn định khi batch nhỏ hoặc khi inference từng token.
Thứ tự Post-LayerNorm mà bài báo gốc dùng:
(Các paper sau này đôi khi dùng Pre-LN: $x + \text{Sublayer}(\text{LayerNorm}(x))$ — ổn định huấn luyện hơn nhưng đó là cải tiến sau, không phải của paper gốc.)
Input: $H^{(\ell-1)} \in \mathbb{R}^{n \times d_{\text{model}}}$.
Bước 1 — Multi-head self-attention:
$$ A^{(\ell)} = \text{MultiHead}\big(H^{(\ell-1)},\, H^{(\ell-1)},\, H^{(\ell-1)}\big) $$ $$ H'^{(\ell)} = \text{LayerNorm}\!\left(H^{(\ell-1)} + \text{Dropout}(A^{(\ell)})\right) $$Bước 2 — FFN position-wise:
$$ F^{(\ell)} = \text{FFN}(H'^{(\ell)}) = \max(0, H'^{(\ell)} W_1^{(\ell)} + b_1^{(\ell)})\, W_2^{(\ell)} + b_2^{(\ell)} $$ $$ H^{(\ell)} = \text{LayerNorm}\!\left(H'^{(\ell)} + \text{Dropout}(F^{(\ell)})\right) $$Sau 6 layer: $\mathbf{z} = H^{(6)}$.
Input: $S^{(\ell-1)} \in \mathbb{R}^{m \times d_{\text{model}}}$ và encoder output $\mathbf{z}$.
Bước 1 — Masked self-attention:
$$ A_1^{(\ell)} = \text{MultiHead}_{\text{masked}}\big(S^{(\ell-1)},\, S^{(\ell-1)},\, S^{(\ell-1)}\big) $$ $$ S_1^{(\ell)} = \text{LayerNorm}\!\big(S^{(\ell-1)} + \text{Dropout}(A_1^{(\ell)})\big) $$Bước 2 — Encoder-Decoder attention (Q từ decoder, K/V từ $\mathbf{z}$):
$$ A_2^{(\ell)} = \text{MultiHead}\big(S_1^{(\ell)},\, \mathbf{z},\, \mathbf{z}\big) $$ $$ S_2^{(\ell)} = \text{LayerNorm}\!\big(S_1^{(\ell)} + \text{Dropout}(A_2^{(\ell)})\big) $$Bước 3 — FFN:
$$ F^{(\ell)} = \text{FFN}(S_2^{(\ell)}) $$ $$ S^{(\ell)} = \text{LayerNorm}\!\big(S_2^{(\ell)} + \text{Dropout}(F^{(\ell)})\big) $$Sau 6 decoder layer:
$$ \text{logits} = S^{(6)} \, E^{\top} \in \mathbb{R}^{m \times |V|} $$ $$ p(y_t \mid y_{\lt t}, x) = \text{softmax}(\text{logits}_t) $$Hình 5. Kiến trúc Transformer đầy đủ (Vaswani et al., Figure 1).
Để hiểu mô hình lớn ở đâu, ta đếm tham số từng thành phần với $d_{\text{model}}=512$, $d_{\text{ff}}=2048$, $h=8$, $N=6$, $|V| \approx 37{,}000$ (BPE shared).
| Thành phần | Công thức | Số tham số |
|---|---|---|
| Multi-head self-attention | $4 d_{\text{model}}^2$ | $4 \times 512^2 = 1{,}048{,}576$ |
| FFN $W_1, b_1$ | $d_{\text{model}} d_{\text{ff}} + d_{\text{ff}}$ | $512 \times 2048 + 2048 = 1{,}050{,}624$ |
| FFN $W_2, b_2$ | $d_{\text{ff}} d_{\text{model}} + d_{\text{model}}$ | $2048 \times 512 + 512 = 1{,}049{,}088$ |
| 2 × LayerNorm ($\gamma, \beta$) | $2 \times 2 d_{\text{model}}$ | $2{,}048$ |
| Tổng/encoder layer | $\approx 8 d_{\text{model}}^2$ | $\approx 3.15$M |
| Thành phần | Số tham số |
|---|---|
| Masked self-attention | $4 d_{\text{model}}^2 \approx 1.05$M |
| Cross-attention | $4 d_{\text{model}}^2 \approx 1.05$M |
| FFN | $\approx 2.10$M |
| 3 × LayerNorm | $\approx 3{,}072$ |
| Tổng/decoder layer | $\approx 12 d_{\text{model}}^2 \approx 4.20$M |
Trực quan hóa phân bổ tham số:
Quan sát: FFN chiếm ~2/3 tham số mỗi layer. Đây là lý do các paper sau (Switch Transformer, Mixture-of-Experts) thay FFN bằng nhiều "expert".
Với $d_{\text{model}}=1024$, $d_{\text{ff}}=4096$, $h=16$: tham số attention/FFN scale theo $d_{\text{model}}^2$ → tăng ~4× so với base. Tổng $\approx 213$M.
Bảng 1 trong paper so sánh 3 chiều: (i) độ phức tạp/layer, (ii) số phép toán tuần tự, (iii) độ dài đường đi tối đa giữa hai vị trí.
| Layer type | Complexity per Layer | Sequential Ops | Max Path Length |
|---|---|---|---|
| Self-Attention | $O(n^2 \cdot d)$ | $O(1)$ | $O(1)$ |
| Recurrent | $O(n \cdot d^2)$ | $O(n)$ | $O(n)$ |
| Convolutional | $O(k \cdot n \cdot d^2)$ | $O(1)$ | $O(\log_k n)$ |
| Self-Attention (restricted, $r$) | $O(r \cdot n \cdot d)$ | $O(1)$ | $O(n/r)$ |
Với chuỗi rất dài ($n \gg d$), $n^2 d$ trở nên đắt. Giới hạn attention vào lân cận kích thước $r$ → complexity $O(r \cdot n \cdot d)$, path length $O(n/r)$. Đây là gốc rễ của các Transformer "thưa" (Longformer, Sparse Transformer).
Trọng số attention $\alpha_{ij}$ có thể được trực quan hóa — các head học các vai trò ngôn ngữ rõ ràng: phụ thuộc cú pháp, đồng tham chiếu, ranh giới câu.
Bảng 1 chỉ liệt kê FLOPs. Bộ nhớ cũng quan trọng không kém. Ma trận attention $A = \text{softmax}(QK^\top/\sqrt{d_k}) \in \mathbb{R}^{n \times n}$ phải được lưu lại để tính gradient.
Số liệu cụ thể — tương tác:
Bộ nhớ tăng $O(n^2)$ — rào cản cốt lõi khi mở rộng context. Là động lực của FlashAttention (giảm memory bằng tile + recompute → $O(n)$) và sparse attention.
Attention có thể được diễn giải theo nhiều cách khác nhau, cùng dẫn về cùng một công thức:
(a) Soft retrieval / dictionary lookup:
Một dictionary $\{(k_j, v_j)\}_{j=1}^n$ với key cứng (one-hot) sẽ cho:
$$ \text{lookup}(q) = v_{j^*}, \quad j^* = \arg\max_j \langle q, k_j\rangle $$Softmax biến điều này thành soft argmax → đạo hàm được, mượt mà:
$$ \text{Attention}(q, K, V) = \sum_j \text{softmax}_j(\langle q, k\rangle/\sqrt{d_k}) \cdot v_j $$(b) Kernel similarity với kernel exponential dot-product:
$$ \kappa(q, k) = \exp(\langle q, k\rangle / \sqrt{d_k}) $$ $$ \text{Attention}(q, K, V) = \frac{\sum_j \kappa(q, k_j) v_j}{\sum_j \kappa(q, k_j)} $$Đây chính là dạng Nadaraya–Watson estimator trong thống kê phi tham số — ước lượng giá trị tại $q$ bằng trung bình có trọng số của các quan sát $v_j$, trọng số là kernel.
(c) Hopfield network: Theo Ramsauer et al. (2020), self-attention tương đương với một update step của Modern Hopfield Network với năng lượng:
$$ E(\xi) = -\text{lse}(\beta, X^\top \xi) + \frac{1}{2}\xi^\top \xi $$Self-attention là gradient descent một bước trên $E$ → mỗi attention layer là một bước truy hồi mẫu trong bộ nhớ liên tưởng.
Adam (Kingma & Ba, 2015) duy trì hai moment chạy của gradient. Tại bước $t$ với gradient $g_t = \nabla_\theta \mathcal{L}_t$:
Bước 1 — Update biased first moment (trung bình động của gradient):
$$ m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t $$Bước 2 — Update biased second moment (trung bình động của bình phương gradient, theo element):
$$ v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2 $$Bước 3 — Bias correction (vì $m_0 = v_0 = 0$):
$$ \hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \qquad \hat{v}_t = \frac{v_t}{1 - \beta_2^t} $$Bước 4 — Cập nhật:
$$ \theta_t = \theta_{t-1} - \text{lrate}_t \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} $$Hyperparameter của paper:
$$ \beta_1 = 0.9, \quad \beta_2 = 0.98, \quad \epsilon = 10^{-9} $$$\beta_2$ điều khiển độ dài "trí nhớ" của ước lượng phương sai gradient. Trí nhớ hiệu dụng:
$$ \tau_{\text{half}} \approx \frac{\ln 2}{-\ln \beta_2} $$Ở giai đoạn warmup, learning rate tăng nhanh và phân bố gradient thay đổi rất nhanh. $\beta_2 = 0.999$ sẽ làm $\hat{v}_t$ tụt hậu; $\beta_2 = 0.98$ cho phép $v_t$ "đuổi kịp" gradient mới.
Phân tích hai chế độ:
Hai phase giao nhau tại $t = t_{\text{warmup}}$:
$$ \text{lrate}_{\max} = d_{\text{model}}^{-0.5} \cdot t_{\text{warmup}}^{-0.5} $$Với $d_{\text{model}}=512$, $t_{\text{warmup}}=4000$: $\text{lrate}_{\max} \approx 6.99 \times 10^{-4}$.
(a) Residual Dropout ($P_{\text{drop}} = 0.1$ với base, 0.3 với big EN-FR):
(b) Label Smoothing ($\epsilon_{ls} = 0.1$):
Thay vì target one-hot $\delta_{y}$, dùng phân bố mục tiêu:
$$ q'(k \mid y) = (1 - \epsilon_{ls})\, \delta_{y,k} + \frac{\epsilon_{ls}}{|V|} $$Loss cross-entropy với $q'$: $\mathcal{L} = -\sum_k q'(k|y) \log p(k|x)$.
Cross-entropy với label smoothing có thể tách thành hai thành phần:
$$ \mathcal{L} = -(1-\epsilon_{ls}) \log p(y \mid x) - \frac{\epsilon_{ls}}{|V|} \sum_{k} \log p(k \mid x) $$Số hạng thứ hai liên quan đến cross-entropy với phân bố đều $u(k) = 1/|V|$:
$$ H(u, p) = -\sum_k u(k) \log p(k \mid x) = -\frac{1}{|V|} \sum_k \log p(k \mid x) $$Vậy:
Vì $H(u, p) = H(u) + \text{KL}(u \| p)$, và $H(u) = \log|V|$ là hằng số:
$$ \mathcal{L} \;\overset{c}{=}\; (1-\epsilon_{ls}) \cdot [-\log p(y \mid x)] + \epsilon_{ls} \cdot \text{KL}(u \| p) $$Diễn giải: label smoothing tương đương cộng một regularizer KL kéo phân bố output $p$ về phân bố đều $u$ → tránh over-confident.
Bên trái: target one-hot ($\epsilon_{ls}=0$). Bên phải: target với label smoothing — xác suất khối 1 chia phần ra cho toàn bộ vocab. Đỉnh tại $y$ giảm xuống $1 - \epsilon_{ls}(1 - 1/|V|)$.
Với logits $z_k$, $p_k = \text{softmax}(z)_k$, gradient theo $z_k$:
$$ \frac{\partial \mathcal{L}}{\partial z_k} = p_k - q'(k \mid y) = \begin{cases} p_y - (1 - \epsilon_{ls}) - \dfrac{\epsilon_{ls}}{|V|} & k = y \\[6pt] p_k - \dfrac{\epsilon_{ls}}{|V|} & k \mathrel{\char"2260} y \end{cases} $$So với one-hot ($p_y - 1$ và $p_k$): label smoothing dịch chuyển điểm cân bằng — gradient = 0 không phải khi $p_y = 1$ mà khi $p_y = 1 - \epsilon_{ls}(1 - 1/|V|) \approx 0.9$ → mô hình không bao giờ bị đẩy về one-hot.
| $N$ | $d_{\text{model}}$ | $d_{\text{ff}}$ | $h$ | $d_k$ | $d_v$ | $P_{\text{drop}}$ | $\epsilon_{ls}$ | params | |
|---|---|---|---|---|---|---|---|---|---|
| base | 6 | 512 | 2048 | 8 | 64 | 64 | 0.1 | 0.1 | 65M |
| big | 6 | 1024 | 4096 | 16 | 64 | 64 | 0.3 | 0.1 | 213M |
| Model | EN-DE BLEU | EN-FR BLEU | Training cost (FLOPs) |
|---|---|---|---|
| Previous SOTA (ConvS2S Ensemble) | 26.36 | 41.29 | $7.7 \times 10^{19}$ |
| Transformer (base) | 27.3 | 38.1 | $3.3 \times 10^{18}$ |
| Transformer (big) | 28.4 | 41.8 | $2.3 \times 10^{19}$ |
Transformer base vượt mọi ensemble cũ với <5% chi phí.
Lúc huấn luyện, teacher forcing cho phép decoder thấy toàn bộ chuỗi target (shifted right) cùng lúc → song song.
Lúc suy diễn, sinh từng token:
y_0 = <BOS>
for t = 1, 2, ..., T_max:
logits_t = Transformer.decode(x, y_0..y_{t-1})
y_t = argmax / sample / beam-search trên softmax(logits_t)
if y_t == <EOS>: break
Greedy chọn từng token tham lam: $y_t = \arg\max_w p(w \mid y_{\lt t}, x)$.
Vấn đề: chuỗi có xác suất cao tích lũy không nhất thiết bắt đầu bằng token có xác suất cao nhất.
Beam search giữ song song $B$ giả thuyết. Tại mỗi bước, mở rộng mỗi giả thuyết thành $|V|$ kế tục, giữ lại $B$ chuỗi có log-prob tổng cao nhất:
$$ \text{score}(y_{1:t}) = \sum_{\tau=1}^{t} \log p(y_\tau \mid y_{<\tau}, x) $$Beam search thiên về chuỗi ngắn (vì cộng thêm log-prob âm cho mỗi token). Paper dùng length penalty của Wu et al. (2016):
$$ \text{score}_{\text{LP}}(y_{1:T}) = \frac{1}{\text{lp}(T)}\sum_{\tau=1}^{T} \log p(y_\tau \mid y_{<\tau}, x), \qquad \text{lp}(T) = \frac{(5 + T)^\alpha}{(5 + 1)^\alpha} $$Cấu hình paper: beam $B=4$, $\alpha = 0.6$, max output length $= |x| + 50$.
$\text{lp}(T) = (5+T)^\alpha / 6^\alpha$ vẽ theo $T$. $\alpha=0$: không penalty (=1). $\alpha=1$: chia trung bình theo độ dài. $\alpha=0.6$: phạt nhẹ chuỗi ngắn.
Khi sinh token $y_t$, decoder cần tính attention trên toàn bộ $y_{\lt t}$. Naïve: tính lại $K_\ell, V_\ell$ của mọi vị trí $\lt t$ ở mọi layer mỗi bước → $O(t)$ phép tính/vị trí, tổng $O(t^2)$ mỗi bước → $O(T^3)$ cho cả chuỗi.
Tối ưu: vì $K_\ell, V_\ell$ của vị trí $\tau < t$ không phụ thuộc vào token sau, ta cache chúng:
→ Mỗi bước chỉ tốn $O(t \cdot d)$, tổng $O(T^2 d)$ cho cả chuỗi, giảm 1 bậc $O(T)$.
Bộ nhớ cache: $2 \cdot N \cdot h \cdot T \cdot d_k$ float $= 2 \cdot 6 \cdot 8 \cdot T \cdot 64 = 6{,}144 \, T$ float/sequence. Với $T=1024$ ≈ 25 MB/sequence.
Mặc dù bài báo gốc không nêu KV-cache rõ ràng, đây là tối ưu hiển nhiên và là chuẩn trong mọi implementation thực tế.
Bài báo gốc không nêu chi tiết, nhưng theo implementation tham chiếu (tensor2tensor):
Với $W \in \mathbb{R}^{d_{\text{in}} \times d_{\text{out}}}$:
$$ W_{ij} \sim \mathcal{U}\!\left[-\sqrt{\frac{6}{d_{\text{in}} + d_{\text{out}}}}, \;\sqrt{\frac{6}{d_{\text{in}} + d_{\text{out}}}}\right] $$Tính chất: variance đầu ra của một layer tuyến tính khớp với variance đầu vào.
Sau đó nhân $\sqrt{d_{\text{model}}}$ trong forward → embedding có norm trung bình $\approx 1$, cùng cấp với PE.
Hệ quả tổng thể: ở step đầu tiên, mỗi sub-layer output có scale gần như input → residual $x + \text{Sublayer}(x) \approx x + \text{small noise}$ → mô hình ổn định để bắt đầu học.
Kiến trúc này khởi nguồn cho toàn bộ kỷ nguyên LLM — BERT, GPT, T5, LLaMA, Claude đều là biến thể trực tiếp.