- Lớp chú ý chuẩn ghi ma trận điểm N × N ra bộ nhớ chính của GPU rồi đọc lại. Với chuỗi dài, việc đọc ghi này chậm hơn cả phép nhân.
- FlashAttention chia truy vấn, khóa, giá trị thành khối vừa bộ nhớ trên chip, tính xong từng khối rồi mới ghi kết quả. Không có ma trận N × N nào được lưu.
- Mẹo giữ cho kết quả đúng là softmax trực tuyến: giữ giá trị lớn nhất và tổng đang chạy, sửa lại phần đã cộng khi gặp điểm lớn hơn.
- Kết quả là chính xác, không xấp xỉ. FlashAttention-2 nhanh hơn khoảng 2 lần nhờ chia việc tốt hơn trên GPU.
Code trong bài là Python 3 với numpy, chỉ để thấy thuật toán; bản thật viết bằng CUDA. Bài giả định bạn đã biết công thức chú ý; nếu chưa, đọc bài kiến trúc transformer. Số liệu lấy từ bản PDF của ba bài báo, đọc ngày 12/11/2026.
Lớp chú ý chuẩn tốn ở đâu
Với chuỗi N token và mỗi đầu chú ý d chiều, lớp chú ý tính:
\[\begin{aligned} S &= QK^{\top} / \sqrt{d} \\ P &= \mathrm{softmax}(S), \quad O = PV \end{aligned}\]
Cách cài thông thường làm ba bước riêng: tính S rồi ghi ra bộ nhớ, đọc S để tính P rồi ghi P, đọc P để tính O. S và P đều cỡ N × N. Bài báo FlashAttention chỉ ra rằng thứ làm chậm không phải số phép nhân, mà là số lần đọc ghi bộ nhớ chính.
GPU có hai tầng bộ nhớ chênh nhau rất xa. Theo bài báo, A100 có 40-80 GB bộ nhớ băng thông cao (HBM) với tốc độ 1,5-2,0 TB/s, và 192 KB bộ nhớ SRAM trên chip ở mỗi bộ xử lý trong số 108 bộ, tốc độ ước khoảng 19 TB/s. Bài báo tóm lại: SRAM nhanh hơn HBM khoảng một bậc độ lớn nhưng nhỏ hơn nhiều bậc. Ma trận điểm của một chuỗi dài 16384 token ở dạng 16 bit đã chiếm 512 MiB cho mỗi đầu, không thể nằm trong SRAM.
Bài báo đếm được lớp chú ý chuẩn cần Θ(N·d + N²) lần truy cập HBM, còn FlashAttention cần Θ(N²·d²/M), với M là cỡ SRAM. Với d từ 64 tới 128 và M khoảng 100 KB, d² nhỏ hơn M nhiều lần, nên số lần truy cập giảm nhiều lần.
Chia khối và tính lại
FlashAttention dùng hai kỹ thuật cổ điển. Thứ nhất là chia khối (tiling): đưa từng khối của Q, K, V từ HBM vào SRAM, tính phần chú ý của khối đó, rồi gộp vào kết quả với hệ số chuẩn hóa đúng. Mọi bước, từ nhân ma trận, softmax tới nhân với V, chạy trong một lần gọi nhân GPU (kernel), nên S và P không bao giờ ra tới HBM.
Thứ hai là tính lại (recomputation) khi lan truyền ngược. Huấn luyện cần S và P để tính đạo hàm. Thay vì lưu chúng, FlashAttention chỉ lưu đầu ra O và hai số thống kê của softmax cho mỗi hàng, rồi tính lại S và P từng khối khi cần. Phép tính nhiều hơn nhưng đọc ghi ít hơn, nên vẫn nhanh hơn.
Hình 2 của bài báo đo trên GPT-2 medium (chuỗi dài 1024 token, 16 đầu, mỗi đầu 64 chiều, 64 chuỗi mỗi lô) trên A100, tính cả lượt xuôi và lượt ngược. Cách chuẩn: 66,6 tỉ phép tính (GFLOP), đọc ghi HBM 40,3 GB, mất 41,7 ms. FlashAttention: 75,2 GFLOP, chỉ 4,4 GB, mất 7,3 ms. Tính nhiều hơn mà nhanh gấp gần 6 lần, vì nút thắt nằm ở bộ nhớ.
Softmax trực tuyến
Khó khăn của việc chia khối nằm ở softmax: mẫu số cần tổng của cả hàng, còn khi đọc khối đầu ta chưa biết các khối sau. Milakov và Gimelshein (2018) đưa ra cách tính mẫu số trong một lượt. Softmax an toàn thường cần ba lượt qua dữ liệu (tìm giá trị lớn nhất, cộng mẫu số, tính kết quả), tức 4 lần truy cập bộ nhớ cho mỗi phần tử. Cách trực tuyến giữ giá trị lớn nhất m và tổng ℓ đang chạy; khi gặp số lớn hơn thì nhân tổng cũ với \(e^{m_{\text{cũ}} - m_{\text{mới}}}\). Số lần truy cập còn 3, và bài báo đo được softmax nhanh hơn tới 1,3 lần.
FlashAttention mở rộng mẹo này cho cả đầu ra. Sau khi đọc khối khóa thứ j, mỗi hàng cập nhật:
\[\begin{aligned} m_j &= \max\big(m_{j-1},\ \operatorname{rowmax}(S_j)\big) \\ \ell_j &= e^{m_{j-1} - m_j}\,\ell_{j-1} + \operatorname{rowsum}\big(e^{S_j - m_j}\big) \\ O_j &= e^{m_{j-1} - m_j}\,O_{j-1} + e^{S_j - m_j}\,V_j \end{aligned}\]
Hết các khối thì chia O cho ℓ. Hình 1 chạy tay với một truy vấn và hai khóa. Khóa 1 có điểm 0, giá trị 8: m = 0, ℓ = 1, O = 8. Khóa 2 có điểm ln 3, lớn hơn, giá trị 4: phần cũ phải nhân với \(e^{0 - \ln 3} = 1/3\), nên ℓ = 1/3 + 1 = 4/3 và O = 8/3 + 4 = 20/3. Chia ra được 5, đúng bằng cách thường: softmax của (0; ln 3) là (1/4; 3/4), và 1/4·8 + 3/4·4 = 5.
Thử bằng numpy
Đoạn code dưới đây cài lớp chú ý chuẩn, softmax trực tuyến và lớp chú ý chia khối theo thứ tự vòng lặp của FlashAttention-2: vòng ngoài theo khối truy vấn, vòng trong theo khối khóa và giá trị.
"""Chú ý chuẩn và chú ý chia khối kiểu FlashAttention (softmax trực tuyến), viết bằng numpy.
Mục đích: thấy hai cách cho cùng kết quả, và cách chia khối không bao giờ giữ cả ma trận điểm N x N."""
import numpy as np
def chu_y_chuan(Q, K, V):
"""softmax(Q K^T / sqrt(d)) V, giữ nguyên ma trận điểm S và ma trận xác suất P cỡ N x N."""
S = Q @ K.T / np.sqrt(Q.shape[1])
P = np.exp(S - S.max(axis=1, keepdims=True))
P /= P.sum(axis=1, keepdims=True)
return P @ V
def softmax_truc_tuyen(x):
"""Một lượt qua x để có max m và tổng d (Milakov, Gimelshein 2018): khi m tăng, nhân d cũ với e^(m_cũ - m_mới)."""
m, d = -np.inf, 0.0
for v in x:
m_moi = max(m, v)
d = d * np.exp(m - m_moi) + np.exp(v - m_moi)
m = m_moi
return np.exp(np.asarray(x, dtype=float) - m) / d
def chu_y_chia_khoi(Q, K, V, Br=64, Bc=64):
"""Vòng ngoài theo khối Br hàng của Q, vòng trong theo khối Bc hàng của K, V (thứ tự của FlashAttention-2).
Mỗi hàng giữ max m, tổng l và đầu ra O chưa chia; chỉ chia cho l một lần ở cuối.
Trả về đầu ra và số phần tử của khối điểm lớn nhất từng tạo ra."""
N, d = Q.shape
O = np.zeros((N, V.shape[1]))
khoi_lon_nhat = 0
for i in range(0, N, Br):
Qi = Q[i:i + Br]
m = np.full(len(Qi), -np.inf)
l = np.zeros(len(Qi))
Oi = np.zeros((len(Qi), V.shape[1]))
for j in range(0, K.shape[0], Bc):
S = Qi @ K[j:j + Bc].T / np.sqrt(d) # chỉ một khối Br x Bc
khoi_lon_nhat = max(khoi_lon_nhat, S.size)
m_moi = np.maximum(m, S.max(axis=1))
P = np.exp(S - m_moi[:, None])
he_so = np.exp(m - m_moi) # sửa phần đã cộng khi max tăng
l = he_so * l + P.sum(axis=1)
Oi = he_so[:, None] * Oi + P @ V[j:j + Bc]
m = m_moi
O[i:i + Br] = Oi / l[:, None]
return O, khoi_lon_nhat
def bo_nho_ma_tran_diem(N, so_dau=1, so_byte=2):
"""Số byte để giữ ma trận điểm N x N (fp16: 2 byte mỗi số) cho so_dau đầu chú ý của một chuỗi."""
return N * N * so_dau * so_byte
if __name__ == "__main__":
# Ví dụ của Hình 1: một truy vấn, hai khóa đến lần lượt, mỗi khối một khóa.
q = np.array([[1.0]])
K = np.array([[0.0], [np.log(3)]])
V = np.array([[8.0], [4.0]])
print("Chuẩn: %.4f | chia khối: %.4f" % (chu_y_chuan(q, K, V)[0, 0], chu_y_chia_khoi(q, K, V, Br=1, Bc=1)[0][0, 0]))
print("Softmax trực tuyến của [3, 1, 4, 1, 5]:", np.round(softmax_truc_tuyen([3, 1, 4, 1, 5]), 4))
rng = np.random.default_rng(0)
N, d = 1024, 64
Q, K, V = (rng.normal(size=(N, d)) for _ in range(3))
chuan = chu_y_chuan(Q, K, V)
for B in (16, 64, 256):
O, lon = chu_y_chia_khoi(Q, K, V, Br=B, Bc=B)
print("Khối %3d: sai khác lớn nhất %.1e, khối điểm lớn nhất %6d số (ma trận đủ: %d số)"
% (B, np.abs(O - chuan).max(), lon, N * N))
print("Ma trận điểm fp16, N = 16384: %d MiB một đầu, %d GiB cho 32 đầu"
% (bo_nho_ma_tran_diem(16384) // 2**20, bo_nho_ma_tran_diem(16384, 32) // 2**30))
Ví dụ của Hình 1 cho 5,0000 ở cả hai cách. Với N = 1024 và d = 64, cách chia khối lệch cách chuẩn cỡ \(10^{-16}\), tức sai số làm tròn, ở mọi cỡ khối 16, 64, 256. Khối điểm lớn nhất từng tạo ra chỉ có 256, 4096 hay 65536 số, so với 1.048.576 số của ma trận đầy đủ. Dòng cuối tính bộ nhớ của ma trận điểm 16 bit khi N = 16384: 512 MiB một đầu, 16 GiB cho 32 đầu.
Khi tự viết, bạn nên so với một bản tính thẳng bằng vòng lặp trên dữ liệu nhỏ, với cỡ khối không chia hết N và với điểm rất lớn như 1000 để chắc phép trừ giá trị lớn nhất chống được tràn số.
FlashAttention-2 nhanh hơn nhờ đâu
Bản đầu đã nhanh 2-4 lần, nhưng theo Dao (2023) chỉ đạt 25-40% tốc độ tính lý thuyết của GPU, trong khi phép nhân ma trận tối ưu đạt 80-90%. Bài báo chỉ ra ba chỗ sửa. Thứ nhất, giảm phép tính không phải nhân ma trận: A100 nhân ma trận 16 bit tới 312 TFLOP/s nhưng phép tính 32 bit thường chỉ 19,5 TFLOP/s, nên mỗi phép tính lẻ đắt gấp 16 lần. FlashAttention-2 bỏ bớt các phép chia giữa chừng, chỉ chia cho ℓ một lần ở cuối. Thứ hai, chia việc theo cả chiều dài chuỗi, không chỉ theo lô và đầu chú ý, để GPU bận đủ khi chuỗi dài và lô nhỏ. Thứ ba, trong một khối, chia Q cho các nhóm luồng (warp) thay vì chia K, V, nên các nhóm không phải gom kết quả qua bộ nhớ dùng chung.
Kết quả: nhanh khoảng 2 lần so với bản đầu, đạt 50-73% tốc độ lý thuyết của A100. Khi huấn luyện trọn mô hình kiểu GPT 1,3 và 2,7 tỉ tham số, FlashAttention-2 đạt tới 225 TFLOP/s mỗi GPU, tức 72% mức tận dụng phép tính của mô hình.
Kết quả, giới hạn và cách dùng
Bài báo đầu tiên báo cáo BERT-large huấn luyện nhanh hơn kỷ lục MLPerf 1.1 15%, GPT-2 nhanh gấp 3 lần bản HuggingFace, và bộ đo Long-Range Arena nhanh gấp 2,4 lần. Bộ nhớ tăng tuyến tính theo độ dài chuỗi, nên mô hình đọc được chuỗi dài hơn: transformer đầu tiên vượt mức đoán bừa ở bài Path-X dài 16 nghìn token (61,4%).
Giới hạn cần nhớ: số phép tính vẫn tăng theo bình phương độ dài chuỗi, FlashAttention chỉ bỏ phần bộ nhớ bình phương. Bài báo cũng ghi rằng với chuỗi dài hơn 1000 token, vài cách chú ý xấp xỉ như Linformer bắt đầu nhanh hơn, đổi lại kết quả không còn chính xác.
Trong thực tế bạn hiếm khi gọi thẳng FlashAttention. Tài liệu PyTorch 2.15 (đọc 12/11/2026) ghi hàm scaled_dot_product_attention có ba cách cài, trong đó có FlashAttention-2; trên GPU NVIDIA, hàm tự chọn cách tối ưu theo đầu vào, và có trình quản lý ngữ cảnh sdpa_kernel để bật, tắt từng cách. Lúc sinh chữ, phần nặng chuyển sang đọc khóa và giá trị đã lưu của các token trước, xem bài KV cache.
- Gọi FlashAttention là chú ý xấp xỉ: kết quả bằng cách tính chuẩn, chỉ khác sai số làm tròn.
- Nghĩ rằng FlashAttention giảm số phép tính: nó giảm đọc ghi bộ nhớ, còn phép tính lượt ngược thậm chí tăng vì phải tính lại.
- Quên nhân lại phần đã cộng khi giá trị lớn nhất thay đổi: kết quả sai mà không báo lỗi.
- Chia cho ℓ ở từng khối rồi cộng dồn: đúng nhưng tốn phép tính lẻ, đúng chỗ FlashAttention-2 đã bỏ.
Câu hỏi thường gặp
Flash attention là gì?
Là cách tính lớp chú ý theo khối trong bộ nhớ nhanh trên chip GPU, không ghi ma trận điểm N × N ra bộ nhớ chính, cho kết quả chính xác nhưng nhanh hơn và ít tốn bộ nhớ hơn.
FlashAttention có làm thay đổi kết quả của mô hình không?
Không, ngoài sai số làm tròn số thực. Đây là chú ý chính xác, khác các phương pháp chú ý thưa hay hạng thấp vốn là xấp xỉ.
Online softmax là gì?
Là cách tính mẫu số của softmax trong một lượt: giữ giá trị lớn nhất và tổng đang chạy, khi gặp giá trị lớn hơn thì nhân tổng cũ với e mũ hiệu hai giá trị lớn nhất.
Tôi có cần tự cài FlashAttention không?
Thường là không. PyTorch đã có sẵn trong hàm scaled_dot_product_attention và tự chọn cách cài nhanh nhất khi chạy trên GPU NVIDIA.
Học tiếp
FlashAttention lo phần tính chú ý trên cả chuỗi; khi sinh từng token, bài KV cache giải thích phần bộ nhớ còn lại, và bài mã hóa vị trí nói cách mô hình biết thứ tự token. Nếu muốn học AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.
Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.
Nguồn tham khảo
- Dao và cộng sự (2022), FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness, arXiv 2205.14135v2 (PDF, đọc 12/11/2026)
- Dao (2023), FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning, arXiv 2307.08691v1 (PDF, đọc 12/11/2026)
- Milakov, Gimelshein (2018), Online normalizer calculation for softmax, arXiv 1805.02867v2 (PDF, đọc 12/11/2026)
- PyTorch 2.15 docs: torch.nn.functional.scaled_dot_product_attention (đọc 12/11/2026)


