AI & Machine Learning

KV cache: vì sao mô hình sinh chữ nhanh, và tốn bao nhiêu bộ nhớ

KV cache là phần bộ nhớ giữ khóa (key) và giá trị (value) của mọi token mô hình đã đọc, để khi sinh token mới chỉ phải tính khóa, giá trị cho đúng một token. Nhờ vậy sinh chữ nhanh hơn rất nhiều, đổi lại bộ nhớ tăng theo độ dài ngữ cảnh: với OPT-13B, mỗi token tốn 800 KB. Bài này tính dung lượng đó từ công thức, giải thích GQA và PagedAttention của vLLM theo bài báo gốc, và kiểm bằng numpy rằng có cache hay không thì kết quả vẫn y hệt.

Ý chính
  • Khi sinh chữ, khóa và giá trị của các token cũ không đổi. KV cache giữ chúng lại, nên mỗi bước chỉ tính cho token mới; kết quả y hệt khi tính lại cả chuỗi.
  • Dung lượng = 2 × số lớp × số đầu khóa × số chiều mỗi đầu × số byte, nhân với số token và số chuỗi trong lô. OPT-13B tốn 800 KB mỗi token.
  • MQA và GQA cho nhiều đầu truy vấn dùng chung một đầu khóa, giá trị, giảm KV cache nhiều lần mà gần giữ chất lượng.
  • vLLM cấp bộ nhớ KV theo khối 16 token như trang nhớ của hệ điều hành, gần như không lãng phí, và chia sẻ được phần đầu chung.

Code trong bài là Python 3 với numpy. Bài giả định bạn đã biết truy vấn, khóa, giá trị trong lớp chú ý; nếu chưa, đọc bài kiến trúc transformer. Số liệu lấy từ bản PDF của các bài báo và trang tài liệu vLLM, đọc ngày 12/11/2026.

Sinh từng token thì lặp lại phép tính nào

Mô hình ngôn ngữ sinh chữ tuần tự: đọc đoạn đầu vào, sinh một token, nối token đó vào chuỗi, rồi sinh token tiếp theo. Pope và cộng sự chia việc này thành hai giai đoạn: đọc đầu vào (prefill), xử lý mọi token của đoạn đầu cùng lúc; và sinh (decode), mỗi lượt chạy mô hình chỉ ra một token.

Ở lớp chú ý nhân quả, token ở vị trí t chỉ nhìn các token từ 1 tới t. Khóa và giá trị của token 1 tới t − 1 phụ thuộc đúng những token đó, nên không đổi khi có thêm token mới. Nếu không lưu lại, bước thứ t phải nhân lại t token với ma trận khóa và ma trận giá trị. Sinh 1000 token như vậy cần 1 + 2 + ... + 1000 = 500.500 lần chiếu; có cache thì chỉ 1000 lần, mỗi token đúng một lần. Ở bước mới, mô hình chỉ tính truy vấn, khóa, giá trị của token mới, nối khóa và giá trị vào cache, rồi cho truy vấn chấm với mọi khóa đã lưu.

KV cache: mỗi bước chỉ tính khóa, giá trị của token mới t1 t2 t3 t4 token mới K V k1 v1 k2 v2 k3 v3 k4 v4 đã lưu vừa thêm q4 chấm với k1…k4, rồi cộng v1…v4 đầu ra giống hệt tính lại cả chuỗi Không cache: 1000 token cần 500.500 lần chiếu K, V Có cache: mỗi token chiếu đúng 1 lần, 1000 token cần 1000 lần Giá phải trả: OPT-13B cần 800 KB mỗi token, 2048 token ≈ 1,6 GB
KV cache mỗi bước chỉ tính K, V của token mới t1 t2 t3 t4 token mới K V k1 v1 k2 v2 k3 v3 k4 v4 đã lưu mới q4 chấm với k1…k4, rồi cộng v1…v4 đầu ra giống hệt tính lại cả chuỗi Không cache: 1000 token cần 500.500 lần chiếu K, V Có cache: 1000 lần OPT-13B: 800 KB mỗi token, 2048 token ≈ 1,6 GB
Hình 1. Bước sinh token thứ 4: k1, v1 tới k3, v3 đã nằm trong cache, chỉ tính thêm k4, v4; q4 chấm với cả bốn khóa rồi cộng bốn giá trị theo trọng số. Đầu ra giống hệt khi tính lại cả chuỗi, đổi lại phải giữ khóa, giá trị của mọi token trong bộ nhớ.

KV cache tốn bao nhiêu bộ nhớ

Mỗi lớp lưu một vectơ khóa và một vectơ giá trị cho mỗi đầu khóa của mỗi token. Số byte cho một token là:

\[\text{KV} = 2 \times n_{\text{layers}} \times n_{\text{kv}} \times d_{\text{head}} \times b\]

với b là số byte mỗi số (2 với dạng 16 bit). Nhân thêm số token trong ngữ cảnh và số chuỗi chạy cùng lúc là ra tổng. Bài báo vLLM tính cho OPT-13B: 2 × 5120 (chiều ẩn, tức 40 đầu × 128 chiều) × 40 lớp × 2 byte = 800 KB mỗi token. Một yêu cầu dài 2048 token cần tới khoảng 1,6 GB. Trên GPU A100 40 GB chạy mô hình 13 tỉ tham số, trọng số chiếm khoảng 65% bộ nhớ và KV cache chiếm gần 30%.

Ở quy mô lớn hơn, KV cache còn vượt cả trọng số. Pope và cộng sự ghi rằng với mô hình trên 500 tỉ tham số dùng chú ý nhiều đầu, 512 chuỗi chạy cùng lúc, mỗi chuỗi dài 2048 token, cần 3 TB KV cache, gấp 3 lần kích thước tham số. Mỗi token sinh ra, toàn bộ cache phải được đọc lên từ bộ nhớ một lần, trong lúc phần tính toán gần như ngồi chờ. Vì thế, ở giai đoạn sinh, tốc độ bị giới hạn bởi băng thông bộ nhớ nhiều hơn số phép nhân.

Bạn có thể tính cho mô hình mình dùng từ bảng kiến trúc. Mixtral 8x7B có 32 lớp, 8 đầu khóa, mỗi đầu 128 chiều, nên mỗi token tốn 2 × 32 × 8 × 128 × 2 = 131.072 byte, tức 128 KiB; ngữ cảnh 32.768 token cần 4 GiB cho một chuỗi. Bộ nhớ cho trọng số thì tính riêng, như trong bài chạy AI trên máy cá nhân.

MQA và GQA: cho nhiều đầu dùng chung khóa

Cách giảm KV cache trực tiếp nhất là giảm \(n_{\text{kv}}\). Chú ý đa truy vấn (multi-query attention, MQA) giữ nhiều đầu truy vấn nhưng chỉ một đầu khóa và một đầu giá trị dùng chung, nên KV cache nhỏ đi đúng bằng số đầu. Bảng 1 của Pope và cộng sự, với PaLM 540B trên 64 chip và 30% bộ nhớ dành cho KV cache, cho độ dài ngữ cảnh tối đa: chú ý nhiều đầu được 1320 token khi chạy 128 chuỗi cùng lúc; MQA với cách chia dữ liệu tối ưu của bài báo được 43.000 token, tức dài hơn tới 32 lần.

MQA có thể làm giảm chất lượng. Ainslie và cộng sự đề xuất chú ý truy vấn theo nhóm (grouped-query attention, GQA): chia đầu truy vấn thành nhóm, mỗi nhóm dùng chung một đầu khóa, giá trị. Họ còn chuyển mô hình nhiều đầu có sẵn sang GQA bằng cách lấy trung bình các ma trận khóa, giá trị rồi huấn luyện thêm chỉ 5% lượng tính toán ban đầu. Với T5-XXL, bản nhiều đầu mất 1,51 giây mỗi mẫu, điểm trung bình 47,2; MQA mất 0,24 giây, điểm 46,6; GQA với 8 nhóm mất 0,28 giây, điểm 47,1. Mixtral là một ví dụ GQA: 32 đầu truy vấn, 8 đầu khóa, nên KV cache nhỏ hơn 4 lần so với khi mỗi đầu có khóa riêng.

vLLM và PagedAttention: cấp bộ nhớ theo khối

vLLM là hệ thống phục vụ mô hình ngôn ngữ do nhóm Kwon và cộng sự xây dựng, dựa trên một thuật toán chú ý mới là PagedAttention. Vấn đề họ nhắm tới: KV cache của mỗi yêu cầu lớn, lớn dần rồi biến mất, và không biết trước sẽ dài bao nhiêu. Các hệ thống cũ cấp sẵn một vùng liền nhau đủ cho độ dài tối đa, nên phần lớn bị bỏ trống hoặc vụn ra. Đo trong bài báo cho thấy chỉ 20,4% tới 38,2% bộ nhớ KV cache của các hệ thống đó thật sự chứa trạng thái của token.

PagedAttention mượn ý tưởng trang nhớ của hệ điều hành. KV cache được chia thành khối cố định, mỗi khối chứa khóa, giá trị của một số token, mặc định 16 token theo bài báo. Mỗi chuỗi có một bảng khối ánh xạ khối logic sang khối vật lý nằm rải rác trong bộ nhớ, và chỉ xin thêm khối khi khối cuối đã đầy. Một chuỗi dài 70 token cần 5 khối, thừa 10 chỗ, thay vì giữ sẵn 2048 chỗ.

Bảng khối còn cho phép chia sẻ. Khi một yêu cầu sinh nhiều câu trả lời từ cùng một đoạn đầu vào, các câu trả lời trỏ tới cùng khối của đoạn đầu; chỉ khi một câu cần ghi vào khối dùng chung thì khối đó mới được chép ra (sao chép khi ghi, copy-on-write). Với tìm kiếm chùm (beam search), bài báo ghi tiết kiệm được tới 55% bộ nhớ. Tổng hợp lại, vLLM tăng thông lượng 2-4 lần so với các hệ thống trước ở cùng độ trễ.

Lượng tử hóa KV cache

Cách thứ ba là giảm b, số byte mỗi số. Tài liệu vLLM (đọc 12/11/2026) cho lưu KV cache ở dạng FP8, một byte mỗi số, để chứa được nhiều token hơn, tăng thông lượng và cho ngữ cảnh dài hơn. Thang đo có thể đặt cho cả tensor hoặc cho từng đầu chú ý. Không hiệu chỉnh thì mọi thang bằng 1,0; tài liệu khuyên hiệu chỉnh bằng một bộ dữ liệu để chính xác nhất, và cho phép giữ nguyên độ chính xác ở vài lớp nhạy cảm. Thang đo, điểm không và sai số làm tròn được giải thích trong bài lượng tử hóa mô hình.

Thử bằng numpy

Đoạn code dưới đây dựng một lớp chú ý nhân quả có thể chạy như MHA, GQA hay MQA, sinh 20 bước theo hai cách: có cache và tính lại cả chuỗi mỗi bước. Nó cũng tính dung lượng KV cache và số khối nhớ.

"""Sinh từng token có KV cache và không có cache, bằng numpy; dung lượng KV cache; chia sẻ đầu khóa (GQA);
số khối nhớ kiểu PagedAttention của vLLM."""
import math

import numpy as np


def softmax(z):
    e = np.exp(z - z.max())
    return e / e.sum()


class LopChuY:
    """Một lớp chú ý nhân quả: n_dau đầu truy vấn, n_kv đầu khóa và giá trị.
    n_kv = n_dau là chú ý nhiều đầu (MHA), n_kv = 1 là MQA, ở giữa là GQA."""

    def __init__(self, d, n_dau, n_kv, rng):
        assert n_dau % n_kv == 0
        self.h, self.hkv, self.dh = n_dau, n_kv, d // n_dau
        self.Wq = rng.normal(size=(d, n_dau * self.dh)) / math.sqrt(d)
        self.Wk = rng.normal(size=(d, n_kv * self.dh)) / math.sqrt(d)
        self.Wv = rng.normal(size=(d, n_kv * self.dh)) / math.sqrt(d)
        self.Wo = rng.normal(size=(n_dau * self.dh, d)) / math.sqrt(d)
        self.so_lan_chieu = 0          # đếm số token được nhân với Wk, Wv

    def _chu_y(self, q, K, V):
        """q: (h, dh) của vị trí đang xét; K, V: (t, hkv, dh). Mỗi nhóm h/hkv đầu truy vấn dùng chung một đầu K, V."""
        nhom = self.h // self.hkv
        ra = np.empty((self.h, self.dh))
        for a in range(self.h):
            g = a // nhom
            ra[a] = softmax(K[:, g] @ q[a] / math.sqrt(self.dh)) @ V[:, g]
        return ra.reshape(-1) @ self.Wo

    def _kv(self, X):
        self.so_lan_chieu += len(X)
        return ((X @ self.Wk).reshape(len(X), self.hkv, self.dh), (X @ self.Wv).reshape(len(X), self.hkv, self.dh))

    def tinh_lai(self, X):
        """Không cache: chiếu lại K, V cho mọi token của X rồi tính đầu ra ở vị trí cuối."""
        K, V = self._kv(X)
        return self._chu_y((X[-1] @ self.Wq).reshape(self.h, self.dh), K, V)

    def buoc_co_cache(self, x, cache):
        """Có cache: chỉ chiếu token mới x, nối k, v của nó vào cache rồi tính chú ý."""
        k, v = self._kv(x[None, :])
        cache["K"] = k if cache["K"] is None else np.concatenate([cache["K"], k])
        cache["V"] = v if cache["V"] is None else np.concatenate([cache["V"], v])
        return self._chu_y((x @ self.Wq).reshape(self.h, self.dh), cache["K"], cache["V"])


def sinh(lop, X0, so_buoc, co_cache):
    """Đọc đoạn mở đầu X0 rồi sinh thêm so_buoc vectơ; đầu vào bước sau là tanh của đầu ra bước trước."""
    X, ra = list(X0), []
    cache = {"K": None, "V": None}
    if co_cache:
        for x in X0[:-1]:
            lop.buoc_co_cache(x, cache)          # giai đoạn đọc đầu vào (prefill)
    for _ in range(so_buoc):
        y = lop.buoc_co_cache(X[-1], cache) if co_cache else lop.tinh_lai(np.array(X))
        ra.append(y)
        X.append(np.tanh(y))
    return np.array(ra)


def kv_byte_moi_token(so_lop, so_dau_kv, chieu_dau, so_byte=2):
    """2 (khóa và giá trị) x số lớp x số đầu khóa x số chiều mỗi đầu x số byte mỗi số."""
    return 2 * so_lop * so_dau_kv * chieu_dau * so_byte


def so_khoi(so_token, co_khoi=16):
    """Số khối KV cần cho một chuỗi khi cấp phát theo khối (vLLM mặc định 16 token mỗi khối)."""
    return -(-so_token // co_khoi)


if __name__ == "__main__":
    rng = np.random.default_rng(0)
    X0 = rng.normal(size=(5, 32))
    for ten, h, hkv in (("MHA", 8, 8), ("GQA", 8, 2), ("MQA", 8, 1)):
        a, b = LopChuY(32, h, hkv, np.random.default_rng(1)), LopChuY(32, h, hkv, np.random.default_rng(1))
        y_cache, y_lai = sinh(a, X0, 20, True), sinh(b, X0, 20, False)
        print("%s: sai khác lớn nhất %.1e | số token được chiếu K, V: có cache %d, không cache %d"
              % (ten, np.abs(y_cache - y_lai).max(), a.so_lan_chieu, b.so_lan_chieu))

    opt = kv_byte_moi_token(40, 40, 128)
    print("OPT-13B: %d byte = %d KiB mỗi token; 2048 token = %d KiB" % (opt, opt // 1024, opt * 2048 // 1024))
    mix = kv_byte_moi_token(32, 8, 128)
    print("Mixtral 8x7B (8 đầu KV): %d KiB mỗi token, 32768 token = %d GiB; nếu 32 đầu KV: %d GiB"
          % (mix // 1024, mix * 32768 // 2**30, kv_byte_moi_token(32, 32, 128) * 32768 // 2**30))
    print("Chuỗi 70 token: %d khối, thừa %d chỗ; đặt trước 2048 chỗ thì thừa %d" % (so_khoi(70), so_khoi(70) * 16 - 70, 2048 - 70))

Ở cả ba kiểu chú ý, hai cách lệch nhau cỡ \(10^{-16}\), tức chỉ sai số làm tròn. Với đoạn đầu 5 token và 20 bước sinh, cách có cache chiếu khóa, giá trị 24 lần (4 token đầu vào cộng 20 bước), cách tính lại chiếu 5 + 6 + ... + 24 = 290 lần. Các dòng sau in 819.200 byte (800 KiB) mỗi token cho OPT-13B, 128 KiB mỗi token và 4 GiB cho 32.768 token với Mixtral, và 16 GiB nếu Mixtral có 32 đầu khóa riêng.

Muốn chắc code cache của mình đúng, hãy so đầu ra từng bước với chú ý nhân quả tính một lần trên cả chuỗi cuối cùng bằng ma trận có mặt nạ tam giác. Hai kết quả phải trùng ở mọi vị trí.

KV cache khác prompt caching thế nào

KV cache cơ bản chỉ phục vụ một lần sinh và được giải phóng khi yêu cầu kết thúc. Tính năng prompt caching của các API giữ KV cache lâu hơn, ở tầng dịch vụ: phần xử lý của đoạn đầu prompt giống hệt nhau được dùng lại giữa nhiều lần gọi để giảm phí và thời gian. Bài báo vLLM mô tả cơ chế gần với nó: dành sẵn các khối vật lý cho một đoạn đầu dùng chung, và yêu cầu nào bắt đầu bằng đoạn đó chỉ cần trỏ tới các khối ấy.

Cẩn thận
  • Ước bộ nhớ chỉ theo trọng số mà quên KV cache: với ngữ cảnh dài và nhiều người dùng cùng lúc, phần này có thể lớn hơn cả trọng số.
  • Tính KV cache theo số đầu truy vấn thay vì số đầu khóa: mô hình dùng GQA nhỏ hơn nhiều lần so với con số đó.
  • Quên rằng KV cache nhân theo số chuỗi trong lô: 10 người dùng cùng lúc là 10 bộ cache.
  • Nghĩ rằng KV cache làm thay đổi câu trả lời: nó chỉ tránh tính lại, kết quả giống hệt.

Câu hỏi thường gặp

KV cache là gì?

Là bộ nhớ giữ khóa và giá trị của mọi token đã đọc trong lớp chú ý, để khi sinh token mới mô hình chỉ tính cho token đó thay vì tính lại cả chuỗi.

Vì sao KV cache tăng theo độ dài ngữ cảnh?

Vì mỗi token đã đọc để lại một vectơ khóa và một vectơ giá trị ở mỗi lớp. Ngữ cảnh dài gấp đôi thì cache lớn gấp đôi.

vLLM là gì?

Là hệ thống phục vụ mô hình ngôn ngữ dùng PagedAttention: cấp bộ nhớ KV theo khối nhỏ như trang nhớ, gần như không lãng phí, nên chạy được lô lớn hơn và tăng thông lượng 2-4 lần theo bài báo gốc.

Lượng tử hóa KV cache có làm câu trả lời kém đi không?

Có thể, vì khóa và giá trị bị làm tròn. Tài liệu vLLM khuyên hiệu chỉnh thang đo bằng dữ liệu và cho phép giữ nguyên độ chính xác ở các lớp nhạy cảm.

Học tiếp

KV cache làm mỗi bước sinh rẻ hơn nhưng vẫn phải chạy mô hình lớn từng token một. Bài speculative decoding giải thích cách để mô hình nhỏ đoán trước nhiều token cho mô hình lớn duyệt một lượt, còn bài FlashAttention nói cách tính chú ý trên cả chuỗi mà không giữ ma trận điểm. 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.

Muốn học bài bản cùng giảng viên?

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í.

Xem Khóa AI

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483