ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Kiến trúc tiên tiến

AI Researcher

Flash Attention

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

Attention matrix cho 128K tokens cần 128K × 128K × 4 bytes ≈ 64GB bộ nhớ. GPU A100 chỉ có 80GB. Gần hết! Làm sao tính attention mà không cần lưu toàn bộ ma trận N×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
Registers1 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

Chuỗi 128K tokens. Standard attention cần 128K × 128K × 4 bytes ≈ 64GB cho attention matrix. Flash Attention cần bao nhiêu?

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

Bạn train Llama với torch.compile + F.scaled_dot_product_attention nhưng GPU utilization chỉ 35%, profiler thấy nhiều _aten::attention native. Lỗi đâu?

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×N→write HBMP=softmax(S)→write HBMO=PVS = QK^T \in \mathbb{R}^{N \times N} \xrightarrow{\text{write HBM}} P = \text{softmax}(S) \xrightarrow{\text{write HBM}} O = 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\text{For each block } (Q_b, K_b, V_b): \quad O_b = \text{softmax}(Q_b K_b^T / \sqrt{d}) \cdot V_b

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)m = \max(x) rồi s=∑ex−ms = \sum e^{x - 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′x':

mnew=max⁡(m,x′),snew=em−mnew⋅s+ex′−mnewm_{\text{new}} = \max(m, x'), \quad s_{\text{new}} = e^{m - m_{\text{new}}} \cdot s + e^{x' - m_{\text{new}}}

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 PyTorch
import torch
import torch.nn.functional as F
from torch.nn.attention import SDPBackend, 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 available
output = 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) để debug
with sdpa_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-isolation
from flash_attn import flash_attn_func
output = 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 sizes

import math
import torch

def flash_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.shape
    scale = 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 exp
    m = torch.full((N,), -float("inf"), device=Q.device)  # running max

    Tr = (N + Br - 1) // Br  # số block của Q
    Tc = (N + Bc - 1) // Bc  # số block của K, V

    # OUTER loop trên Q blocks (FA2 đổi thứ tự: outer là Q)
    for i in range(Tr):
        qi_s, qi_e = i * Br, min((i + 1) * Br, N)
        Qi = Q[qi_s:qi_e]                        # (Br, d) — load SRAM
        Oi = 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 blocks
        for j in range(Tc):
            if causal and j * Bc > qi_e - 1:
                break
            kj_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 SRAM
            Sij = Qi @ Kj.transpose(0, 1) * scale  # (Br, Bc)
            if causal:
                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_local
            Oi = alpha[:, None] * Oi + Pij @ Vj
            mi = mi_new
            # ─────────────────────────────────────────────────

        # Ghi kết quả block Q này ra HBM
        O[qi_s:qi_e] = Oi / li[:, None]
        l[qi_s:qi_e] = li
        m[qi_s:qi_e] = mi

    return O, 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ế.

Continue the module

Lesson 3 of 12