AI Builder
Tự chú ý
Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.Cơ chế cho phép mỗi vị trí trong chuỗi chú ý đến mọi vị trí khác
The same lesson, opened from AI Engineer / Kiến trúc, AI Researcher / Kiến trúc tiên tiến.
Ẩn dụ — chợ Bến Thành
Hãy tưởng tượng bạn đang đứng trong chợ Bến Thành. Bạn là một “từ”, và bạn cần hoàn thiện nghĩa của mình bằng cách hỏi các gian hàng xung quanh.
| Thành phần | Ẩn dụ | Câu hỏi |
|---|---|---|
| Query (Q) | Câu hỏi bạn thì thầm | “Ai có thứ liên quan đến tôi?” |
| Key (K) | Tấm bảng hiệu của mỗi gian hàng, tóm tắt họ bán gì | “Tôi có gì để bạn so khớp?” |
| Value (V) | Món hàng thực sự họ trao cho bạn nếu bạn để ý đến họ | “Nội dung tôi trả về là gì?” |
Bạn nhìn lướt tất cả bảng hiệu (tính QKᵀ), cho điểm độ liên quan, rồi chia sự chú ý của mình (softmax). Cuối cùng bạn gom các món hàng theo tỷ lệ đó — đó là output của attention cho từ “bạn”.
Khám phá — attention trên một câu
Self-attention cho câu năm từ “Con mèo ngồi trên bàn” là một ma trận 5 × 5. Mỗi hàng là một token, và tổng mỗi hàng bằng 1 sau softmax. Màu càng đậm nghĩa là chú ý càng nhiều.
Với một hàng, các bước tính là: nhân Q với K của từng token, chia cho √d_k, rồi softmax để thành trọng số. Output của token là tổng có trọng số của các Value.
Thử tắt phép chia √d_k: khi d_k nhỏ (= 3), hiệu ứng chưa rõ, nhưng softmax vẫn dịch về một ô duy nhất. Với d_k = 64 trong thực tế, chênh lệch đó đủ để gradient tắt.
Khoảnh khắc Aha
Self-attention = mỗi từ “hỏi” tất cả từ khác trong cùng câu: “Bạn quan trọng với tôi bao nhiêu?” Tập hợp các câu trả lời sau softmax chính là hàng attention của từ đó. Output của từ đó là tổng có trọng số của mọi Value.
Khác với RNN phải truyền thông tin tuần tự qua thời gian, self-attention cho mọi từ một đường đi O(1) đến mọi từ khác, bất kể khoảng cách. “Tôi” ở đầu câu có kết nối trực tiếp với “tôi” ở cuối câu. Đây là trái tim của Transformer; khi nhân bản song song h lần, ta có multi-head attention.
Thử thách
Giải thích chi tiết
Self-attention (scaled dot-product attention) là phép toán để mỗi vị trí tính một vector đầu ra là tổng có trọng số của tất cả các Value trong cùng chuỗi, với trọng số là độ khớp giữa Query của vị trí đó và Key của các vị trí khác.
Q và K có n hàng và d_k cột, V có n hàng và d_v cột. Ma trận attention là n × n: mỗi ô (i, j) là mức chú ý token i dành cho token j.
Công thức gốc của Vaswani và cộng sự (2017)
Code mẫu: self-attention bằng NumPy
self_attention_numpy.py
import numpy as np
def softmax(x, axis=-1):
x = x - x.max(axis=axis, keepdims=True) # ổn định số học
e = np.exp(x)
return e / e.sum(axis=axis, keepdims=True)
def self_attention(X, Wq, Wk, Wv):
"""
X: (n_tokens, d_model) — embedding đầu vào
Wq: (d_model, d_k) — chiếu sang không gian Query
Wk: (d_model, d_k) — chiếu sang không gian Key
Wv: (d_model, d_v) — chiếu sang không gian Value
"""
Q = X @ Wq # (n, d_k)
K = X @ Wk # (n, d_k)
V = X @ Wv # (n, d_v)
d_k = K.shape[-1]
scores = Q @ K.T / np.sqrt(d_k) # (n, n) — QK^T/√d_k
weights = softmax(scores, axis=-1) # (n, n) — softmax theo hàng
output = weights @ V # (n, d_v) — tổng có trọng số
return output, weights
# Ví dụ: câu 5 từ, d_model = 8, d_k = d_v = 4
rng = np.random.default_rng(42)
X = rng.standard_normal((5, 8))
Wq = rng.standard_normal((8, 4)) * 0.1
Wk = rng.standard_normal((8, 4)) * 0.1
Wv = rng.standard_normal((8, 4)) * 0.1
out, attn = self_attention(X, Wq, Wk, Wv)
print(out.shape) # (5, 4)
print(attn.shape) # (5, 5) — tổng mỗi hàng ≈ 1
print(attn.sum(axis=-1)) # [1. 1. 1. 1. 1.]Code mẫu: masked self-attention và cross-attention
masked_and_cross.py
import numpy as np
def scaled_dot_product(Q, K, V, mask=None):
d_k = K.shape[-1]
scores = Q @ K.T / np.sqrt(d_k)
if mask is not None:
scores = np.where(mask, scores, -1e9) # đặt các ô bị che = -inf
weights = softmax(scores, axis=-1)
return weights @ V, weights
# --- causal mask cho decoder-only (GPT) ---
n = 5
causal = np.tril(np.ones((n, n), dtype=bool)) # True ở tam giác dưới
# scores[i, j] chỉ được phép > -inf khi j <= i
# --- cross-attention ---
# Q từ decoder (m token), K, V từ encoder (n token)
# Lưu ý: hình dạng attention là m × n, không bắt buộc vuông.
def cross_attention(dec_h, enc_out, Wq, Wk, Wv):
Q = dec_h @ Wq # (m, d_k)
K = enc_out @ Wk # (n, d_k)
V = enc_out @ Wv # (n, d_v)
out, _ = scaled_dot_product(Q, K, V)
return out # (m, d_v)Chi tiết toán học: phương sai của tích vô hướng
Giả sử các thành phần của q và k là biến ngẫu nhiên độc lập, kỳ vọng 0, phương sai 1. Khi đó q · k = Σᵢ qᵢkᵢ có kỳ vọng 0 và phương sai:
Độ lệch chuẩn là √d_k. Chia tích cho √d_k đưa độ lệch chuẩn về 1, nên softmax không bị đẩy vào vùng bão hoà. Với d_k = 64, hiệu chỉnh này ảnh hưởng lớn đến chất lượng huấn luyện. Nếu thay softmax bằng hàm khác, hằng số scaling có thể khác, nên luôn xem lại phương sai.
Mask: padding, causal và sliding-window
Trong thực tế, một batch chứa các chuỗi có độ dài khác nhau và phải được pad tới cùng độ dài. Padding mask đảm bảo attention không chú ý vào token PAD; nếu không, gradient bị nhiễu bởi các vector rác.
Causal mask (decoder-only): j > i thì đặt −∞, mô hình không được nhìn tương lai. Sliding-window mask (Longformer, Mistral): chỉ cho phép |i − j| ≤ w, giảm từ O(n²) xuống O(n·w). Kết hợp sliding window với vài token global (như CLS, SEP) là công thức của nhiều mô hình long-context hiện đại.
Mask phải áp trước softmax, không phải sau. Dùng −1e9 thay cho −∞ thật vẫn hoạt động với float32, nhưng tránh float16 vì −1e9 bị underflow.
Vì sao attention bền vững hơn RNN với phụ thuộc xa?
Trong RNN, tín hiệu từ token 1 đến token n đi qua n bước nhân ma trận. Nếu giá trị riêng của ma trận hồi quy không bằng 1, gradient co rút hoặc bùng nổ theo cấp số nhân của n. Đây là lý do LSTM và GRU phải thêm cổng.
Self-attention thì khác: đường đi từ token 1 đến token n luôn là một bước — một phép nhân QKᵀ. Gradient lan truyền thẳng, không suy giảm theo khoảng cách. Đổi lại, chi phí là O(n²). Đánh đổi này là nền tảng của kỷ nguyên Transformer.
Phát biểu chặt hơn: độ dài đường đi tối đa giữa hai vị trí trong đồ thị tính toán là O(1) với attention, O(n) với RNN, và O(log n) với CNN dilated. Vì vậy Transformer tổng quát hoá tốt với context dài, miễn là bộ nhớ cho phép.
Code mẫu: gradient qua attention
backward_attention.py
"""
Ta không tự viết backward cho attention — autograd lo việc đó. Nhưng
hiểu đường đi của gradient giúp bạn debug:
∂L/∂V = weights.T @ ∂L/∂output
∂L/∂W_i,: = softmax_grad(scores_i,:) * (V @ ∂L/∂output_i)
∂L/∂Q,∂K = đi ngược qua QK^T / sqrt(d_k)
Đoạn PyTorch minh hoạ — nếu một trong các tensor không requires_grad,
gradient sẽ chặn tại đó (điều hay xảy ra khi ta freeze embedding).
"""
import torch, torch.nn.functional as F
def attention(Q, K, V, mask=None):
d_k = Q.size(-1)
s = Q @ K.transpose(-2, -1) / d_k ** 0.5
if mask is not None:
s = s.masked_fill(~mask, float("-inf"))
w = F.softmax(s, dim=-1)
return w @ V, w
torch.manual_seed(0)
X = torch.randn(2, 5, 8, requires_grad=True) # (batch, n, d_model)
Wq = torch.randn(8, 4, requires_grad=True) * 0.1
Wk = torch.randn(8, 4, requires_grad=True) * 0.1
Wv = torch.randn(8, 4, requires_grad=True) * 0.1
out, _ = attention(X @ Wq, X @ Wk, X @ Wv)
loss = out.pow(2).mean()
loss.backward()
print("‖∂L/∂X‖ =", X.grad.norm().item())
print("‖∂L/∂Wq‖ =", Wq.grad.norm().item())
# Thay requires_grad của Wq bằng False → gradient không chảy tới Wq.Biến thể attention nên biết
- Additive attention (Bahdanau): ra đời trước scaled dot-product; tính score qua một MLP nhỏ. Biểu cảm hơn nhưng đắt, hiếm dùng trong Transformer hiện đại.
- Multi-Query Attention (MQA): nhiều head chia sẻ cùng một K và V, giảm mạnh chi phí KV cache khi inference LLM.
- Grouped-Query Attention (GQA): chia head thành G nhóm, mỗi nhóm chia sẻ K và V. Theo nguồn bài, Llama 2 và 3 dùng làm mặc định.
- Linear Attention: khai triển softmax qua feature map, đưa độ phức tạp về O(n·d²). Đánh đổi độ chính xác, phù hợp streaming.
- Sparse và Local Attention: chỉ attend vào lân cận hoặc một mẫu rời rạc. Longformer, BigBird và Mistral sliding window dùng ý này.
- Mamba và State Space Models: không phải attention, nhưng cạnh tranh trực tiếp cho ngữ cảnh dài.
Thuật ngữ liên quan
- Multi-head attention — chạy h bản self-attention song song với tham số khác nhau, rồi concat.
- Positional encoding — thêm thông tin vị trí vì self-attention không biết thứ tự. Gồm sinusoidal (gốc) và RoPE, ALiBi (hiện đại).
- Flash Attention — kỹ thuật tile-based để tính attention không cần ma trận n × n đầy đủ, tiết kiệm bộ nhớ và nhanh hơn trên GPU.
- KV cache — lưu K và V của các token đã sinh để không tính lại khi generate token tiếp theo.
- Attention mechanism — bài giới thiệu tổng quát (Bahdanau, Luong) trước khi vào self-attention.
Tóm tắt
- Mỗi token sinh ra ba vector: Query (hỏi gì?), Key (chứa gì?), Value (nội dung). Attention = softmax(QKᵀ/√d_k) · V.
- Mỗi token nối trực tiếp với mọi token khác — đường đi bằng 1, nắm bắt phụ thuộc xa tốt hơn RNN.
- Tính song song trên GPU qua một phép nhân ma trận — đây là lý do Transformer học nhanh hơn LSTM.
- Nhược điểm O(n²) về bộ nhớ và tính toán, giới hạn context window; Flash Attention và Sparse Attention giải quyết phần nào.
- Chia √d_k giữ softmax không bão hoà; masked attention chặn decoder nhìn tương lai; cross-attention đổi nguồn cho Q.
- Là trái tim của Transformer (GPT, BERT, Llama, Claude, Gemini, ViT) và là bước mở rộng tự nhiên thành multi-head attention.