Transformer Là Gì? Self-Attention, QKV Và Kiến Trúc Transformer

Mục lục bài viết

Hãy nhìn vào câu này:

The animal didn't cross the street because it was too tired.

Nếu được hỏi từ “it” đang nói tới cái gì, phần lớn chúng ta gần như lập tức trả lời: the animal.

Không phải the street.

Điều thú vị là “street” nằm gần “it” hơn “animal”. Nếu chỉ nhìn khoảng cách giữa các từ, đáp án gần nhất lại là đáp án sai. Muốn hiểu đúng, hệ thống phải kết nối nhiều mảnh thông tin: animal là sinh vật; tired mô tả một trạng thái mà sinh vật có thể trải qua; cấu trúc của câu khiến “it” nhiều khả năng quay lại chủ thể trước đó.

Đây chính là loại vấn đề khiến việc xử lý ngôn ngữ khó hơn rất nhiều so với việc tra từ trong từ điển.

Một từ không có ý nghĩa hoàn chỉnh khi đứng một mình. Ý nghĩa của nó phụ thuộc vào những từ khác, đôi khi cách nó vài chục hoặc vài nghìn token.

Trước Transformer, các mô hình chuỗi như RNN và LSTM thường truyền thông tin qua chuỗi theo từng bước. Transformer thay đổi câu hỏi.

Thay vì hỏi:

“Làm thế nào mang thông tin từ token đầu tiên đi qua hàng loạt bước để đến token hiện tại?”

Transformer hỏi:

“Tại sao token hiện tại không trực tiếp nhìn vào những token mà nó cần?”

Câu hỏi tưởng đơn giản này dẫn tới Self-Attention — cơ chế cho phép mỗi token xây dựng biểu diễn mới của mình bằng cách xem xét các token khác, đánh giá mức độ liên quan của chúng và tổng hợp thông tin phù hợp.

Đó là trái tim của kiến trúc Transformer được Vaswani và cộng sự giới thiệu trong Attention Is All You Need năm 2017. Transformer loại bỏ recurrence khỏi kiến trúc sequence-to-sequence gốc, tăng đáng kể khả năng song song hóa trong training và rút ngắn đường truyền thông tin giữa những vị trí xa nhau.

Nhưng để thật sự hiểu Transformer, biết câu thần chú:

Attention(Q, K, V)

là chưa đủ.

Chúng ta cần hiểu Q, K, V thực sự là gì, attention matrix được tạo ra như thế nào, tại sao phải chia cho √dₖ, Multi-Head Attention giải quyết vấn đề gì, positional information nằm ở đâu, và cuối cùng tất cả những thứ đó được ghép thành một Transformer block như thế nào.

Đó là hành trình của bài viết này.

1. Vấn đề trước Transformer không đơn giản là “RNN hay quên”

Một cách kể phổ biến về lịch sử Transformer là:

RNN
↓
vanishing gradient
↓
không nhớ được câu dài
↓
Transformer xuất hiện

Cách giải thích này đúng một phần, nhưng quá đơn giản.

RNN thực sự phải xử lý chuỗi theo quan hệ phụ thuộc tuần tự:

x₁ → h₁ → h₂ → h₃ → h₄ → ... → hₙ

Trạng thái tại bước t phụ thuộc vào trạng thái t - 1:

h_{t} = f (x_{t}, h_{t - 1})

Nếu muốn biểu diễn token cuối cùng dựa trên token đầu tiên, thông tin phải truyền qua một đường rất dài.

LSTM và GRU được thiết kế để cải thiện đáng kể vấn đề gradient và khả năng giữ thông tin dài hạn, vì vậy nói rằng “RNN đọc 50 từ là quên từ đầu tiên” không phải mô tả kỹ thuật chính xác.

Điểm nghẽn quan trọng hơn đối với việc scale là sequential dependency.

Để tính:

h₅

ta cần:

h₄

Muốn có h₄, phải có h₃.

Và cứ như vậy.

GPU rất giỏi những bài toán kiểu:

A × B

trong đó hàng triệu phép nhân có thể được thực hiện đồng thời.

Nhưng RNN về bản chất tạo ra chuỗi dependency:

step 1
  ↓
step 2
  ↓
step 3
  ↓
step 4

Không thể đơn giản tính toàn bộ các bước cùng lúc.

Transformer thay đổi cấu trúc này:

Token 1 ─┬─ Token 2
         ├─ Token 3
         ├─ Token 4
         └─ Token 5

Token 2 ─┬─ Token 1
         ├─ Token 3
         ├─ Token 4
         └─ Token 5

...

Trong một self-attention layer, các vị trí có thể tương tác trực tiếp với nhau.

Bài báo Transformer gốc phân tích sự khác biệt này theo ba chiều: computational complexity mỗi layer, số operation bắt buộc phải thực hiện tuần tự và độ dài lớn nhất của đường truyền thông tin giữa hai vị trí. Với self-attention toàn cục, số bước tuần tự theo chiều sequence giảm từ (O(n)) của recurrent layer xuống (O(1)), đồng thời maximum path length giữa hai token cũng giảm từ (O(n)) xuống (O(1)). Đổi lại, self-attention chuẩn có complexity (O(n^2d)) theo sequence length.

Layer	Complexity mỗi layer	Sequential operations	Max path giữa hai token
Self-Attention	(O(n^2d))	(O(1))	(O(1))
Recurrent	(O(nd^2))	(O(n))	(O(n))

Đây là một trade-off cực kỳ quan trọng.

Transformer không làm computation “miễn phí”.

Nó đổi:

dependency tuần tự

lấy:

một ma trận tương tác toàn cục giữa các token.

Và chính ma trận đó dẫn chúng ta tới Attention.

2. Attention nên được hiểu như một hệ thống truy xuất mềm

Trước khi nhìn vào matrix multiplication, hãy bỏ toán sang một bên.

Giả sử bạn vào một thư viện và hỏi:

“Tôi cần tài liệu về distributed systems.”

Bạn không mở từng cuốn sách rồi đọc toàn bộ nội dung.

Bạn trước tiên nhìn vào những thông tin giúp xác định cuốn nào có khả năng liên quan:

Distributed Systems
Designing Data-Intensive Applications
Computer Networking
Operating Systems
Cooking with Python
...

Ta có thể xây một mental model:

Query
"Tôi đang tìm gì?"
        │
        ▼
   so khớp với
        │
        ▼
Keys
"Thông tin nào mô tả thứ tôi có?"
        │
        ▼
chọn / đánh trọng số
        │
        ▼
Values
"Nội dung thực sự cần lấy"

Attention chính thức cũng được định nghĩa theo cách rất giống vậy: một query được so với tập key-value pairs; compatibility giữa query và từng key quyết định trọng số dùng để tổng hợp các value.

Query — thứ token đang tìm kiếm

Query (Q) có thể được hình dung như tín hiệu:

“Đối với việc xây dựng representation hiện tại của tôi, loại thông tin nào từ các token khác có ích?”

Key — thứ dùng để được tìm thấy

Key (K) giống như phần biểu diễn được dùng để trả lời:

“Token này có phù hợp với query đó không?”

Value — thông tin thực sự được truyền đi

Nếu Query và Key tương thích, Value (V) mới là thông tin được đưa vào output.

Mental model:

              similarity
Query ─────────────────────────► Key
                                  │
                                  │ weight
                                  ▼
                                Value
                                  │
                                  ▼
                             output token

Điều này cũng giải thích vì sao cần tách Key và Value.

Thông tin dùng để quyết định:

“Có nên lấy dữ liệu này không?”

không nhất thiết phải giống hoàn toàn thông tin:

“Nếu lấy thì lấy cái gì?”

Đây là pattern quen thuộc trong information retrieval.

Một search engine có thể dùng một representation để ranking tài liệu, nhưng tài liệu cuối cùng mà người dùng nhận được chứa lượng thông tin phong phú hơn nhiều so với representation dùng để ranking.

Nhưng đừng hiểu analogy quá literal

Có một nuance cực kỳ quan trọng.

Q, K và V không chứa những câu hỏi bằng tiếng người.

Transformer không có một field như:

{
  "query": "Tìm chủ ngữ của đại từ này"
}

Q, K và V chỉ là những vector số học được học thông qua optimization.

Mental model:

Q = what I'm looking for
K = what I match against
V = what I retrieve

rất hữu ích để hiểu mechanism.

Nhưng trong model thật, ý nghĩa của từng chiều trong các vector đó không được programmer viết tay.

3. Q, K và V thực sự được tạo ra như thế nào?

Giả sử câu sau đã được tokenize:

The animal crossed the road

Và sau embedding cùng positional information, mỗi token được biểu diễn bằng một vector có d_model chiều.

Ta gom tất cả token thành matrix:

X \in ℝ^{n \times d_{m o d e l}}

Trong đó:

n       = số token
d_model = kích thước hidden representation

Ví dụ:

5 tokens
d_model = 512

X.shape = (5, 512)

Transformer không dùng trực tiếp X làm Query, Key và Value.

Nó học ba phép linear projection:

Q = X W_{Q}

K = X W_{K}

V = X W_{V}

Nếu đơn giản hóa:

                 ┌── WQ ──► Q
                 │
Input X ─────────┼── WK ──► K
                 │
                 └── WV ──► V

Các matrix (W_Q), (W_K) và (W_V) là learnable parameters.

Không ai thiết kế thủ công:

dimension 17 = subject
dimension 42 = sentiment
dimension 103 = singular noun

Ban đầu các trọng số chưa mang những cấu trúc hữu ích như vậy. Qua training, gradient descent điều chỉnh chúng để những phép projection tạo ra representation hữu ích cho objective mà model đang tối ưu.

Đó là khác biệt giữa một thuật toán search truyền thống và attention học được.

Trong SQL, developer định nghĩa trước:

WHERE user_id = 123

Trong Transformer, chính không gian dùng để matching cũng được học từ dữ liệu.

4. Self-Attention: từ một câu thành ma trận quan hệ

Bây giờ ta đã có:

Q
K
V

Bước tiếp theo là hỏi:

Query của mỗi token phù hợp với Key của token nào?

Transformer gốc sử dụng Scaled Dot-Product Attention:

A t t e n t i o n (Q, K, V) = s o f t m a x (\frac{Q K^{T}}{\sqrt{d_{k}}}) V

Công thức nhìn có vẻ dày đặc.

Nhưng thực chất nó chỉ gồm bốn bước.

Bước 1: tính similarity score

Ta lấy:

Q K^{T}

Nếu:

Q.shape = (n, d_k)
K.shape = (n, d_k)

thì:

K.T.shape = (d_k, n)

Q @ K.T → (n, n)

Kết quả là một matrix:

                 Key
            The animal crossed road
Query The     •    •      •      •
      animal  •    •      •      •
      crossed •    •      •      •
      road    •    •      •      •

Mỗi cell trả lời:

Query của token ở hàng này tương thích bao nhiêu với Key của token ở cột này?

Đây là một trong những insight quan trọng nhất để hiểu Transformer:

Self-Attention biến một sequence thành một matrix quan hệ giữa tất cả các vị trí.

Nếu có 1.000 token:

attention matrix = 1000 × 1000

Nếu có 10.000 token:

attention matrix = 10,000 × 10,000

Đó cũng chính là nguồn gốc của quadratic cost của vanilla self-attention.

Dot product không phải cosine similarity

Một lỗi giải thích phổ biến là nói:

“Transformer dùng cosine similarity giữa Query và Key.”

Không chính xác.

Transformer gốc dùng dot product:

q \cdot k

Cosine similarity là:

\cos (θ) = \frac{q \cdot k}{| q | | k |}

Hai phép đo liên quan nhưng không giống nhau, vì dot product còn phụ thuộc vào magnitude của vector.

Bước 2: tại sao phải chia cho (\sqrt{d_k})?

Sau khi tính dot product:

Q K^{T}

Transformer chia score cho:

\sqrt{d_{k}}

Tại sao?

Giả sử các thành phần của q và k có mean gần 0, variance gần 1.

Dot product là:

q \cdot k = \sum_{i = 1}^{d_{k}} q_{i} k_{i}

Khi d_k lớn, tổng này có xu hướng có magnitude lớn hơn.

Nếu đưa những score rất lớn vào softmax, softmax có thể trở nên cực kỳ “sắc”:

scores:
[1, 2, 20]

softmax:
[~0, ~0, ~1]

Khi đó gradient ở nhiều vị trí trở nên rất nhỏ, khiến optimization khó hơn.

Transformer gốc vì thế scale score bằng:

\frac{1}{\sqrt{d_{k}}}

Các tác giả giải thích rằng nếu các component độc lập có mean 0 và variance 1, variance của dot product sẽ tăng theo (d_k); scaling này giúp tránh việc dot products có magnitude quá lớn trước softmax.

Bước 3: Softmax biến score thành attention weights

Ta có:

S = \frac{Q K^{T}}{\sqrt{d_{k}}}

Sau đó:

A = s o f t m a x (S)

Softmax được áp dụng theo từng hàng.

Ví dụ:

Raw scores:

            animal   street   tired
it            3.1      0.2     1.4

Sau softmax, có thể trở thành:

            animal   street   tired
it           0.78      0.04     0.18

Tổng:

0.78 + 0.04 + 0.18 = 1

Nhưng cần cẩn thận với cách gọi.

Những số này thường được diễn giải như “78% attention”, nhưng chúng không nhất thiết là probability đã được calibration theo nghĩa thống kê.

Chính xác hơn, chúng là normalized attention weights.

Bước 4: dùng weights để trộn Values

Cuối cùng:

O = A V

Với token it:

o_{i t} = 0.78 v_{a n i m a l} + 0.04 v_{s t r e e t} + 0.18 v_{t i r e d}

Output không nhất thiết copy nguyên một token.

Nó là weighted combination của nhiều Value vectors.

Đây là khác biệt cốt lõi giữa attention và lookup cứng kiểu database.

SQL có thể gần giống:

match
↓
return row

Attention giống:

score every candidate
↓
normalize scores
↓
blend information from candidates

Toàn bộ pipeline:

Input X
  │
  ├────────► Q = XWQ
  │
  ├────────► K = XWK
  │
  └────────► V = XWV
                │
                ▼
           Q × Kᵀ
                │
                ▼
             / √dₖ
                │
                ▼
             Softmax
                │
                ▼
      Attention Weights
                │
                ▼
           Weights × V
                │
                ▼
          Contextual Output

Một implementation tối giản gần như đúng theo công thức:

scores = Q @ K.transpose(-2, -1)
scores = scores / sqrt(d_k)

scores = scores + mask  # nếu cần causal/padding mask

weights = softmax(scores, dim=-1)
output = weights @ V

Đằng sau hàng loạt Transformer framework phức tạp, phần lõi của attention thực sự xoay quanh vài phép toán như vậy.

5. Self-Attention làm từ ngữ trở nên contextual như thế nào?

Đây mới là nơi attention trở nên đặc biệt với language modeling.

Hãy xét:

I deposited money in the bank.

và:

We sat on the river bank.

Một lexical embedding tĩnh cho từ bank không thể tự mình biểu diễn đầy đủ hai nghĩa này.

Trong Transformer, representation của một token được cập nhật qua nhiều layer.

Ở câu thứ nhất, bank có cơ hội tương tác với:

deposited
money

Ở câu thứ hai:

river
sat

Sau attention, representation của bank trong hai context có thể trở nên rất khác nhau.

Ta có thể hình dung:

Initial representation

bank
 │
 │ Self-Attention
 │
 ├──── money
 ├──── deposited
 │
 ▼
bank₁ = financial context

trong khi:

bank
 │
 │ Self-Attention
 │
 ├──── river
 ├──── sat
 │
 ▼
bank₂ = river-side context

Đây là lý do Transformer tạo ra contextual representations.

BERT sau này khai thác Transformer encoder để xây dựng deep bidirectional contextual representations bằng cách cho mỗi vị trí condition trên cả context bên trái và bên phải trong các layer encoder.

Quay lại ví dụ “it”

Ta có:

The animal didn't cross the street
because it was too tired.

Một cách giải thích quá mức thường nói rằng Query của it trực tiếp mang câu hỏi:

“Tôi đang tìm một sinh vật có khả năng bị mệt.”

Không nên hiểu cơ chế literal như vậy.

Ở layer đầu tiên, Query của it được tạo từ hidden representation hiện có của vị trí đó. Qua các layer liên tiếp, các representation tiếp tục được contextualize:

Layer 1
token relationships cơ bản
       │
       ▼
Layer 2
context phong phú hơn
       │
       ▼
Layer 3
kết hợp thêm dependencies
       │
       ▼
...
       │
       ▼
Layer N
high-level contextual representation

Một layer/head có thể liên kết it với animal; một layer khác có thể giúp representation của tired liên kết với chủ thể; những signal đó tiếp tục được kết hợp ở các layer phía trên.

Điểm quan trọng không phải:

“Attention thực hiện một rule coreference viết sẵn.”

Mà là:

Kiến trúc cung cấp cho model một đường truyền trực tiếp để những vị trí xa nhau trao đổi thông tin, còn những pattern hữu ích được học end-to-end từ dữ liệu.

Đây là một khác biệt nhỏ trong cách diễn đạt nhưng rất lớn về mặt hiểu biết.

6. Vì sao cần Multi-Head Attention?

Nếu một attention matrix đã cho token nhìn thấy toàn bộ sequence, tại sao còn cần nhiều head?

Giả sử ta chỉ có một attention operation.

Mỗi token cuối cùng nhận một weighted sum:

o_{i} = \sum_{j} a_{i j} v_{j}

Nhưng ngôn ngữ có nhiều loại quan hệ xảy ra đồng thời:

Ai thực hiện hành động?
Đối tượng của động từ là gì?
Đại từ tham chiếu tới đâu?
Modifier đang bổ nghĩa cho token nào?
Thông tin nào nằm ở vị trí gần?
Thông tin nào liên quan về semantic?

Một attention projection duy nhất phải nén tất cả những tín hiệu này vào cùng một representation space.

Multi-Head Attention cho model nhiều projection khác nhau.

Transformer gốc định nghĩa:

h e a d_{i} = A t t e n t i o n (Q W_{i}^{Q}, K W_{i}^{K}, V W_{i}^{V})

Sau đó:

M u l t i H e a d (Q, K, V) = C o n c a t (h e a d_{1}, \dots, h e a d_{h}) W^{O}

Flow:

                  ┌─ Projection 1 ─ Attention ─ Head 1 ─┐
                  │                                     │
Q, K, V ──────────┼─ Projection 2 ─ Attention ─ Head 2 ─┤
                  │                                     ├─ Concat ─ WO ─ Output
                  ├─ Projection 3 ─ Attention ─ Head 3 ─┤
                  │                                     │
                  └─ Projection h ─ Attention ─ Head h ─┘

Trong Transformer base gốc:

d_model = 512
heads   = 8

d_k = d_v = 64

Mỗi head dùng các learned linear projections khác nhau; output các head sau đó được concatenate và project lại qua (W^O).

Không phải “cắt vector thành 8 mảnh rồi mỗi mảnh có nhiệm vụ cố định”

Một implementation tối ưu có thể tạo Q/K/V trong một matrix multiplication lớn rồi reshape tensor thành nhiều head.

Nhưng về mặt toán học, điều quan trọng là:

Mỗi head có projection parameters riêng.

Không nên hình dung model đơn giản lấy:

dimension 0–63   → head 1
dimension 64–127 → head 2
...

rồi giữ nguyên semantics của từng đoạn.

Các projection học những representation subspace mới.

Head có phải “chuyên gia syntax”, “chuyên gia sentiment” không?

Đó là analogy hữu ích, nhưng không phải architecture contract.

Ta không cấu hình:

head_1.role = "syntax"
head_2.role = "coreference"
head_3.role = "sentiment"

Các tác giả Transformer quan sát thấy một số attention head biểu hiện những pattern liên quan tới cấu trúc syntactic và semantic, nhưng chức năng của head xuất hiện từ learning chứ không được gán trước.

💡 Mental model

Hãy nghĩ Multi-Head Attention như việc model được phép tạo ra nhiều hệ tọa độ khác nhau để hỏi “token nào liên quan tới token nào?”, thay vì ép mọi quan hệ vào duy nhất một hệ tọa độ.

Đó là cách hiểu chính xác hơn việc tưởng tượng mỗi head là một module NLP viết sẵn.

7. Attention chưa phải Transformer: một Transformer block còn nhiều thứ khác

Một misunderstanding phổ biến là:

Transformer = Attention

Không hoàn toàn.

Attention là thành phần trung tâm, nhưng một Transformer layer còn có:

Multi-Head Attention;
Feed-Forward Network;
residual connections;
Layer Normalization;
positional information.

Trong encoder của Transformer gốc:

Input
  │
  ▼
Multi-Head Self-Attention
  │
  ├──────── Residual
  ▼
Add + LayerNorm
  │
  ▼
Feed-Forward Network
  │
  ├──────── Residual
  ▼
Add + LayerNorm
  │
  ▼
Output

Transformer base gốc dùng stack 6 encoder layers và 6 decoder layers, với (d_{model}=512); encoder layer gồm self-attention và position-wise FFN, còn decoder bổ sung một encoder-decoder attention sub-layer.

Attention giao tiếp; FFN xử lý

Một mental model hữu ích là:

Attention
= lấy thông tin từ các token khác

FFN
= xử lý representation của token sau khi đã nhận thông tin

Position-wise Feed-Forward Network của Transformer gốc là:

F F N (x) = m a x (0, x W_{1} + b_{1}) W_{2} + b_{2}

Quan trọng là cùng một FFN được áp dụng độc lập tại từng position, với cùng parameters trong một layer. Transformer base dùng hidden dimension 2048 bên trong FFN rồi project trở lại dimension 512.

Ta có thể hình dung:

Attention:
token ↔ token ↔ token ↔ token

FFN:
token → transform
token → transform
token → transform
token → transform

Attention mixes information across sequence positions.

FFN mixes and transforms feature dimensions bên trong từng position.

Hai phép toán giải quyết hai loại computation khác nhau.

Residual Connection: đừng bắt mỗi layer xây lại representation từ đầu

Thay vì:

y = S u b l a y e r (x)

Transformer sử dụng residual path:

x + S u b l a y e r (x)

Trong architecture gốc:

L a y e r N o r m (x + S u b l a y e r (x))

Residual connections trước đó đã chứng minh giá trị trong việc làm các deep network dễ optimize hơn; Transformer áp dụng chúng quanh các attention và FFN sub-layer.

Mental model:

                 ┌───────────────┐
x ───────────────┤               + ──► output
│                │               ▲
└─► Sublayer ────┘               │

Layer không cần thay thế toàn bộ representation.

Nó có thể học:

“Tôi chỉ cần thêm correction này vào signal hiện tại.”

Điều này đặc biệt quan trọng khi ta stack rất nhiều transformations.

LayerNorm: giữ activation có scale dễ kiểm soát

Layer Normalization tính normalization statistics trên các activation trong một layer cho từng sample thay vì phụ thuộc vào mini-batch như BatchNorm. Nó sau đó còn có learnable gain và bias.

Do đó, câu:

“LayerNorm luôn biến output thành mean 0, variance 1.”

chỉ đúng với bước normalization trung gian.

Sau learned affine transformation:

y = γ \hat{x} + β

output cuối cùng không bắt buộc giữ mean 0 và variance 1.

🔬 Deep Dive — Post-LN của Transformer gốc

Transformer năm 2017 sử dụng:

L a y e r N o r m (x + S u b l a y e r (x))

thường được gọi là Post-LN.

Nhiều Transformer architecture về sau thay đổi vị trí normalization, nhưng đó là một chủ đề optimization riêng. Điều quan trọng khi học architecture gốc là đừng vô tình nhìn một diagram hiện đại rồi nghĩ nó hoàn toàn giống thiết kế năm 2017.

8. Nếu attention nhìn tất cả token cùng lúc, model biết thứ tự từ bằng cách nào?

Đây là vấn đề rất dễ bỏ qua.

Self-attention tự nó không có recurrence.

Xét:

Dog bites man

và:

Man bites dog

Token set gần như giống nhau.

Nhưng nghĩa thì hoàn toàn khác.

Nếu model chỉ nhận token embeddings:

dog
bites
man

mà không có thông tin về position, permutation của input sẽ trở thành vấn đề lớn.

Transformer vì thế cần đưa positional information vào representation.

Trong paper gốc:

I n p u t R e p r e s e n t a t i o n = T o k e n E m b e d d i n g + P o s i t i o n a l E n c o d i n g

Diagram:

Token embedding ───────┐
                       ├── + ──► Transformer
Position encoding ─────┘

Transformer năm 2017 sử dụng sinusoidal positional encoding:

P E_{(p o s, 2 i)} = \sin (\frac{p o s}{10000^{2 i / d_{m o d e l}}})

P E_{(p o s, 2 i + 1)} = \cos (\frac{p o s}{10000^{2 i / d_{m o d e l}}})

Mỗi dimension dùng sinusoid với frequency khác nhau. Các tác giả lựa chọn cách này vì họ giả thuyết nó giúp model dễ học quan hệ vị trí tương đối; họ cũng nhận thấy learned positional embeddings cho kết quả gần tương đương trong thí nghiệm của paper và cho rằng sinusoidal encoding có thể hỗ trợ extrapolation sang sequence dài hơn training data.

Từ “có thể” ở đây quan trọng.

Không nên nâng giả thuyết đó thành:

“Sinusoidal encoding bảo đảm Transformer tổng quát hóa hoàn hảo tới sequence dài tùy ý.”

Nó không bảo đảm điều đó.

🏗️ Engineering takeaway

Attention trả lời:

Token nào liên quan?

Positional mechanism bổ sung:

Token đó nằm ở đâu?

Hai loại thông tin cùng cần thiết để model hiểu sequence.

9. Encoder, Decoder và ba loại Attention rất dễ bị trộn lẫn

Transformer gốc là kiến trúc encoder-decoder cho sequence transduction, đặc biệt là machine translation.

Toàn bộ system có thể hình dung như sau:

Source tokens
     │
     ▼
┌───────────────┐
│    Encoder    │
│               │
│ Self-Attention│
│      + FFN    │
└───────┬───────┘
        │
   K,V │
        │
        ▼
┌───────────────┐
│    Decoder    │
│               │
│Masked Self-Att│
│       ↓       │
│ Cross-Attn ◄──┘
│       ↓
│      FFN
└───────┬───────┘
        │
        ▼
   Next-token distribution

Có ba attention pattern cần phân biệt.

9.1 Encoder Self-Attention

Trong encoder:

Q ← encoder states
K ← encoder states
V ← encoder states

Tất cả xuất phát từ cùng sequence.

Một position có thể attend tới mọi position khác.

token 1 ↔ token 2 ↔ token 3 ↔ token 4

Không có causal restriction.

Điều này phù hợp với nhiệm vụ xây representation của một input đã biết đầy đủ.

9.2 Decoder Masked Self-Attention

Decoder dùng autoregressive factorization:

P (y) = \prod_{t} P (y_{t} | y_{< t})

Khi dự đoán token ở position t, model không được nhìn thấy các future token.

Attention matrix bình thường:

      k1 k2 k3 k4
q1     ✓  ✓  ✓  ✓
q2     ✓  ✓  ✓  ✓
q3     ✓  ✓  ✓  ✓
q4     ✓  ✓  ✓  ✓

Causal attention:

      k1 k2 k3 k4
q1     ✓  ✗  ✗  ✗
q2     ✓  ✓  ✗  ✗
q3     ✓  ✓  ✓  ✗
q4     ✓  ✓  ✓  ✓

Transformer thực hiện việc này bằng cách đặt score của các connection không hợp lệ thành:

- \infty

trước softmax.

Bởi:

e^{- \infty} = 0

những vị trí đó nhận attention weight bằng 0. Đây chính là masking mechanism được mô tả trong Transformer gốc.

9.3 Cross-Attention

Ở encoder-decoder attention:

Q ← Decoder

K ← Encoder
V ← Encoder

Đây là trường hợp làm ý nghĩa Query-Key-Value trở nên trực quan nhất.

Decoder đang ở trạng thái:

“Dựa trên những gì tôi đã generate, phần nào của input source hữu ích tiếp theo?”

Query đến từ decoder.

Encoder cung cấp Key để matching và Value để retrieval. Transformer gốc mô tả chính xác pattern này: decoder queries attend lên encoder memory keys và values.

Ví dụ machine translation:

English input
"The cat sleeps"

      │ encoder
      ▼

context representations
      │
      │ cross-attention
      ▼

decoder:
"Con mèo ..."

Khi cần sinh phần tiếp theo, decoder có thể retrieve signal liên quan từ encoded source.

10. Một nuance cực quan trọng: training có thể song song, generation thì không hoàn toàn

Người mới thường nghe:

“Transformer không xử lý tuần tự.”

Rồi sau đó thắc mắc:

“Vậy tại sao LLM vẫn generate token từng token?”

Cả hai đều đúng vì đang nói về hai giai đoạn khác nhau.

Training decoder

Giả sử target là:

I love machine learning

Ta có thể đưa cả target đã shift vào model trong training:

Input:
<BOS> I love machine

Predict:
I     love machine learning

Vì ground-truth target đã có sẵn, causal mask đảm bảo mỗi position chỉ sử dụng past context hợp lệ.

GPU vẫn có thể tính attention cho nhiều target positions trong một forward pass.

Training:

position 1 ┐
position 2 ├── computed together
position 3 │
position 4 ┘

Đó là lợi thế parallelization lớn so với recurrent computation. Transformer paper nhấn mạnh chính khả năng giảm sequential operations trong training.

Autoregressive inference

Khi model thực sự generate:

Prompt
  │
  ▼
token 1
  │
  ▼
token 2
  │
  ▼
token 3

token 3 chưa tồn tại trước khi token 2 được chọn.

Vì thế decoding vẫn có dependency:

y_{t} \to y_{t + 1}

Transformer loại bỏ recurrence bên trong representation computation của layer, nhưng autoregressive generation vẫn là một sequential process ở cấp token generation.

⚠️ Cẩn thận

“Transformer parallelizable” không đồng nghĩa:

“LLM có thể generate toàn bộ câu trả lời cùng lúc.”

Đó là hai claim hoàn toàn khác nhau.

11. Từ Transformer gốc tới BERT, GPT và T5

Khi hiểu ba attention pattern phía trên, ba nhánh Transformer lớn trở nên dễ hiểu hơn rất nhiều.

Architecture	Attention chính	Nhìn future context?	Điểm mạnh điển hình
Encoder-only	Bidirectional self-attention	Có	Understanding / representation
Decoder-only	Causal self-attention	Không	Autoregressive generation
Encoder-decoder	Encoder + causal decoder + cross-attention	Tùy block	Sequence-to-sequence

Encoder-only: BERT

BERT sử dụng Transformer encoder và xây deep bidirectional representations, cho phép token condition trên cả context trái và phải.

Mental model:

past ◄── token ──► future

Điều đó phù hợp với những bài toán cần representation của một input đã biết đầy đủ.

Decoder-only: GPT-style language model

Autoregressive language model giữ causal constraint:

token₁
  ↓
token₂
  ↓
token₃
  ↓
token₄

Những model như GPT-3 scale autoregressive language modeling lên quy mô rất lớn và cho thấy mạnh mẽ khả năng few-shot/in-context behavior từ text interaction mà không cần gradient update cho từng task tại inference.

Điểm quan trọng về architecture không phải là:

“Decoder thông minh hơn Encoder.”

Mà là training objective và information flow khác nhau.

Encoder-decoder: T5

T5 giữ cấu trúc encoder-decoder và đưa nhiều NLP task về chung một text-to-text framework.

Mental model:

Input text
   │
Encoder
   │
representation
   │
Cross-Attention
   │
Decoder
   │
Output text

Cấu trúc này tự nhiên cho các transformation task có input và output rõ ràng.

Transformer không bị giới hạn ở text

Một insight sâu hơn là Attention không hề yêu cầu input phải là “word”.

Nó chỉ cần sequence hoặc tập representation.

Vision Transformer cho thấy image có thể được chia thành patches, project thành sequence representations rồi xử lý bằng Transformer; paper ViT báo cáo rằng pure Transformer trên image patches có thể đạt kết quả rất mạnh khi pre-train ở scale đủ lớn.

Image
 │
 ▼
┌──┬──┬──┬──┐
│P1│P2│P3│P4│
├──┼──┼──┼──┤
│P5│P6│P7│P8│
└──┴──┴──┴──┘
 │
 ▼
Patch embeddings
 │
 ▼
Transformer

Điều này cho thấy thứ Transformer thực sự xử lý không phải “ngôn ngữ”.

Nó xử lý relationships giữa learned representations.

12. Transformer giải quyết vấn đề gì — và không giải quyết vấn đề gì?

Sau khi hiểu architecture, rất dễ rơi vào thái cực ngược lại và xem Transformer như một mechanism hoàn hảo.

Không phải vậy.

Nó đơn giản thay đổi tập trade-off.

1. Global attention giúp dependency ngắn đường truyền, nhưng tốn quadratic cost

Vanilla attention tạo:

n \times n

attention scores.

Vì thế complexity mỗi layer chứa term:

O (n^{2} d)

theo phân tích của Transformer paper.

Khi sequence tăng gấp đôi:

n → 2n

số pairwise interactions tăng xấp xỉ:

n² → 4n²

Đây là lý do long-context attention trở thành một engineering problem lớn.

Transformer không loại bỏ computation cost.

Nó chuyển cost sang một dạng rất phù hợp với matrix hardware, nhưng có scaling problem riêng.

2. Attention không tự biết order

Không có positional information, self-attention không tự nhiên chứa đầy đủ notion về thứ tự sequence.

Transformer cần position mechanism riêng. Paper gốc giải quyết bằng positional encoding.

3. Attention weights không nên được đọc như lời giải thích hoàn hảo về “suy nghĩ”

Một attention matrix rất trực quan:

it ─────────► animal

Nhưng hidden computation của Transformer trải qua:

nhiều heads
× nhiều layers
+ residual paths
+ FFNs
+ nonlinear transformations

Vì vậy một attention map có thể hữu ích để inspection, nhưng không nên giản lược toàn bộ reasoning của model thành:

“Model chọn token X vì attention weight của X cao nhất.”

Attention chỉ là một phần trong computation graph.

4. Multi-head không bảo đảm mỗi head học một chức năng đẹp đẽ

Một số head có thể phát triển pattern rất interpretable.

Một số có thể redundant.

Một số có behavior khó gán semantic label.

Multi-head cung cấp capacity và representation subspaces; nó không cung cấp taxonomy về grammar.

5. Transformer không loại bỏ tuần tự khỏi autoregressive generation

Training representation có thể parallelize mạnh.

Nhưng nếu objective là:

P (x_{t} | x_{< t})

thì generation vẫn cần previous output.

Vì vậy latency của LLM inference là một systems problem khác với Transformer training parallelism.

13. Mental model hoàn chỉnh của Transformer

Sau tất cả công thức, có thể nén architecture về một quá trình tương đối đơn giản.

Bước 1 — biến token thành vector

Tokens
  │
  ▼
Embeddings

Bước 2 — bổ sung thông tin vị trí

Embedding
    +
Position
    │
    ▼
Initial representation

Bước 3 — tạo Q, K, V

X
├─► Q
├─► K
└─► V

Bước 4 — mỗi token tìm những token liên quan

Q × Kᵀ
   │
   ▼
Attention scores

Bước 5 — normalize relevance

scores
  │
 /√dₖ
  │
softmax
  ▼
weights

Bước 6 — lấy và trộn thông tin

weights × V
      │
      ▼
contextual representation

Bước 7 — làm việc đó từ nhiều representation subspaces

Head 1 ─┐
Head 2 ─┤
Head 3 ─┼─► Concatenate ─► Projection
...     │
Head h ─┘

Bước 8 — xử lý representation cục bộ

Attention output
      │
      ▼
     FFN

Bước 9 — giữ signal ổn định qua mạng sâu

Residual + LayerNorm

Bước 10 — lặp lại nhiều layer

Layer 1
  ↓
Layer 2
  ↓
Layer 3
  ↓
...
  ↓
Layer N

Đến đây, câu:

“Transformer dùng Attention”

không còn là một slogan mơ hồ nữa.

Ta có thể nhìn thấy chính xác data đang đi đâu.

14. Điều thực sự mang tính cách mạng của Transformer

Quay lại câu mở đầu:

The animal didn't cross the street because it was too tired.

Cách hiểu quan trọng nhất không phải rằng Transformer sở hữu một rule:

if pronoun == "it":
    find nearest living noun

Nó cũng không có database chứa những relation được programmer định nghĩa trước.

Thay vào đó, Transformer tạo ra một computation architecture trong đó:

mỗi position
      │
      ▼
có thể tạo Query
      │
      ▼
đánh giá Keys của nhiều position khác
      │
      ▼
lấy weighted combination của Values
      │
      ▼
xây representation mới

Và quá trình này được lặp lại:

qua nhiều heads
× nhiều layers
× lượng dữ liệu training rất lớn

Các pattern về syntax, reference, semantic similarity hay những cấu trúc phức tạp hơn có thể xuất hiện từ optimization thay vì phải được lập trình như hàng nghìn rule NLP thủ công.

Đó là phần sâu sắc nhất của Transformer.

Nó không chỉ thay:

RNN

bằng:

Attention

Nó thay đổi cách ta tổ chức computation cho sequence.

RNN chủ yếu truyền state:

token → token → token → token

Transformer tạo interaction:

token ─┬─ token
       ├─ token
       ├─ token
       └─ token

Sự thay đổi đó đồng thời tạo ra hai khả năng rất quan trọng: dependencies xa có đường truyền ngắn hơn qua network, và computation trên các positions trong một training sequence có thể được biểu diễn thành những matrix operations phù hợp hơn với phần cứng song song. Đây là hai trong những động lực trung tâm mà Attention Is All You Need đưa ra cho kiến trúc mới.

Nhưng Transformer không phải phép màu.

Attention toàn cục trả giá bằng quadratic interaction cost. Positional information phải được bổ sung riêng. Causal language generation vẫn tuần tự ở inference. Attention maps không phải bản ghi hoàn chỉnh về reasoning.

Hiểu những giới hạn đó cũng quan trọng không kém việc hiểu điểm mạnh.

Nếu chỉ cần giữ lại bốn ý sau bài này, hãy giữ bốn ý này:

Self-Attention là cơ chế routing và mixing information giữa các token, không đơn giản là “model tập trung vào một từ”.
Q và K quyết định mức độ compatibility; V là information được tổng hợp vào output.
Multi-Head Attention cho model nhiều learned representation subspaces, chứ không phải một danh sách chuyên gia NLP có nhiệm vụ được định sẵn.
Transformer là cả một block architecture gồm Attention, FFN, positional information, residual paths và normalization — Attention là trái tim, nhưng không phải toàn bộ cơ thể.

Khi mental model này đã chắc, rất nhiều khái niệm tưởng như độc lập trong AI hiện đại — causal attention, context window, KV cache, decoder-only LLM, cross-attention, Vision Transformer hay những kỹ thuật tối ưu attention — bắt đầu trở thành các biến thể tự nhiên của cùng một nền tảng, thay vì một tập hợp buzzword phải học thuộc.

Nguồn tham khảo

Vaswani et al. — Attention Is All You Need.
Bahdanau, Cho & Bengio — Neural Machine Translation by Jointly Learning to Align and Translate.
He et al. — Deep Residual Learning for Image Recognition.
Ba, Kiros & Hinton — Layer Normalization.
Devlin et al. — BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding.
Brown et al. — Language Models are Few-Shot Learners.
Raffel et al. — Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer.
Dosovitskiy et al. — An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale.

Chia sẻX LinkedIn

1. Vấn đề trước Transformer không đơn giản là “RNN hay quên”

2. Attention nên được hiểu như một hệ thống truy xuất mềm

Query — thứ token đang tìm kiếm

Key — thứ dùng để được tìm thấy

Value — thông tin thực sự được truyền đi

Nhưng đừng hiểu analogy quá literal

3. Q, K và V thực sự được tạo ra như thế nào?

4. Self-Attention: từ một câu thành ma trận quan hệ

Bước 1: tính similarity score

Dot product không phải cosine similarity

Bước 2: tại sao phải chia cho (\sqrt{d_k})?

Bước 3: Softmax biến score thành attention weights

Bước 4: dùng weights để trộn Values

5. Self-Attention làm từ ngữ trở nên contextual như thế nào?

Quay lại ví dụ “it”

6. Vì sao cần Multi-Head Attention?

Không phải “cắt vector thành 8 mảnh rồi mỗi mảnh có nhiệm vụ cố định”

Head có phải “chuyên gia syntax”, “chuyên gia sentiment” không?

7. Attention chưa phải Transformer: một Transformer block còn nhiều thứ khác

Attention giao tiếp; FFN xử lý

Residual Connection: đừng bắt mỗi layer xây lại representation từ đầu

LayerNorm: giữ activation có scale dễ kiểm soát

8. Nếu attention nhìn tất cả token cùng lúc, model biết thứ tự từ bằng cách nào?

9. Encoder, Decoder và ba loại Attention rất dễ bị trộn lẫn

9.1 Encoder Self-Attention

9.2 Decoder Masked Self-Attention

9.3 Cross-Attention

10. Một nuance cực quan trọng: training có thể song song, generation thì không hoàn toàn

Training decoder

Autoregressive inference

11. Từ Transformer gốc tới BERT, GPT và T5

Encoder-only: BERT

Decoder-only: GPT-style language model

Encoder-decoder: T5

Transformer không bị giới hạn ở text

12. Transformer giải quyết vấn đề gì — và không giải quyết vấn đề gì?

1. Global attention giúp dependency ngắn đường truyền, nhưng tốn quadratic cost

2. Attention không tự biết order

3. Attention weights không nên được đọc như lời giải thích hoàn hảo về “suy nghĩ”

4. Multi-head không bảo đảm mỗi head học một chức năng đẹp đẽ

5. Transformer không loại bỏ tuần tự khỏi autoregressive generation

13. Mental model hoàn chỉnh của Transformer

Bước 1 — biến token thành vector

Bước 2 — bổ sung thông tin vị trí

Bước 3 — tạo Q, K, V

Bước 4 — mỗi token tìm những token liên quan

Bước 5 — normalize relevance

Bước 6 — lấy và trộn thông tin

Bước 7 — làm việc đó từ nhiều representation subspaces

Bước 8 — xử lý representation cục bộ

Bước 9 — giữ signal ổn định qua mạng sâu

Bước 10 — lặp lại nhiều layer

14. Điều thực sự mang tính cách mạng của Transformer

Nguồn tham khảo

Bài viết liên quan

Rate Limit, Retry và Exponential Backoff trong LLM API: Thiết kế để 429 không biến thành sự cố dây chuyền

LLM Inference Thực Sự Hoạt Động Như Thế Nào? Từ Prompt Đến Prefill, Decode Và KV Cache

Temperature, Top-p và Sampling: Vì Sao Cùng Một Prompt AI Có Thể Trả Lời Khác Nhau?