Bài 8: Trước Transformer — vì sao RNN không đủ

Bài 1-7 (Module 1 — Foundation LLM) đã trả lời câu hỏi LLM dùng gì làm input: token, vocabulary, embedding, context window. Module 2 chuyển sang câu hỏi LLM xử lý input như thế nào — tức là kiến trúc bên trong model.

Sau bài này, bạn cần trả lời được:

• Trước Transformer, sequence model dùng kiến trúc nào (RNN / LSTM / GRU / seq2seq).
• Ba vấn đề khiến RNN không đủ cho language modeling quy mô lớn.
• Vai trò của attention Bahdanau 2014 — và tại sao nó "chưa đủ".
• Vaswani et al. 2017 đề xuất gì khác biệt và đánh đổi gì.
• Tổng quan kiến trúc Transformer, 3 biến thể chính (encoder-only / decoder-only / encoder-decoder).

Bài này thiên về motivation và bối cảnh. Các bài 9-13 sẽ đi vào chi tiết công thức của attention, self-attention, multi-head, positional encoding và block Transformer hoàn chỉnh.

Từ khoảng 2013 đến 2017, state-of-art cho mọi task NLP có yếu tố sequence là một nhánh của recurrent neural network (RNN):

• Vanilla RNN (Elman 1990) — hidden state \( h_t = \sigma(W_x x_t + W_h h_{t-1} + b) \). Khó train vì vanishing / exploding gradient.
• LSTM (Hochreiter & Schmidhuber 1997) — thêm gate (input / forget / output) và cell state \( c_t \) để giữ thông tin dài hạn. Phổ biến sau 2013 khi GPU đủ rẻ.
• GRU (Cho et al. 2014) — đơn giản hóa LSTM, ít gate hơn, hiệu năng tương đương trên nhiều task.

Với task sequence-to-sequence (dịch máy, tóm tắt), kiến trúc tiêu chuẩn là seq2seq (Sutskever et al. 2014, Cho et al. 2014): hai mạng RNN ghép nối tiếp.

Input  : "I love AI"
         ↓ ↓ ↓
        [Encoder RNN]  ───► context vector c ───►  [Decoder RNN]
                                                       ↓ ↓ ↓ ↓
                                                Output: "Tôi yêu AI"

Đây là backbone của Google Neural Machine Translation (2016) — hệ thống dịch sản phẩm đầu tiên thay rule-based bằng deep learning, đã được deploy thực tế. Trên các task language modeling (Penn Treebank, WikiText), LSTM cũng giữ vị trí dẫn đầu cho đến giữa 2017.

Series 3 (Deep Learning) Module 5 đi sâu vào RNN / LSTM / GRU; bài này chỉ tóm tắt vừa đủ để giải thích vì sao cộng đồng tìm kiến trúc khác.

RNN tính hidden state theo công thức tuần tự:

\[ h_t = f(h_{t-1}, x_t) \]

Muốn có \( h_t \) phải có \( h_{t-1} \). Muốn có \( h_{t-1} \) phải có \( h_{t-2} \). Chuỗi phụ thuộc kéo dài đến \( h_0 \).

Hệ quả khi train:

• Mỗi step phải đợi step trước hoàn tất → không thể tính các step song song trong cùng một sequence.
• Độ phức tạp tuần tự: \( O(T) \) "step" cho sequence dài \( T \). Sequence 1000 token cần 1000 lần forward + 1000 lần backward.
• GPU có hàng nghìn core nhưng RNN chỉ dùng được một phần nhỏ tại mỗi step → utilization thấp.
• Backpropagation through time (BPTT) phải lưu activation cho từng step trong bộ nhớ → tốn memory tuyến tính theo \( T \).

Hệ quả khi inference cũng tương tự: muốn dự đoán token thứ \( T \) phải chạy đủ \( T \) step RNN. Latency tăng tuyến tính theo độ dài.

Trong 2013-2017, các nhóm research thử nhiều cách giảm bottleneck này: ByteNet (Kalchbrenner et al. 2016, dùng dilated CNN), ConvS2S (Gehring et al. 2017, fully convolutional seq2seq). Cả hai parallel hóa được khi train nhưng vẫn có hạn chế riêng về long-range.

Để model "biết" mối liên hệ giữa token vị trí 1 và token vị trí 500, thông tin từ \( x_1 \) phải đi qua 499 step trung gian \( h_1 \to h_2 \to \dots \to h_{500} \). Mỗi step nhân thêm ma trận \( W_h \), kèm phi tuyến.

Vanilla RNN: gradient backward qua nhiều bước nhân với cùng ma trận, eigenvalue < 1 → tiến về 0 (vanishing), eigenvalue > 1 → bùng nổ (exploding). Bengio et al. 1994 đã phân tích chính thức hiện tượng này.

LSTM cải thiện đáng kể: cell state \( c_t \) có "đường tắt" đi qua gate cộng (gate forget & input) nên gradient giữ được lâu hơn. Thực nghiệm cho thấy LSTM xử lý dependency < 200 token tương đối ổn, nhưng:

• Sequence > 500 token vẫn bị suy giảm chất lượng đáng kể — model "quên" phần đầu khi đến cuối.
• Vanishing gradient không biến mất hoàn toàn, chỉ giảm cường độ.
• Khampipos & Mahowald 2018 (long-distance subject-verb agreement) cho thấy LSTM mắc lỗi hệ thống ở các dependency > 30 từ trong tiếng Anh tự nhiên.

Trong khi đó, một bài luận học thuật hay code repository có thể dài 5.000-50.000 token. LSTM không phải lựa chọn thực dụng cho ngữ cảnh dài đến vậy.

Seq2seq vanilla (Sutskever et al. 2014) cố gắng ép toàn bộ thông tin của câu nguồn vào một vector \( c \) duy nhất — chính là hidden state cuối của encoder. Decoder sau đó sinh từng token output dựa vào \( c \) cộng với hidden state riêng của decoder.

x_1, x_2, ..., x_n  →  [Encoder RNN]  →  c ∈ ℝ^d  →  [Decoder RNN]  →  y_1, y_2, ..., y_m
                                          ↑
                                  bottleneck: cố định kích thước d

Với câu ngắn (5-10 từ) vector \( c \) đủ chứa thông tin. Với câu dài hơn, \( c \) phải "nén" nhiều nội dung vào kích thước cố định — và ép buộc này tạo ra hiện tượng quality degrades with sentence length mà Cho et al. 2014 ("On the properties of neural machine translation") đã đo được: BLEU score giảm rõ rệt khi câu nguồn vượt 30 từ.

Nguyên nhân: model không có cách nhìn lại token đầu câu khi đang sinh token cuối. Mọi thông tin phải đi qua kênh hẹp \( c \).

Bahdanau, Cho & Bengio 2014 ("Neural Machine Translation by Jointly Learning to Align and Translate", arXiv:1409.0473) đề xuất bỏ vector \( c \) cố định. Thay vào đó, decoder ở mỗi step sinh ra một context vector riêng bằng cách "attend" qua tất cả hidden state của encoder.

Ở step decoder \( t \), với hidden state decoder \( s_t \) và tập hidden state encoder \( \{h_1, \dots, h_n\} \):

\[ e_{t,i} = \text{score}(s_{t-1}, h_i), \qquad \alpha_{t,i} = \frac{\exp(e_{t,i})}{\sum_j \exp(e_{t,j})}, \qquad c_t = \sum_{i=1}^{n} \alpha_{t,i} h_i \]

Decoder dùng \( c_t \) (khác nhau ở mỗi step) cùng \( s_{t-1} \) để sinh token \( y_t \). Trọng số \( \alpha_{t,i} \) cho biết khi sinh từ thứ \( t \) của output, model đang "nhìn vào" từ nào của input.

Luong et al. 2015 ("Effective Approaches to Attention-based NMT", arXiv:1508.04025) đề xuất ba biến thể score function (dot, general, concat) đơn giản và hiệu quả hơn. Đây là phiên bản attention được dùng rộng rãi trong production NMT 2015-2017.

Kết quả: chất lượng dịch câu dài cải thiện rõ. BLEU không sụt giảm theo độ dài câu nguồn như seq2seq vanilla.

Nhưng: backbone vẫn là RNN. Hai vấn đề đầu (sequential computation, long-range trong chính encoder) chưa được giải. Train một model NMT lớn vẫn mất ngày trên cluster GPU.

Nếu attention đã đảm nhiệm phần "nhìn ra ngữ cảnh", thì hidden state RNN còn vai trò gì? Có thể có một kiến trúc chỉ dùng attention, bỏ hoàn toàn recurrence không?

Câu hỏi này không hiển nhiên. Recurrence đảm bảo hai thứ:

• Thứ tự — \( h_t \) biết về \( x_1, \dots, x_t \) theo thứ tự. Nếu bỏ recurrence, model phải có cách khác để biểu diễn vị trí.
• Tính chất sequential — quan trọng cho language modeling khi sinh từng token một.

Một số bước trung gian được thử nghiệm 2016-2017:

• ConvS2S (Gehring et al. 2017): dùng CNN thay RNN. Parallel hóa được, nhưng long-range vẫn phải xếp chồng nhiều layer.
• "Decomposable Attention" (Parikh et al. 2016): attention thuần cho task entailment, không có recurrence. Quy mô nhỏ nhưng chứng minh nguyên tắc.

Đến tháng 6/2017, đội ngũ Google Brain công bố lời đáp đầy đủ.

Bài báo "Attention Is All You Need" (Vaswani et al., NeurIPS 2017, arXiv:1706.03762) đề xuất kiến trúc Transformer với hai quyết định thiết kế quan trọng:

1. Bỏ hoàn toàn recurrence và convolution.
2. Mọi tính toán giữa các vị trí trong sequence được thực hiện bằng self-attention — mỗi token attend mọi token khác trong cùng sequence (kể cả chính nó).

Một block Transformer ở dạng tối giản gồm hai thành phần:

• Multi-head self-attention — tính trộn thông tin giữa các vị trí.
• Feed-forward network (FFN) — mạng dense áp dụng độc lập từng vị trí.

Mỗi thành phần đi kèm residual connection và LayerNorm (bài 13 sẽ đi sâu).

Thông tin về thứ tự token được đưa vào qua positional encoding cộng vào embedding ở input (bài 12).

Self-attention sẽ là chủ đề chính của bài 10 — bài này chỉ cần ghi nhớ ý: mỗi token tính một "câu hỏi" (query) đối chiếu với "khóa" (key) của tất cả token còn lại, lấy weighted sum của "giá trị" (value) tương ứng. Đây là phép tính có thể được biểu diễn dưới dạng nhân ma trận hàng loạt — chìa khóa để parallel hóa.

Trên task dịch English→German của WMT 2014, Transformer base đạt BLEU 27,3 trong khi train nhanh hơn ConvS2S và GNMT vài lần. Train một model lớn (Transformer big) mất khoảng 3,5 ngày trên 8 GPU P100, so với hàng tuần của các baseline RNN tại thời điểm đó.

Bảng đối chiếu rút gọn ba điểm RNN bị giới hạn với cách Transformer xử lý:

Tiêu chí                       RNN / LSTM            Transformer
─────────────────────────────────────────────────────────────────────
Sequential step (train)        O(T)                  O(1) cho 1 layer
                                                     (tính cả sequence cùng lúc)
Path giữa hai token i và j     O(|i - j|)            O(1)
                               (đi qua chuỗi h_t)    (attention trực tiếp)
Tổng compute / 1 layer         O(T · d²)             O(T² · d) + O(T · d²)
Parallel hóa khi train         Không                 Có (toàn bộ sequence)
Long-range                     Suy giảm > ~500 token Tốt hơn, vẫn giới hạn
                                                     bởi context window

Ba lợi thế cụ thể:

• Parallelizable khi train: cả sequence được tính cùng lúc nhờ phép nhân ma trận. GPU / TPU dùng được toàn bộ core. Hiệu năng training trên cùng phần cứng tăng nhiều lần.
• Long-range trực tiếp: mọi token kết nối mọi token qua đúng 1 lớp attention, không phải qua chuỗi hidden state. Token vị trí 1 và token vị trí 5.000 có "khoảng cách" \( O(1) \) trong đồ thị tính toán.
• Scale tốt: tăng số layer, số head, hidden dim đều cải thiện chất lượng đo bằng loss / benchmark. Empirical scaling law (Kaplan et al. 2020, Hoffmann et al. 2022) cho thấy loss giảm trơn theo lũy thừa của param, data, compute.

Hệ quả: Transformer trở thành kiến trúc nền tảng cho phần lớn LLM hiện đại, vision Transformer (ViT), speech (Whisper), multimodal (CLIP, LLaVA). Nhận xét "universal architecture" được lặp lại từ 2020 trở đi.

Không có kiến trúc nào miễn phí. Transformer trả giá ở ba điểm:

• Attention \( O(n^2) \): với sequence dài \( n \), ma trận attention có \( n \times n \) phần tử. Memory và compute đều tăng bậc hai. Đây là nguyên nhân context window dài (1M token) là vấn đề kỹ thuật khó, không phải tăng thông số dễ dàng.
• Không có vị trí ngầm: vì bỏ recurrence, model không "tự biết" thứ tự token. Phải thêm positional encoding (sinusoidal, learned, ALiBi, RoPE...) một cách tường minh (bài 12).
• Số tham số lớn: với task quy mô nhỏ, Transformer thường cần nhiều tham số hơn LSTM tương đương để đạt cùng kết quả. Lợi thế thật sự xuất hiện khi quy mô đủ lớn (vài chục triệu token train trở lên).

Một số nhánh cải tiến giải quyết trực tiếp các trade-off:

• FlashAttention (Dao et al. 2022): tổ chức lại bộ nhớ để giảm memory cho attention \( O(n^2) \) mà không thay đổi công thức.
• Sparse / linear attention: thay attention đầy đủ bằng phép xấp xỉ \( O(n \log n) \) hoặc \( O(n) \).
• State space (Mamba): trở lại ý tưởng "trạng thái nén" của RNN nhưng tổ chức để vẫn parallel hóa được.

Mục 15 sẽ điểm qua các hướng này, sâu hơn dành cho bài chuyên đề ngoài lộ trình.

2014    Bahdanau attention cho seq2seq RNN (arXiv:1409.0473)
2014    Sutskever et al. — seq2seq with neural networks (arXiv:1409.3215)
2015    Luong attention — variant đơn giản, hiệu quả (arXiv:1508.04025)
2016    Google Neural Machine Translation (GNMT) deploy LSTM + attention
2017-06 "Attention Is All You Need" — Transformer (arXiv:1706.03762)
2018-06 GPT-1 (OpenAI) — decoder-only Transformer pretrain
2018-10 BERT (Google) — encoder-only Transformer, masked LM
2019-02 GPT-2 — scale decoder-only lên 1,5B param
2019-10 T5 (Google) — encoder-decoder, "text-to-text" framework
2020-05 GPT-3 — 175B param, in-context learning, scale matters
2020    Vision Transformer (ViT) — Transformer cho ảnh
2022-11 ChatGPT (RLHF fine-tune GPT-3.5)
2023    Llama, Llama 2 — Transformer open weight
2023-12 Mixtral 8x7B — Mixture of Experts trên Transformer
2024    Mamba, RWKV — challenger non-Transformer cho long context

Tính đến 2024-2026, gần như mọi LLM thương mại và open-source phổ biến (GPT-4, Claude 3 / 4, Gemini, Llama 3, Mistral, Qwen) đều dựa trên Transformer hoặc biến thể trực tiếp của nó. Kiến trúc gốc 2017 vẫn nhận ra được trong code của model 2026, dù có nhiều tối ưu (RoPE, GQA, SwiGLU, FlashAttention).

Sơ đồ rất tóm tắt của một Transformer decoder (kiểu GPT):

Input tokens [t_1, t_2, ..., t_n]
       │
       ▼
[Token Embedding] + [Positional Encoding]      ← bài 12
       │
       ▼
┌──────────────────────────────────────┐
│  Transformer Block (lặp L lần)        │
│                                        │
│   ├─ Multi-head Self-Attention        │ ← bài 10, 11
│   │     (+ residual + LayerNorm)      │
│   │                                    │
│   └─ Feed-Forward Network (FFN)       │ ← bài 13
│         (+ residual + LayerNorm)      │
└──────────────────────────────────────┘
       │
       ▼
[Output projection (LM head)]                  ← bài 5 (đã học)
       │
       ▼
Logits ∈ ℝ^V  →  softmax  →  token tiếp theo

Chú thích:

• \( L \) (số layer) là siêu tham số. GPT-2 small \( L = 12 \), Llama 3 8B \( L = 32 \), GPT-3 175B \( L = 96 \).
• Hidden dimension \( d \) cũng là siêu tham số. GPT-2 \( d = 768 \), Llama 3 8B \( d = 4096 \).
• Số head attention chia \( d \) thành các "góc nhìn" song song — chi tiết bài 11.

Bài báo gốc 2017 đề xuất kiến trúc encoder-decoder (cho dịch máy). Sau đó cộng đồng tách ra ba biến thể, mỗi biến thể tối ưu cho một loại task:

Loại                       Đại diện         Mục tiêu chính
──────────────────────────────────────────────────────────────────────
Encoder-only               BERT, RoBERTa    Hiểu (representation, classification)
Decoder-only               GPT, Llama       Sinh (text generation, LLM hiện đại)
Encoder-Decoder            T5, BART         Map sequence → sequence (dịch, tóm tắt)

Khác biệt then chốt nằm ở mask attention:

• Encoder-only — attention không mask, mỗi token thấy được toàn bộ chuỗi (cả trái và phải). Phù hợp khi cần embedding cho cả câu (search, classify).
• Decoder-only — attention causal: token vị trí \( t \) chỉ thấy \( 1 \dots t \), không thấy tương lai. Phù hợp khi cần sinh token tuần tự.
• Encoder-Decoder — encoder không mask (đọc input đầy đủ), decoder mask causal và thêm cross-attention attend vào output encoder.

Phần lớn LLM thương mại 2022-2026 (GPT, Claude, Llama, Mistral, Qwen, Gemini) là decoder-only. Bài 14 sẽ so sánh chi tiết ba kiến trúc và lý do decoder-only chiếm ưu thế khi scale lên LLM.

Có hai phép tính "attention" trong Transformer cần phân biệt — bài này chỉ giới thiệu, bài 10 sẽ đi sâu:

• Self-attention: query, key, value đều đến từ cùng một sequence. Mỗi token "tự" nhìn các token khác (kể cả chính nó) trong cùng chuỗi. Đây là khối chính của encoder-only và decoder-only.
• Cross-attention: query đến từ một sequence (ví dụ decoder), key và value đến từ sequence khác (ví dụ encoder output). Cho phép decoder "nhìn vào" input đã được encoder xử lý xong. Có trong kiến trúc encoder-decoder.

Trong decoder-only (GPT), chỉ có self-attention. Trong encoder-decoder (T5, BART), mỗi decoder block thường có một self-attention (trên output đã sinh) và một cross-attention (trên encoder output).

Module 2 tập trung vào kiến trúc gốc 2017 và biến thể trực tiếp. Một số hướng research hiện đại nằm ngoài phạm vi Module 2, chỉ liệt kê để hình dung bức tranh:

• Sparse attention: chỉ attend tới một tập con vị trí. Longformer (Beltagy et al. 2020) sliding window + global token, BigBird (Zaheer et al. 2020) random + global + window. Giảm \( O(n^2) \) về \( O(n) \) hoặc \( O(n \log n) \).
• Linear attention: viết lại công thức attention thành dạng \( O(n) \). Performer (Choromanski et al. 2020) dùng random feature, Linformer (Wang et al. 2020) chiếu key/value xuống không gian thấp.
• State space model: Mamba (Gu & Dao 2023), RWKV — bỏ attention, dùng tính chất tuyến tính của state space để vẫn parallel hóa được khi train. Cạnh tranh với Transformer cho context dài (long-form audio, DNA).
• Mixture of Experts (MoE): thay FFN một tầng bằng nhiều FFN "expert"; router chọn 2-4 expert / token. Mixtral 8x7B (Mistral 2023), DeepSeek V3, GPT-4 (theo các báo cáo không chính thức) đều dùng MoE để tăng dung lượng mà không tăng compute / token tương ứng.

Tất cả các nhánh này đều giả định bạn đã hiểu Transformer gốc; vì vậy lộ trình của bài học vẫn là Transformer trước, biến thể sau.

Từ 2017 đến nay, Transformer giữ vị trí chủ đạo cho LLM. Tuy nhiên đã có một số dấu hiệu cho thấy không phải mọi bài toán đều phù hợp với kiến trúc này:

• Context window cực dài (256k → 1M → 10M token): chi phí \( O(n^2) \) trở nên không thực tế ngay cả khi tối ưu FlashAttention. Mamba và Jamba (Mistral 2024) cho thấy state space lai Transformer có thể rẻ hơn ở long context.
• Streaming inference với latency thấp: RWKV được thiết kế cho inference \( O(1) \) memory mỗi token, hấp dẫn cho edge.
• Dữ liệu có cấu trúc đặc biệt (audio waveform, time series, gene): có nghiên cứu cho thấy SSM cạnh tranh tốt hơn Transformer thuần.

Tính đến hiện tại (2025-2026), Transformer vẫn là default an toàn cho LLM. Câu hỏi "kiến trúc tiếp theo" vẫn đang được trả lời. Bài này sẽ không lựa chọn phe nào — Module 2 dạy Transformer như nền tảng, và bạn có thể đọc thêm Mamba / RWKV ở các bài chuyên đề ngoài lộ trình.

Module 2 gồm 7 bài:

Bài 8  (bài này)  — Motivation: vì sao cần Transformer
Bài 9             — Attention mechanism: query, key, value, score function
Bài 10            — Self-Attention: token "nhìn" token khác trong cùng sequence
Bài 11            — Multi-head Attention: nhiều "góc nhìn" song song
Bài 12            — Positional Encoding: thông tin thứ tự (sinusoidal, learned, RoPE)
Bài 13            — Transformer block: attention + FFN + residual + LayerNorm
Bài 14            — Encoder-only (BERT) vs Decoder-only (GPT) vs Encoder-Decoder (T5)

Sau Module 2, Module 3 (Hugging Face) sẽ chuyển sang dùng pretrained Transformer bằng thư viện transformers — đến lúc đó các thuật ngữ AutoModel, config.num_hidden_layers, config.num_attention_heads, config.hidden_size sẽ trở nên rõ nghĩa.

PyTorch có sẵn class nn.Transformer, nhưng trong thực tế ít ai dùng trực tiếp — phần lớn dự án nạp pretrained model qua Hugging Face. Hai cách viết để bạn hình dung trước:

Cách "low-level" (PyTorch built-in, hiếm dùng ở production):

import torch
import torch.nn as nn

# Encoder-decoder Transformer rất tối giản
model = nn.Transformer(
    d_model=512,
    nhead=8,
    num_encoder_layers=6,
    num_decoder_layers=6,
    dim_feedforward=2048,
    batch_first=True,
)

src = torch.randn(2, 10, 512)   # (batch, seq_len, d_model)
tgt = torch.randn(2, 12, 512)
out = model(src, tgt)
print(out.shape)                # torch.Size([2, 12, 512])

Cách "high-level" (Hugging Face — dùng pretrained model thật):

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tok = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

inputs = tok("Transformer là", return_tensors="pt")
with torch.no_grad():
    out = model.generate(**inputs, max_new_tokens=20)
print(tok.decode(out[0]))

Trong bài 11-13, chúng ta sẽ implement một block self-attention và một block Transformer hoàn chỉnh "from scratch" bằng PyTorch — không phải để chạy production mà để hiểu mọi phép tính bên trong.

1. Liệt kê 3 vấn đề của RNN / LSTM mà Transformer giải quyết được. Với mỗi vấn đề, viết một câu giải thích cụ thể cách Transformer xử lý.
2. Tìm 5 model LLM hoặc foundation model phổ biến hiện nay và xếp loại theo kiến trúc (encoder-only / decoder-only / encoder-decoder). Gợi ý: BERT, GPT-2, T5, BART, Llama 3, Mistral, Whisper, ViT, CLIP.
3. Giả sử bạn cần xử lý sequence 1 triệu token (ví dụ toàn bộ codebase). Đánh giá ngắn ba kiến trúc (Transformer thuần với attention \( O(n^2) \), sparse attention, state space như Mamba) về: bộ nhớ cần thiết, độ phức tạp tính toán, chất lượng kỳ vọng.
4. (Tùy chọn) Mở paper "Attention Is All You Need" (arXiv:1706.03762) và xác định: số layer mặc định của Transformer base, số head, hidden dim, dim FFN, kết quả BLEU trên WMT 2014 EN→DE.
5. (Tùy chọn) Đọc abstract của Bahdanau et al. 2014 (arXiv:1409.0473). Tóm tắt trong 3 câu: vấn đề họ giải, ý tưởng đề xuất, kết quả thực nghiệm.

• Trước 2017, sequence model chủ yếu là RNN / LSTM / GRU. Seq2seq + attention (Bahdanau 2014, Luong 2015) là state-of-art cho dịch máy.
• Ba vấn đề của RNN: tính toán tuần tự \( O(T) \) không parallel được; long-range dependency suy giảm dù LSTM cải thiện; bottleneck encoder→decoder ép thông tin vào một context vector.
• Attention Bahdanau fix bottleneck nhưng vẫn dùng RNN backbone, hai vấn đề đầu chưa giải.
• Transformer (Vaswani et al. 2017) bỏ recurrence và convolution hoàn toàn, dùng self-attention + FFN. Train parallel cả sequence, mọi cặp token có đường nối \( O(1) \).
• Trade-off: attention \( O(n^2) \) tốn memory với sequence dài, phải đưa positional encoding tường minh, model cần đủ lớn để hơn LSTM.
• 3 biến thể: encoder-only (BERT) cho hiểu, decoder-only (GPT, Llama) cho sinh, encoder-decoder (T5, BART) cho seq2seq. LLM thương mại hiện đại phần lớn là decoder-only.
• Module 2 (bài 9-14) đi sâu vào attention, self-attention, multi-head, positional encoding, block Transformer và so sánh ba biến thể.

Bài 9 (Attention mechanism) sẽ bắt đầu với công thức gốc: query, key, value và cách tính trọng số attention chi tiết.