Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.
Cơ chế cho phép mô hình tập trung vào các phần quan trọng nhất của đầu vào khi tạo ra mỗi phần đầu ra.
lesson102 minNLP & MultimodalAI Researcher
Thử thách mở đầu
Trước khi nhìn vào công thức, hãy thử tưởng tượng bạn là phiên dịch viên. Bạn đang đọc câu "Tôi yêu Việt Nam quá" và chuẩn bị dịch từng từ ra tiếng Anh. Khi bạn chạm tới từ "Nam", mắt bạn lập tức liếc về đâu?
Chính xác! Để dịch "Nam" thành "Vietnam", não bạn phải đọc kèm "Việt" — hai token này tạo thành một đơn vị ngữ nghĩa. Attention trong neural network làm đúng việc đó: nó học ra rằng token "Nam" nên "nhìn" vào "Việt" với trọng số cao.
Ba bước của scaled dot-product attention
Ba bước của scaled dot-product attention
① Điểm thô eij = Qi · Kj^T / √d_k
② αij = softmax(eij) — tổng = 1
③ contexti = Σj αij · Vj
Khoảnh khắc A-ha
Attention biến mỗi token thành một người hỏi . Token đặt câu hỏi (query), so sánh với mọi token khác (key) để quyết định mình nên nghe ai. Câu trả lời không phải là một từ, mà là một hỗn hợp có trọng số của giá trị các token khác.
Đây là lí do cơ chế này giải bài toán phụ thuộc xa (long-range dependency) mà RNN vật vã suốt thập kỉ — bất kể hai token cách nhau bao xa, attention chỉ mất một phép nhân ma trận để kết nối chúng.
Thử thách nhanh 1
Softmax định nghĩa là exp(x_i) / Σ exp(x_j). Dù điểm thô thế nào, mẫu số chuẩn hoá → tổng phải bằng 1 chính xác (bỏ qua lỗi float). 1.07 → lỗi implementation.
Quy trình 3 bước
1. Tính điểm (Score)
So sánh query với mỗi key để ra điểm 'tương thích'.
eij=dkQi⋅Kj⊤
2. Softmax (Normalize)
Biến điểm thành phân phối xác suất — tổng = 1.
αij=∑kexp(eik)exp(eij)
3. Tổng có trọng số giá trị
Kết hợp các value vector theo trọng số α.
contexti=j∑αijVj
Lý thuyết sâu
Cơ chế Attention được giới thiệu bởi Bahdanau và đồng nghiệp (2014) cho bài toán dịch máy. Ý tưởng ban đầu: cho decoder của mô hình Seq2Seq "nhìn lại" mọi trạng thái ẩn của encoder thay vì chỉ dùng một context vector. Ba năm sau, Vaswani et al. (2017) trong bài "Attention is All You Need" tổng quát hoá thành self-attention: token nhìn vào chính chuỗi của mình. Đây là nền tảng của Transformer, GPT, BERT, và mọi LLM hiện đại.
Một cách nhìn hữu ích: xem attention như một hệ thống truy vấn cơ sở dữ liệu mềm. Query giống như câu truy vấn SQL. Key giống như chỉ mục (index) của mỗi hàng. Value là nội dung. Khác biệt duy nhất: thay vì trả về một hàng duy nhất khớp chính xác, attention trả về một hỗn hợp mờ — trọng số theo độ khớp giữa query và key.
Cụ thể hơn, trong self-attention của Transformer:
Q = X · W_Q: mỗi token biến thành một câu hỏi.
K = X · W_K: mỗi token biến thành một "nhãn" mô tả chính nó.
V = X · W_V: mỗi token biến thành một "nội dung" sẵn sàng được tổng hợp.
Ba ma trận W_Q, W_K, W_V được học qua backprop — mạng tự quyết định thế nào là "khớp".
Vì sao chia √d_k
Tại sao lại cần chia √d_k? (chi tiết toán)
Giả sử Q, K có các thành phần độc lập, kì vọng 0, phương sai 1. Khi đó dot product Q⋅K=∑i=1dkQiKi có phương sai = d_k (tổng của d_k biến độc lập với var = 1).
Cụ thể: E[QiKi]=E[Qi]E[Ki]=0 (do độc lập), và Var(QiKi)=E[Qi2]E[Ki2]=1 . Tổng d_k số hạng độc lập → phương sai cộng lại bằng d_k.
Với d_k = 64, std ≈ 8. Softmax trên logits độ lớn ±8 → xác suất bão hòa sát 0 hoặc 1 → gradient gần như 0. Chia √d_k kéo std về 1, giữ softmax ở vùng "có gradient".
Thử thực nghiệm (theo nguồn bài, chưa kiểm chứng): train không chia √d_k trên d_k = 512 — loss gần như không giảm sau epoch 1. Thêm scale → loss giảm mượt từ epoch đầu.
Var(Q⋅K)=dk⟹Var(dkQ⋅K)=1
Một câu hỏi hay: tại sao không dùng LayerNorm lên logits? Trả lời: được — một số biến thể (NormFormer, SubFormer) làm vậy. Nhưng chia √d_k rẻ hơn nhiều và đủ ổn với khởi tạo Xavier / He.
Multi-head attention
Multi-Head attention: vì sao lại chia đầu?
Một đầu attention duy nhất bị ép phải học một "kiểu" quan hệ. Ví dụ, đầu có thể học cú pháp chủ-vị nhưng bỏ qua quan hệ đồng quy chiếu (coreference), hoặc ngược lại — và không có cách nào ép nó làm cả hai cùng lúc một cách cân bằng.
Multi-head chia không gian d thành h đầu, mỗi đầu có d_k = d/h chiều. Mỗi đầu có các ma trận chiếu W_Q^(h), W_K^(h), W_V^(h) riêng → có thể phát triển "sở trường" khác nhau. Khi phân tích GPT-2 (Clark et al. 2019), người ta quan sát thấy:
Đầu A học quan hệ chủ ngữ ↔ động từ (SVO).
Đầu B học đồng quy chiếu ("he" → "John").
Đầu C nhìn vào token kế liền (copy pattern — kiểu n-gram).
Đầu D chú ý vào token đặc biệt như [CLS], dấu chấm câu ("no-op" attention).
Đầu E chú ý theo khoảng cách cố định (chu kì — giống convolution).
Output h đầu được concat lại thành vector d chiều, rồi đi qua một ma trận chiếu W_O cuối. Tức là mạng tổng hợp nhiều góc nhìn thành một biểu diễn duy nhất.
MultiHead(Q,K,V)=Concat(head1,…,headh)WO
headi=Attention(QWiQ,KWiK,VWiV)
Một nghịch lí thú vị: các nghiên cứu gần đây (Michel et al. 2019) cho thấy nhiều đầu có thể prune đi mà model hầu như không giảm chất lượng — gợi ý rằng multi-head thực chất đóng vai trò như một dạng regularization / over-parameter giúp model dễ train hơn.
Code, độ phức tạp và debug
attention_from_scratch.py
importtorchimporttorch.nnasnnimporttorch.nn.functionalasFimportmathclassScaledDotProductAttention(nn.Module):"""Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V."""defforward(self,q,k,v,mask=None):# q: [B, H, L_q, d_k]# k: [B, H, L_k, d_k]# v: [B, H, L_k, d_v]d_k=q.size(-1)# 1) Raw scores = Q · K^T / sqrt(d_k)scores=torch.matmul(q,k.transpose(-2,-1))/math.sqrt(d_k)# scores: [B, H, L_q, L_k]# 2) Optional causal mask (decoder)ifmaskisnotNone:scores=scores.masked_fill(mask==0,float("-inf"))# 3) Softmax → attention weightsattn=F.softmax(scores,dim=-1)# tổng theo L_k = 1# 4) Weighted sum of Vout=torch.matmul(attn,v)# out: [B, H, L_q, d_v]returnout,attnclassMultiHeadAttention(nn.Module):def__init__(self,d_model:int,n_heads:int):super().__init__()assertd_model%n_heads==0self.d_model=d_modelself.n_heads=n_headsself.d_k=d_model// n_headsself.W_q=nn.Linear(d_model,d_model)self.W_k=nn.Linear(d_model,d_model)self.W_v=nn.Linear(d_model,d_model)self.W_o=nn.Linear(d_model,d_model)self.attn=ScaledDotProductAttention()defforward(self,q,k,v,mask=None):B=q.size(0)# 1) Linear projection → split into heads# [B, L, d_model] → [B, H, L, d_k]q=self.W_q(q).view(B,-1,self.n_heads,self.d_k).transpose(1,2)k=self.W_k(k).view(B,-1,self.n_heads,self.d_k).transpose(1,2)v=self.W_v(v).view(B,-1,self.n_heads,self.d_k).transpose(1,2)# 2) Scaled dot-product attention trên tất cả các đầu song songout,attn=self.attn(q,k,v,mask=mask)# 3) Concat các đầuout=out.transpose(1,2).contiguous().view(B,-1,self.d_model)# 4) Projection cuốireturnself.W_o(out),attn# ─── Ví dụ nhanh trên câu "Tôi yêu Việt Nam quá"if__name__=="__main__":seq_len,d_model,n_heads=5,64,4mha=MultiHeadAttention(d_model,n_heads)# Giả lập embedding của 5 tokenx=torch.randn(1,seq_len,d_model)# [B=1, L=5, d=64]# Self-attention: Q, K, V đều = xcontext,attn=mha(x,x,x)print("Context shape:",context.shape)# [1, 5, 64]print("Attention shape:",attn.shape)# [1, 4, 5, 5]print("Sum per row (đầu 0):",attn[0,0].sum(dim=-1))# tensor([1., 1., 1., 1., 1.])
Một điểm thú vị nữa: trong các mô hình ngôn ngữ lớn hiện đại (GPT-4, Claude, Gemini), attention không chỉ được dùng để kết nối các token trong cùng một câu — nó còn kết nối các đoạn văn bản cách xa hàng nghìn token. Khi model đọc một tài liệu dài và trả lời câu hỏi về đoạn đầu, về mặt cơ học thì attention của token trả lời phải nhìn được về token của đoạn đầu. Đây là lí do kích thước context window (32K, 200K, 1M token) trở thành chỉ số quan trọng của LLM.
Tuy nhiên, chất lượng attention không đều trên mọi khoảng cách. Các thí nghiệm "needle in a haystack" (tìm kim trong đống rơm) cho thấy nhiều mô hình có độ chính xác giảm đáng kể ở giữa context dài — hiện tượng gọi là "lost in the middle" (Liu et al. 2023). Nghiên cứu hiện nay tập trung vào cải thiện positional encoding (RoPE, ALiBi), attention sparsity, và training strategy để attention phân bố đều hơn.
attention_visualize.py
importmatplotlib.pyplotaspltimportseabornassnsimporttorch# Cho ma trận attention đã có từ model (shape [L, L])defplot_attention(attn_matrix,tokens):"""Vẽ heatmap attention như visualization ở phía trên."""fig,ax=plt.subplots(figsize=(6,5))sns.heatmap(attn_matrix.cpu().detach(),xticklabels=tokens,yticklabels=tokens,cmap="YlOrBr",# amber scale — giống UI của bài nàyannot=True,fmt=".2f",cbar_kws={"label":"attention weight"},ax=ax,)ax.set_xlabel("Key (từ được nhìn)")ax.set_ylabel("Query (từ đang hỏi)")ax.set_title("Attention matrix")plt.tight_layout()returnfig# Pipeline đầy đủ cho 1 câudefattention_for_sentence(model,tokenizer,sentence):tokens=tokenizer.tokenize(sentence)ids=torch.tensor([tokenizer.convert_tokens_to_ids(tokens)])withtorch.no_grad():outputs=model(ids,output_attentions=True)# outputs.attentions: tuple[L_layers] of [B, H, L, L]# Lấy layer cuối, trung bình qua các đầuattn=outputs.attentions[-1][0].mean(dim=0)# [L, L]returnplot_attention(attn,tokens)# sentence = "Tôi yêu Việt Nam quá"# attention_for_sentence(model, tokenizer, sentence)# ─── Bonus: so sánh attention ở các layer khác nhau ───defattention_across_layers(model,tokenizer,sentence):"""Tạo subplot cho mỗi layer — xem attention evolving theo chiều sâu."""tokens=tokenizer.tokenize(sentence)ids=torch.tensor([tokenizer.convert_tokens_to_ids(tokens)])withtorch.no_grad():outputs=model(ids,output_attentions=True)n_layers=len(outputs.attentions)fig,axes=plt.subplots(1,n_layers,figsize=(3*n_layers,3),sharey=True)forlayer_idx,attn_layerinenumerate(outputs.attentions):# Trung bình qua các đầu của layer nàyattn=attn_layer[0].mean(dim=0).cpu()ax=axes[layer_idx]ifn_layers>1elseaxessns.heatmap(attn,xticklabels=tokens,yticklabels=tokensiflayer_idx==0elseFalse,cmap="YlOrBr",cbar=False,ax=ax,square=True,)ax.set_title(f"Layer {layer_idx}")fig.suptitle("Attention từ nông đến sâu")plt.tight_layout()returnfig# ─── Bonus 2: temperature sweep (giống slider ở phần viz) ───deftemperature_sweep(raw_scores,tokens,temperatures=(0.2,1.0,5.0)):"""Vẽ 3 heatmap với T khác nhau để so sánh độ 'quyết đoán'."""fig,axes=plt.subplots(1,len(temperatures),figsize=(4*len(temperatures),4))forax,Tinzip(axes,temperatures):scaled=raw_scores/Tattn=torch.softmax(scaled,dim=-1)sns.heatmap(attn,xticklabels=tokens,yticklabels=tokens,cmap="YlOrBr",annot=True,fmt=".2f",cbar=False,ax=ax,)ax.set_title(f"T = {T}")returnfig
Lịch sử và tương lai
Dòng chảy tiến hoá của attention
2014 — Bahdanau Attention
Bổ sung attention vào Seq2Seq RNN. Điểm số dùng MLP nhỏ (additive). Chứng minh attention cải thiện BLEU đáng kể cho bản dịch câu dài.
2015 — Luong Attention
Đơn giản hoá thành dot-product (nhanh hơn). Đề xuất global vs local attention — local chỉ nhìn cửa sổ nhỏ quanh từ hiện tại.
2017 — Transformer (Attention is All You Need)
Xoá RNN hoàn toàn. Chỉ dùng self-attention + multi-head + positional encoding. Mở đường cho kỉ nguyên LLM.
2018-2020 — BERT, GPT-2, T5
Ba kiến trúc chính: encoder-only (BERT), decoder-only (GPT), encoder-decoder (T5). Tất cả chỉ là attention + FFN.
2022 — FlashAttention
Tổ chức lại memory access để giảm I/O giữa HBM và SRAM của GPU. Attention O(n²) vẫn đúng về mặt lý thuyết, nhưng thực tế nhanh gấp 2-4 lần.
2023+ — Linear & Sparse Attention
Mamba (SSM), RWKV, Hyena, Longformer — các kiến trúc thay thế attention bằng cơ chế O(n) hoặc O(n log n) để mở rộng context hàng triệu token.
Mặc dù vậy, tại thời điểm 2026, attention vẫn là trái tim của gần như mọi LLM thương mại. Các cải tiến tập trung vào tối ưu (FlashAttention, paged attention trong vLLM) hoặc lai ghép (attention cho context ngắn, SSM cho context dài — như Jamba, Griffin).
Thử thách nhanh 2
Attention O(n²) × batch × heads × layers cộng dồn rất nhanh. FlashAttention và gradient checkpointing giúp tiết kiệm VRAM đáng kể. Đây là lí do LLM hiện đại dùng context window có giới hạn và đầu tư vào sparse attention.
Tóm tắt
Ghi nhớ về Attention
Mỗi token là một query; nó so khớp với mọi key để chọn 'nên nghe ai'.
Ba bước: Q·K^T / √d_k → softmax → Σ α·V. Tổng mỗi hàng attention = 1.
Chia √d_k giữ variance của điểm thô ~ 1 để softmax không bão hoà.
Softmax temperature nhỏ → quyết đoán (one-hot); lớn → dàn đều.
Multi-head = h đầu song song; mỗi đầu học một loại quan hệ khác.
Độ phức tạp O(n²) là rào cản context dài — FlashAttention / sparse attention giải quyết.