Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.
Thuật toán tối ưu tính attention nhanh hơn và tiết kiệm bộ nhớ GPU bằng kỹ thuật tiling
lesson115 minKiến trúc tiên tiếnAI Researcher
Dự đoán
Flash Attention! Chia Q, K, V thành blocks nhỏ vừa SRAM (20MB, nhanh gấp 10–100× HBM). Tính attention từng block tại chỗ, dùng online softmax để tích lũy kết quả. Không cần lưu ma trận N×N → O(N) bộ nhớ thay vì O(N²). Và nhanh hơn 2–4× vì giảm IO! Quan trọng: kết quả CHÍNH XÁC, không xấp xỉ — thuật toán đồng nhất về toán học với standard attention, chỉ khác cách tính.
Bộ nhớ attention và tốc độ
Với N=128K, fp16: Standard 32 GB · Flash ~0.5 MB.
FA3 trên H100 đạt ~75% peak FP16 (theo nguồn bài, chưa kiểm chứng), hoặc 1.2 PFLOPS với FP8.
Khoảnh khắc Aha
Flash Attention không thay đổi toán học — kết quả CHÍNH XÁC giống standard attention. Nó chỉ thay đổi cách tính: chia thành blocks nhỏ, tính trong SRAM (nhanh), dùng online softmax để tích lũy. Giảm IO = giảm thời gian thật sự!
Insight sâu hơn: GPU hiện đại tắc ở bộ nhớ (memory-bound) chứ không phải tính toán (compute-bound). Tỷ lệ FLOPS/bandwidth của A100 là ~150; tức GPU có thể làm 150 phép nhân cho mỗi byte đọc. Attention chuẩn có arithmetic intensity thấp hơn giá trị đó → bỏ phí compute. Flash Attention nâng arithmetic intensity bằng cách “tái dùng” data trong SRAM nhiều lần — gần đến peak compute của GPU.
Bộ nhớ GPU — các tầng
Tầng bộ nhớ
Độ trễ
Dung lượng · băng thông
Registers
1 chu kỳ
256 KB / SM · ~80 TB/s
SRAM (shared memory)
~20 chu kỳ
~20 MB / GPU · ~19 TB/s
L2 cache
~200 chu kỳ
40 MB · ~5 TB/s
HBM (device memory)
~400 chu kỳ
80 GB · ~2 TB/s
DRAM (host)
hàng µs
≥ 128 GB · ~50 GB/s (PCIe)
Bộ nhớ chia sẻ trong mỗi SM. Nhanh hơn HBM ~10 lần. Flash Attention giữ block Q, K, V ở đây.
Bộ nhớ chính GPU. Lớn, nhưng 'xa' — phần lớn thời gian GPU chờ HBM.
RAM hệ thống. Đi qua PCIe/NVLink — rất chậm so với GPU memory.
Thử thách 1
Flash Attention không lưu ma trận N×N. Chỉ cần 1 block Q, K, V (~100KB) và running stats O(N) cho online softmax (running max + running sum, mỗi cái N floats). Tổng vào khoảng 0.5–1 MB thay vì 64GB — giảm hơn 100,000 lần! Đây là lý do LLM có context window 128K+ tokens như GPT-4 Turbo hay Claude trở nên khả thi.
Thử thách 2
Khi PyTorch không thể chọn Flash kernel (dtype sai, head_dim > 128, mask custom không nằm trong causal/padding), nó âm thầm fallback về math/mem-efficient kernel. Profiler hiện native attention op chứ không phải Flash. Cách khắc phục: ép fp16/bf16, dùng với torch.nn.attention.sdpa_kernel(SDPBackend.FLASH_ATTENTION), hoặc dùng FlexAttention để compile mask custom thành Flash kernel.
IO bottleneck và tiling
Flash Attention (Dao et al., 2022) là thuật toán IO-aware exact attention. Không thay đổi toán học, chỉ tối ưu cách tính trên hardware. Ý tưởng cốt lõi: phần lớn thời gian GPU không làm toán — nó đợi data đi lại giữa HBM và SRAM. Tránh round-trip đó là thắng.
Standard Attention — IO bottleneck
S=QKT∈RN×Nwrite HBMP=softmax(S)write HBMO=PV
3 lần ghi/đọc HBM cho ma trận N×N. Memory = O(N²). Đây là HBM trip thứ 1 (ghi S), thứ 2 (đọc S + ghi P), thứ 3 (đọc P + ghi O) — cộng dồn rất đáng kể khi N lớn.
Flash Attention — tiling + online softmax
For each block (Qb,Kb,Vb):Ob=softmax(QbKbT/d)⋅Vb
Mỗi block tính hoàn toàn trong SRAM. Online softmax cập nhật running max/sum. Memory = O(N). Không có ma trận P cỡ N×N bao giờ xuất hiện trong HBM!
Online softmax
Online softmax — kỹ thuật cốt lõi
Để tính softmax ổn định, ta cần m=max(x) rồi s=∑ex−m. Online softmax cho phép tính dần khi chỉ thấy một phần của x mỗi lần. Khi gặp giá trị mới x′:
mnew=max(m,x′),snew=em−mnew⋅s+ex′−mnew
Output cũng được rescale tương ứng khi m thay đổi. Kết quả cuối cùng hoàn toàn chính xác — không sai số so với tính một lần với toàn bộ hàng.
Phiên bản và các hiểu lầm
Code mẫu
flash_attention_usage.py
# Cách dùng Flash Attention trong PyTorchimporttorchimporttorch.nn.functionalasFfromtorch.nn.attentionimportSDPBackend,sdpa_kernel# PyTorch 2.0+ có built-in Flash Attention!# Tự động chọn Flash Attention khi có thể.q=torch.randn(1,8,4096,64,device="cuda",dtype=torch.float16)# (B, heads, N, d_k)k=torch.randn(1,8,4096,64,device="cuda",dtype=torch.float16)v=torch.randn(1,8,4096,64,device="cuda",dtype=torch.float16)# Tự động dùng Flash Attention nếu availableoutput=F.scaled_dot_product_attention(q,k,v,is_causal=True)# Memory: O(N) thay vì O(N²)# Speed: 2–4× nhanh hơn naive implementation# Ép dùng Flash backend (báo lỗi nếu không được) để debugwithsdpa_kernel(SDPBackend.FLASH_ATTENTION):output=F.scaled_dot_product_attention(q,k,v,is_causal=True)# Hoặc dùng thư viện flash-attn trực tiếp (chi tiết hơn)# pip install flash-attn --no-build-isolationfromflash_attnimportflash_attn_funcoutput=flash_attn_func(q,k,v,causal=True,dropout_p=0.0,softmax_scale=1.0/(64**0.5))# So sánh memory:# N=4096: Standard ~64MB, Flash ~0.5MB (giảm 128×)# N=128K: Standard ~64GB, Flash ~0.5MB (giảm 130,000×)
pseudocode_flash_attention.py
# Pseudocode Flash Attention forward pass# Tham khảo: Dao et al. 2022, Algorithm 1# N: seq length, d: head dim, Br/Bc: block row/col sizesimportmathimporttorchdefflash_attention_forward(Q,K,V,Br=64,Bc=64,causal=False):"""
Q, K, V: (N, d) tensors trên HBM
Trả về O: (N, d) — tương đương softmax(QK^T / sqrt(d)) V
Bộ nhớ thêm: O(N) (running stats), KHÔNG phải O(N^2)
"""N,d=Q.shapescale=1.0/math.sqrt(d)# Output + running stats, chỉ O(N) bộ nhớO=torch.zeros_like(Q)# (N, d)l=torch.zeros(N,device=Q.device)# running sum of expm=torch.full((N,),-float("inf"),device=Q.device)# running maxTr=(N+Br-1)// Br # số block của QTc=(N+Bc-1)// Bc # số block của K, V# OUTER loop trên Q blocks (FA2 đổi thứ tự: outer là Q)foriinrange(Tr):qi_s,qi_e=i*Br,min((i+1)*Br,N)Qi=Q[qi_s:qi_e]# (Br, d) — load SRAMOi=torch.zeros(qi_e-qi_s,d,device=Q.device)li=torch.zeros(qi_e-qi_s,device=Q.device)mi=torch.full((qi_e-qi_s,),-float("inf"),device=Q.device)# INNER loop trên K,V blocksforjinrange(Tc):ifcausalandj*Bc>qi_e-1:breakkj_s,kj_e=j*Bc,min((j+1)*Bc,N)Kj=K[kj_s:kj_e]# (Bc, d)Vj=V[kj_s:kj_e]# (Bc, d)# Attention scores cho tile này — hoàn toàn trong SRAMSij=Qi@Kj.transpose(0,1)*scale# (Br, Bc)ifcausal:mask=torch.arange(kj_s,kj_e,device=Q.device)>torch.arange(qi_s,qi_e,device=Q.device)[:,None]Sij.masked_fill_(mask,-float("inf"))# ── Online softmax ───────────────────────────────mij_local=Sij.max(dim=-1).values# (Br,)mi_new=torch.maximum(mi,mij_local)Pij=torch.exp(Sij-mi_new[:,None])# (Br, Bc)lij_local=Pij.sum(dim=-1)# (Br,)alpha=torch.exp(mi-mi_new)# rescale factor cho O cũli=alpha*li+lij_localOi=alpha[:,None]*Oi+Pij@Vjmi=mi_new# ─────────────────────────────────────────────────# Ghi kết quả block Q này ra HBMO[qi_s:qi_e]=Oi/li[:,None]l[qi_s:qi_e]=lim[qi_s:qi_e]=mireturnO,l,m# l, m dùng lại ở backward
Backward và MQA / GQA
Standard backward cần lưu ma trận P = softmax(S) trong forward để tính gradient. Đó là O(N²). Flash Attention thay vào đó lưu chỉ running stats (l, m) kích thước O(N). Ở backward, ta tính lại P tại chỗ cho từng block — đổi memory lấy compute thêm, nhưng compute đó diễn ra trong SRAM nên rẻ. Tổng thể, backward chỉ tốn O(N) memory phụ và nhanh tương đương hoặc nhanh hơn standard.
MQA và GQA giảm số K/V heads để tiết kiệm KV cache memory và bandwidth trong decode. Flash Attention vẫn áp dụng được — thực tế, FA2+ còn thêm tối ưu đặc biệt cho MQA/GQA khi broadcast K/V qua các query heads. Llama 2/3 dùng GQA + FA2, và Llama-3.1 405B với 128K context là kết quả trực tiếp của combo này.
Ứng dụng và pitfalls
Ứng dụng thực tế
LLM context 128K+ tokens: GPT-4 Turbo, Claude 200K, Gemini 1.5 (1M tokens) đều dùng Flash Attention hoặc biến thể. Không có Flash, KV cache + attention matrix sẽ vượt VRAM.
Huấn luyện Llama / Mistral / Qwen: Flash Attention 2 tăng throughput training ~2×, tiết kiệm ~40% memory — nghĩa là có thể fit batch lớn hơn hoặc sequence dài hơn trên cùng một cluster.
Serving vLLM, TGI, SGLang: Các engine serving đều dùng Flash Attention cho prefill (encode prompt dài) kết hợp paged attention cho decode. Giảm tail latency đáng kể.
Vision Transformer trên ảnh lớn: Ảnh 1024×1024 patch 16×16 → 4K tokens. Flash giúp train ViT-Huge trên ảnh HD không OOM.
Protein folding / AlphaFold-like: Sequence amino acid có thể dài hàng ngàn. Memory-efficient attention là bắt buộc.
Whisper / ASR long-form: Xử lý audio dài 30 phút = chuỗi token dài. Flash Attention giữ memory dưới ngưỡng GPU tiêu dùng.
Pitfall thường gặp
Kỳ vọng Flash thần kỳ với chuỗi ngắn: Dưới 1K tokens, Flash Attention có thể không nhanh hơn — compute đủ rẻ, overhead tile management chiếm tỷ trọng lớn. Speedup thực sự lộ ra khi N ≥ 4K.
Dùng sai dtype: Flash Attention chính thức yêu cầu fp16 hoặc bf16. Nếu vô tình chạy fp32, PyTorch sẽ fallback về kernel thường — tưởng đã dùng Flash nhưng không. Luôn kiểm tra với profiler.
Head dim > 128 không hỗ trợ: FA1/FA2 yêu cầu head_dim ≤ 128 (phải vừa SRAM). FA3 mở rộng lên 256 trên H100. Nếu mô hình có head lớn, phải fallback hoặc chia.
Mask phức tạp: Custom attention mask (không phải causal/padding) khó tận dụng Flash. Dùng FlexAttention (PyTorch 2.5+) — compile mask thành kernel Flash tối ưu.
Tóm tắt
Flash Attention = exact attention (không xấp xỉ) nhưng IO-efficient: chia thành blocks, tính trong SRAM nhanh gấp 10× HBM.
Giảm bộ nhớ O(N²) → O(N): không lưu ma trận attention N×N đầy đủ, chỉ giữ running stats cho online softmax.
Nhanh hơn 2–4× nhờ giảm HBM IO trips. Insight: GPU tắc ở memory bandwidth, không phải compute — giảm IO quan trọng hơn giảm FLOPs.
Online softmax: cập nhật running max + running sum qua mỗi block, rescale output tương ứng → kết quả đồng nhất với softmax một lần.
FA1 (2022) → FA2 (2023, 2× nhanh hơn, song song tốt hơn) → FA3 (2024, tận dụng H100 TMA/WGMMA/FP8, ~75% peak).
Mọi LLM hiện đại dùng Flash Attention — GPT-4, Claude, Llama, Mistral, Gemini. Cho phép context 128K–1M tokens kinh tế.