Bài 14: Encoder-only (BERT) vs Decoder-only (GPT) vs Encoder-Decoder (T5)

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

• Encoder-only, decoder-only, encoder-decoder khác nhau ở chỗ nào trong cách dùng attention.
• Pretraining objective tương ứng — MLM, CLM, span corruption — mỗi cái ép model học gì.
• Model tiêu biểu mỗi family và tham số gần đúng.
• Vì sao 99% LLM chat hiện nay (Claude, GPT, Llama, Qwen, DeepSeek...) là decoder-only.
• Khi nào vẫn còn lý do để chọn encoder-only (BERT) hoặc encoder-decoder (T5, NLLB).
• Cách load ba architecture qua transformers chỉ bằng AutoModel, AutoModelForCausalLM, AutoModelForSeq2SeqLM.

Bài này kết Module 2. Module 1 (Bài 1-7) lo về token và embedding; Module 2 (Bài 8-14) đi qua attention và Transformer block. Module 3 từ Bài 15 chuyển sang thực hành với Hugging Face.

Bài 13 đã mô tả 1 Transformer block: multi-head self-attention + FFN + residual + LayerNorm. Paper Vaswani et al. 2017 ghép block theo cấu hình encoder-decoder để dịch máy. Nhưng cùng building block đó có thể lắp theo ba cách khác nhau:

• Encoder-only: chỉ stack block encoder, attention bidirectional. Đại diện: BERT (Devlin et al. 2018).
• Decoder-only: chỉ stack block decoder, attention causal. Đại diện: GPT (Radford et al. 2018).
• Encoder-Decoder: stack encoder + stack decoder, kết nối qua cross-attention. Đại diện: Transformer gốc, T5 (Raffel et al. 2020), BART (Lewis et al. 2019).

Sự khác biệt nằm gần như hoàn toàn ở mặt nạ attention (mask) và cách kết nối các stack — không phải ở phép toán cốt lõi.

Encoder-only không sinh token mới. Mục tiêu là biến chuỗi đầu vào thành chuỗi vector biểu diễn (representation) phục vụ task downstream.

Đặc điểm:

• Self-attention không có causal mask: mỗi token attend tất cả token trong chuỗi (chỉ mask padding).
• Ma trận attention \( n \times n \) đầy đủ — bidirectional.
• Output: chuỗi vector \( (n, d_{\text{model}}) \), giữ nguyên độ dài.
• Task downstream gắn thêm head phía trên: linear cho classification, token classification cho NER, dot-product cho retrieval.

Hệ quả: encoder mạnh ở "đọc hiểu" cả câu vì mọi token nhìn được cả past và future. Đổi lại, không sinh được câu tiếp theo — output có cùng độ dài input, không có cơ chế tạo token mới.

Use case điển hình: text classification (sentiment, topic), Named Entity Recognition, embedding cho semantic search / RAG (Bài 23+), question answering kiểu extractive (chọn span trong văn bản).

Vì encoder không sinh token tiếp theo, không thể pre-train bằng next-token prediction. BERT dùng Masked Language Modeling (MLM):

1. Lấy chuỗi token đầu vào.
2. Chọn ngẫu nhiên 15% vị trí để "che". Trong số đó: 80% thay bằng [MASK], 10% thay bằng token ngẫu nhiên, 10% giữ nguyên.
3. Forward qua encoder, lấy output ở các vị trí bị che.
4. Loss = cross-entropy giữa prediction và token gốc tại các vị trí đó.

Mục tiêu: dự đoán đúng token bị che, dựa vào ngữ cảnh cả hai phía. Cần bidirectional attention mới khả thi — đây là lý do encoder-only phù hợp với MLM.

BERT gốc có thêm Next Sentence Prediction (NSP): cho hai câu A, B; dự đoán B có phải câu tiếp theo của A không. RoBERTa (Liu et al. 2019) cho thấy NSP không cải thiện chất lượng, và bỏ NSP đi.

• BERT (Devlin et al. 2018, arXiv:1810.04805): base 12 layer, 768 hidden, 12 head, ~110M tham số; large 24 layer, 1024 hidden, 16 head, ~340M.
• RoBERTa (Liu et al. 2019, arXiv:1907.11692): cùng kiến trúc BERT, cải tiến training — corpus lớn hơn, batch lớn hơn, train lâu hơn, bỏ NSP, dynamic masking. Vượt BERT trên hầu hết benchmark GLUE / SQuAD.
• DeBERTa (He et al. 2020, arXiv:2006.03654): disentangled attention — tách content và position thành hai stream attention riêng. DeBERTa-v3 (2021) thêm replaced-token detection thay MLM.
• DistilBERT (Sanh et al. 2019): chưng cất BERT thành 6 layer, ~66M tham số, giữ ~97% chất lượng, nhanh gấp đôi.
• ALBERT (Lan et al. 2019): chia sẻ tham số giữa layer + factorize embedding để giảm tham số.
• ELECTRA (Clark et al. 2020): thay MLM bằng replaced-token detection — sample efficient hơn.
• mBERT (multilingual BERT): train trên 104 ngôn ngữ Wikipedia, 1 model dùng chung vocab.
• XLM-R (Conneau et al. 2019): multilingual mạnh hơn mBERT, 100 ngôn ngữ, train trên CommonCrawl.
• PhoBERT (Nguyen & Nguyen 2020, VinAI): pre-train trên 20GB tiếng Việt; pho-bert-base, pho-bert-large.
• ViBERT, vELECTRA, BARTpho: các biến thể tiếng Việt khác.

Encoder-only vẫn dùng rất rộng cho embedding model. Các embedding model SOTA 2024 như BGE (BAAI), E5 (Microsoft) đều xuất phát từ encoder Transformer (thường initialize từ XLM-R hoặc DeBERTa-v3), fine-tune contrastive.

Decoder-only chỉ stack block decoder. Mỗi block có một self-attention sub-layer (causal) + FFN, không có cross-attention.

Đặc điểm:

• Self-attention dùng causal mask: token \( i \) chỉ attend các token \( j \le i \).
• Ma trận attention \( n \times n \) chỉ "đầy" ở tam giác dưới.
• Output ở vị trí \( i \) chỉ phụ thuộc các token \( 1, \dots, i \).
• Generation: predict token tiếp theo, append vào chuỗi, lặp.

Hệ quả: decoder-only train một lần trên toàn câu (mọi vị trí tính output song song), nhưng nhờ causal mask, mỗi vị trí chỉ học từ phần "đã thấy" — y hệt trạng thái khi inference từng token một. Train song song, inference tuần tự.

Use case: text generation (completion, chat), code generation, function calling, agent reasoning — tất cả task biến được thành "next token prediction".

Pretraining decoder-only là Causal Language Modeling (CLM): dự đoán token tiếp theo cho mọi vị trí.

Với chuỗi \( x_1, x_2, \dots, x_n \), loss là negative log-likelihood:

\[ \mathcal{L} = -\sum_{i=1}^{n} \log P(x_{i+1} \mid x_1, \dots, x_i) \]

Vì có causal mask, một forward pass tính được loss cho tất cả vị trí cùng lúc — rất hiệu quả khi train ở quy mô lớn (hàng nghìn tỷ token).

Không cần che token, không cần special task. Bất kỳ corpus văn bản nào cũng dùng được, không cần label. Đây là một trong các lý do decoder-only scale tốt hơn — dữ liệu pretraining gần như không giới hạn.

Gần như mọi LLM chat hiện nay là decoder-only. Một số đại diện:

• GPT-1 → GPT-5 (OpenAI, 2018-2025): GPT-1 117M, GPT-2 1.5B, GPT-3 175B (arXiv:2005.14165), GPT-4 / 4o / 5 không công bố tham số.
• Claude 1 → Claude 4 / 4.5 (Anthropic): kiến trúc decoder-only, không công bố chi tiết tham số.
• Gemini 1.5 / 2 / 2.5 (Google): decoder-only, một số biến thể MoE.
• Llama 1 / 2 / 3 / 3.1 (Meta): open weights. Llama 3.1 ở các kích thước 8B, 70B, 405B (arXiv:2407.21783).
• Mistral 7B, Mixtral 8x7B, Mixtral 8x22B (Mistral AI): Mixtral dùng Mixture-of-Experts.
• Qwen 2 / 2.5 / 3 (Alibaba): open weights, từ 0.5B đến 72B.
• DeepSeek-V3 (671B MoE, ~37B active), DeepSeek-R1: reasoning model open weights.
• Gemma 2 / 3 (Google), Phi-3 / 4 (Microsoft), Command R (Cohere), Yi (01.AI), InternLM, GLM-4: open weights khác.

Vietnamese LLM decoder-only: VinaLLaMA, PhoGPT (VinAI), Vistral (UIT). Phần lớn fine-tune từ Llama hoặc Mistral.

Quan sát chung: từ 2022 trở đi, hầu hết flagship LLM phục vụ chat / agent / code đều là decoder-only.

Đây là cấu hình paper Vaswani et al. 2017 dùng cho dịch máy.

Cấu trúc:

• Encoder stack: \( N \) block. Mỗi block: bidirectional self-attention + FFN. Output: chuỗi vector của input.
• Decoder stack: \( N \) block. Mỗi block có 3 sub-layer:
  1. Causal self-attention trên chuỗi output đang sinh.
  2. Cross-attention: Q lấy từ decoder, K và V lấy từ encoder output. Đây là chỗ thông tin từ input chảy sang decoder (xem Bài 9).
  3. FFN.

Use case: seq2seq nơi input và output là hai chuỗi khác nhau, ranh giới rõ ràng: dịch (input câu nguồn, output câu đích), tóm tắt (input bài, output tóm tắt), question-answering kiểu generative (input câu hỏi + context, output câu trả lời).

Lợi thế lý thuyết: encoder đọc input bidirectional (hiểu tốt), decoder sinh output causal (sinh hợp lệ), cross-attention làm cầu nối explicit.

Encoder-decoder cần objective cho cả encoder lẫn decoder. Có hai cách phổ biến:

• Span corruption (T5, Raffel et al. 2020): chọn các đoạn ngắn (span) ngẫu nhiên trong input, thay mỗi span bằng một sentinel token riêng (<extra_id_0>, <extra_id_1>...). Decoder phải sinh ra các span gốc nối tiếp, mỗi span có sentinel làm separator.

  Input  : The quick <extra_id_0> jumps over the <extra_id_1> dog.
  Target : <extra_id_0> brown fox <extra_id_1> lazy <extra_id_2>

• Denoising (BART, Lewis et al. 2019): input bị "phá" bằng các phép biến đổi (token masking, deletion, infilling, sentence permutation, document rotation). Decoder phải tái tạo input gốc — chính xác từng token.

Cả hai cách dùng được mọi corpus văn bản, không cần label.

• T5 (Raffel et al. 2020, arXiv:1910.10683) — "Text-to-Text Transfer Transformer": mọi task được phát biểu thành "text in, text out". Các kích thước: small (60M), base (220M), large (770M), 3B, 11B (XXL).
• mT5 (Xue et al. 2020): T5 multilingual, 101 ngôn ngữ.
• Flan-T5 (Chung et al. 2022): T5 instruction-tuned trên ~1.8k task. Trong nhiều benchmark zero-shot, Flan-T5 XXL gần ngang GPT-3 ở thời điểm release.
• BART (Lewis et al. 2019, arXiv:1910.13461): kiến trúc tương tự T5, pretraining denoising. Mạnh ở summarization và generation.
• mBART: BART multilingual cho dịch máy.
• NLLB-200 (NLLB Team 2022): "No Language Left Behind", dịch 200 ngôn ngữ ít tài nguyên, 54.5B tham số ở bản lớn nhất.
• MarianMT, M2M-100: encoder-decoder cho dịch máy Meta / Hugging Face.
• BARTpho, ViT5: encoder-decoder pre-train cho tiếng Việt (VinAI).

Quan sát: số model encoder-decoder mới release giảm dần từ 2023 — phần lớn task seq2seq được "nuốt" vào decoder-only kích thước lớn. Tuy nhiên nhánh dịch máy chất lượng cao và domain-specific NLP vẫn còn dùng.

                        Encoder-only       Decoder-only      Encoder-Decoder
                        (BERT family)      (GPT family)      (T5 / BART family)
─────────────────────────────────────────────────────────────────────────────
Self-attention          bidirectional      causal            enc: bi, dec: causal
Cross-attention         không               không             có (dec → enc)
Bidirectional context   YES (full)          NO                Một phần (input only)
Generation              NO                  YES (native)      YES (native)
Classification          YES (mạnh)          OK (qua prompt)   OK
Embedding / retrieval   YES (truyền thống)  Dùng được         OK
Pretraining objective   MLM                 CLM (next-token)  Span corr. / Denoising
Inference cost (gen)    N/A                 Auto-regressive   Auto-regressive (decoder)
Scale (param SOTA)      ~1B                 100B-1T+          ~10B (Flan-T5 XXL)
Modern dominance        Embedding / NER     LLM chat / agent  Translation chuyên

Ba dòng không loại trừ nhau — chúng có "vùng sở trường" khác nhau. Phần dưới đi vào lý do hiện tại decoder-only chiếm ưu thế.

Một số lý do thường được trích dẫn trong literature và thực tiễn industry:

• Kiến trúc đơn giản, scale ổn: chỉ 1 stack đồng nhất, dễ phân tán trên nhiều GPU. Encoder-decoder phải đồng bộ hai stack + cross-attention, infrastructure phức tạp hơn ở quy mô siêu lớn.
• Universal next-token prediction: mọi task biến được thành "given prompt, sinh tiếp" — classification, dịch, tóm tắt, code, reasoning. Không cần task-specific head.
• In-context learning: Brown et al. 2020 (GPT-3 paper) cho thấy decoder-only đủ lớn học task mới chỉ từ vài ví dụ trong prompt, không cần fine-tune. Encoder-only hay encoder-decoder kích thước tương đương không thể hiện hiệu ứng này rõ.
• Instruction following / chat: format chat (system / user / assistant) ánh xạ tự nhiên vào next-token prediction. RLHF (Ouyang et al. 2022) áp dụng tốt nhất trên decoder-only.
• Inductive bias ít hơn: không có cấu trúc "input vs output" cứng. Một số nghiên cứu (Wang et al. 2022, "What Language Model Architecture and Pretraining Objective Work Best for Zero-Shot Generalization") cho thấy decoder-only + CLM generalize zero-shot tốt nhất khi scale lên.
• Hiệu quả compute pretraining: CLM tính loss trên toàn bộ token (mỗi vị trí 1 loss), trong khi MLM chỉ tính loss trên 15% token bị che — về mặt sample efficiency, CLM rút ra nhiều tín hiệu hơn cho mỗi câu.

Cần lưu ý: "dominate" ở đây nói về thị phần LLM chat / agent / code. Embedding model, NER, translation vẫn có chỗ đứng cho encoder và encoder-decoder.

• Embedding cho semantic search / RAG: cần vector đại diện chuỗi, không cần generation. BGE-large (BAAI), E5 (Microsoft), GTE (Alibaba) — phần lớn vẫn xuất phát từ encoder backbone.
• Classification kích thước nhỏ: phân loại spam, sentiment, topic, intent — BERT-base 110M đủ dùng và rẻ inference hơn LLM 7B.
• NER, span extraction: cần label trên từng token, encoder vẫn là default trong production NLP.
• Latency thấp: encoder không có generation loop nên forward pass single-shot.
• Domain specific tiếng Việt: PhoBERT, ViBERT đã pretrain trên corpus tiếng Việt sạch, fine-tune cho task NLP cụ thể vẫn cạnh tranh.

Một số embedding model 2024-2025 (text-embedding-3 của OpenAI, voyage-3) thực ra dùng decoder backbone với pooling đặc biệt, không phải encoder cổ điển. Nhưng encoder vẫn là lựa chọn default cho open-weight embedding model.

• Dịch máy chuyên dụng: NLLB-200 dịch 200 ngôn ngữ, nhiều low-resource. Decoder-only general chưa chắc support tốt các cặp ngôn ngữ hiếm bằng model chuyên dịch.
• Tóm tắt deterministic, chi phí thấp: BART / T5 vài trăm triệu tham số đủ tóm tắt tài liệu, rẻ hơn dùng LLM 70B qua API.
• Task seq2seq với input và output tách biệt rõ: cross-attention giữ "input nguyên vẹn" trong khi decoder sinh — đôi khi giảm hallucination so với decoder-only dồn cả input vào context.

Xu hướng thực tế: với chất lượng đủ, ngân sách đủ, GPT-4 / Claude / Gemini dịch và tóm tắt cạnh tranh hoặc vượt encoder-decoder cùng quy mô. Nhưng khi cần model dưới 1B chạy on-prem, T5 và NLLB vẫn được dùng nhiều trong production.

• PrefixLM: model 1 stack (giống decoder), nhưng cho phép "prefix" — vùng input ban đầu — attend bidirectional, vùng sinh ra phía sau dùng causal mask. Có thể xem như encoder-decoder gập lại làm một, share tham số.
• UL2 (Tay et al. 2022, arXiv:2205.05131): pretraining objective hỗn hợp — Regular denoising (R), Sequence denoising (S), Extreme denoising (X) — để model học cả khả năng MLM, CLM, span corruption trong một backbone. Có hai biến thể: encoder-decoder UL2 và decoder-only UL2.
• GLM (Du et al. 2022): General Language Model — autoregressive blank infilling, cho phép vừa generation vừa MLM trên cùng kiến trúc. ChatGLM xuất phát từ GLM.
• FIM (Fill-in-the-Middle): training trick áp dụng cho decoder-only, sắp xếp lại input thành prefix + suffix + middle để decoder học hoàn thiện vùng giữa. Dùng phổ biến cho code model (StarCoder, Code Llama, DeepSeek-Coder).

Các biến thể này mờ ranh giới giữa ba dòng. Nhưng phần lớn LLM chat hiện tại vẫn là decoder-only thuần.

• BERT: [CLS] (đầu chuỗi, embedding cả câu), [SEP] (separator giữa hai câu / cuối chuỗi), [MASK] (token bị che trong MLM), [PAD], [UNK].
• GPT-2 / GPT-3: <|endoftext|> đánh dấu hết tài liệu trong pretraining và end-of-generation. Không có [CLS] / [MASK].
• ChatML (OpenAI, Anthropic, Llama 3, Qwen): cấu trúc role bằng special token, ví dụ <|im_start|>system\n...<|im_end|>\n<|im_start|>user\n...<|im_end|>. Llama 3 dùng <|begin_of_text|>, <|start_header_id|>, <|end_header_id|>, <|eot_id|>.
• T5: <extra_id_0>, <extra_id_1>, ... (100 sentinel) đánh dấu các span bị che. </s> kết thúc.
• BART: <s>, </s> bao đầu cuối; <mask> cho token masking.

Khi dùng model qua Hugging Face, các special token tự được thêm bởi tokenizer (tokenizer.encode(text, add_special_tokens=True)). Chi tiết tokenizer đã đề cập Bài 3-5.

Model              Năm    Loại            Param
─────────────────────────────────────────────────
BERT base          2018   Encoder-only    110M
BERT large         2018   Encoder-only    340M
RoBERTa large      2019   Encoder-only    355M
DeBERTa-v3 large   2021   Encoder-only    304M
GPT-2              2019   Decoder-only    1.5B
GPT-3              2020   Decoder-only    175B
GPT-4              2023   Decoder-only    ~1.7T (ước lượng public)
Llama 3.1          2024   Decoder-only    8B / 70B / 405B
Mistral 7B         2023   Decoder-only    7.3B
Mixtral 8x7B       2023   Decoder-only MoE 46.7B (12.9B active)
DeepSeek-V3        2024   Decoder-only MoE 671B (37B active)
Qwen 2.5           2024   Decoder-only    0.5B - 72B
T5 XXL             2020   Encoder-decoder 11B
Flan-T5 XXL        2022   Encoder-decoder 11B
BART large         2019   Encoder-decoder 406M
NLLB-200           2022   Encoder-decoder 54.5B

Mẫu hình: encoder và encoder-decoder hiếm khi vượt 10B. Decoder-only đẩy được lên 100B-1T+. Một phần do mục tiêu sử dụng, một phần do kiến trúc decoder-only đơn giản hơn khi scale.

Hugging Face Transformers (v4.x) cho phép load cả ba kiến trúc qua API chung. Phần này demo nhanh, chi tiết để dành Bài 16-18.

Encoder-only — BERT cho embedding:

from transformers import AutoTokenizer, AutoModel
import torch

tok = AutoTokenizer.from_pretrained("bert-base-uncased")
enc = AutoModel.from_pretrained("bert-base-uncased")

inputs = tok("Self-attention is the core of Transformer.", return_tensors="pt")
with torch.no_grad():
    out = enc(**inputs)

# out.last_hidden_state: (1, seq_len, 768) — vector mỗi token
# out.last_hidden_state[:, 0]: vector [CLS] thường dùng đại diện cả câu
print(out.last_hidden_state.shape)

Decoder-only — GPT-2 cho generation:

from transformers import AutoTokenizer, AutoModelForCausalLM

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

inputs = tok("The capital of France is", return_tensors="pt")
out = gen.generate(**inputs, max_new_tokens=10)
print(tok.decode(out[0], skip_special_tokens=True))

Encoder-decoder — Flan-T5 cho seq2seq:

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

tok = AutoTokenizer.from_pretrained("google/flan-t5-base")
s2s = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-base")

prompt = "translate English to German: Self-attention is powerful."
inputs = tok(prompt, return_tensors="pt")
out = s2s.generate(**inputs, max_new_tokens=20)
print(tok.decode(out[0], skip_special_tokens=True))

Ba class khác nhau: AutoModel (encoder, trả hidden state), AutoModelForCausalLM (decoder, có generate), AutoModelForSeq2SeqLM (encoder-decoder, có generate). Bài 15-18 sẽ đi chi tiết về Hub, pipeline, AutoTokenizer / AutoModel pattern.

• LLM chat / agent / code: gần như toàn bộ là decoder-only — Claude, GPT, Gemini, Llama, Mistral, Qwen, DeepSeek.
• Embedding / semantic search: encoder backbone vẫn phổ biến cho open-weight (BGE, E5, GTE, multilingual-e5). Một số embedding API thương mại (text-embedding-3-large, voyage-3) chuyển sang decoder backbone với pooling.
• Dịch máy production: NLLB / mBART / MarianMT cho domain rộng + low-resource; GPT-4 / Claude khi cần chất lượng cao và ngôn ngữ phổ biến.
• Tóm tắt: T5 / BART nhỏ cho on-prem; decoder LLM lớn qua API cho free-form summary.
• NER, classification truyền thống: encoder fine-tune vẫn là default trong nhiều pipeline NLP doanh nghiệp.
• Speech, multimodal: phần lớn các mô hình lớn (Whisper, GPT-4o audio, Gemini multimodal) là encoder-decoder hoặc decoder với encoder phụ — vẫn còn vai trò cho stack hai phần.

Bảy bài Module 2 đi từ vấn đề tới kiến trúc hoàn chỉnh:

• Bài 8 — Trước Transformer: RNN / LSTM không scale, vanishing gradient, không song song.
• Bài 9 — Attention: ý tưởng softmax-weighted sum, ba ma trận Q / K / V, encoder-decoder attention.
• Bài 10 — Self-attention: Q, K, V cùng từ X. Causal vs bidirectional.
• Bài 11 — Multi-head: \( h \) head song song, mỗi head học pattern riêng. MQA / GQA cho inference rẻ.
• Bài 12 — Positional Encoding: sin/cos, learned, RoPE, ALiBi. Đưa thông tin vị trí vào model.
• Bài 13 — Transformer block: attention + FFN + residual + LayerNorm. Pre-LN vs post-LN.
• Bài 14 — Architecture variants: encoder-only, decoder-only, encoder-decoder. Đây là bài hiện tại.

Sau Module 2, bạn có thể đọc paper Transformer (Vaswani 2017), BERT (Devlin 2018), GPT (Radford 2018, 2019, Brown 2020), T5 (Raffel 2020) ở mức theo dõi được công thức và lý do thiết kế.

Module 3 (Bài 15+) chuyển sang thực hành: Hugging Face Hub, Transformers library, pipeline, AutoModel / AutoTokenizer, fine-tune. Phần lớn code sẽ là Python.

1. Cho 5 task sau, chọn architecture phù hợp nhất và giải thích ngắn 1-2 câu: (a) phân loại sentiment review sản phẩm trên web Việt Nam, (b) dịch tài liệu kỹ thuật Anh - Việt với độ chính xác cao, (c) build chatbot trợ lý lập trình, (d) trích xuất tên người, tổ chức, địa điểm từ tin tức, (e) tìm bài viết gần nhất với query trong kho 1M bài blog.
2. So sánh BERT-base (110M) và GPT-2 small (~117M) ở: kiến trúc, pretraining objective, ba use case mỗi model làm tốt hơn cái kia. Viết ngắn ~200 chữ.
3. Dùng Hugging Face Transformers (v4.x), load 3 model: bert-base-uncased, gpt2, google/flan-t5-base. In ra: số tham số, số layer, hidden size. Gợi ý: sum(p.numel() for p in model.parameters()).
4. Cho câu tiếng Anh "The Eiffel Tower is located in", dùng GPT-2 sinh tiếp 10 token; dùng BERT điền vào câu "The Eiffel Tower is located in [MASK]." qua fill-mask pipeline; dùng Flan-T5 trả lời prompt "question: Where is the Eiffel Tower located?". Ghi lại 3 output và nhận xét.
5. Lập luận 1 trang (~400 chữ): tại sao decoder-only chiếm ưu thế cho LLM chat 2024-2026 dù về mặt lý thuyết encoder-decoder có vẻ "đầy đủ" hơn? Trích dẫn ít nhất 1 paper hoặc nguồn cụ thể (gợi ý: Brown et al. 2020 GPT-3, Wang et al. 2022).
6. (Đọc thêm) Đọc Section 3 của T5 paper (arXiv:1910.10683) — phần so sánh các pretraining objective. Ghi lại bảng kết quả: trong các objective, span corruption thắng hay thua MLM?

• Ba biến thể Transformer: encoder-only (BERT), decoder-only (GPT), encoder-decoder (T5 / BART). Khác nhau ở cách dùng attention.
• Encoder-only: bidirectional self-attention, pretrain bằng MLM (mask 15% token). Mạnh ở classification, NER, embedding.
• Decoder-only: causal self-attention, pretrain bằng CLM (next-token prediction). Mạnh ở generation, chat, agent. Gần như mọi LLM hiện đại.
• Encoder-decoder: encoder bidirectional + decoder causal + cross-attention. Pretrain span corruption (T5) hoặc denoising (BART). Mạnh ở seq2seq rõ input/output.
• Decoder-only dominate 2024-2026 vì scale tốt, universal next-token, in-context learning, hợp RLHF / chat, inductive bias thấp.
• Vẫn dùng encoder-only cho embedding (BGE, E5) và NLP truyền thống nhỏ. Vẫn dùng encoder-decoder cho dịch low-resource (NLLB) và summarization rẻ.
• Param scale: encoder ~1B; encoder-decoder ~10B; decoder-only ~100B-1T+.
• Hugging Face: AutoModel cho encoder, AutoModelForCausalLM cho decoder, AutoModelForSeq2SeqLM cho encoder-decoder.
• Module 2 (Bài 8-14) kết tại đây. Module 3 (Bài 15+) bắt đầu thực hành với Hugging Face.