AI & Machine Learning

Lượng tử hóa mô hình: từ 16 bit xuống 8 bit, 4 bit thì mất gì

Lượng tử hóa (quantization) là cách lưu trọng số, đôi khi cả giá trị trung gian, của mô hình bằng số nguyên ít bit thay cho số thực 16 hay 32 bit: mỗi số được chia cho một thang rồi làm tròn về mốc gần nhất. Mô hình nhẹ đi 2 tới 4 lần, đổi lại mỗi số lệch tối đa nửa bước, và một giá trị ngoại lai có thể làm hỏng cả tensor. Bài này đọc bốn bài báo gốc, đo sai số bằng numpy, và giải thích vì sao thang theo nhóm, GPTQ, QLoRA giữ được chất lượng ở 4 bit.

Ý chính
  • Lượng tử hóa ánh xạ số thực r sang số nguyên q theo công thức r = S(q − Z): S là thang đo, Z là điểm không. Mỗi số lệch tối đa nửa thang.
  • Một thang cho cả tensor thì một giá trị ngoại lai làm thang phình to và các số nhỏ thành 0. Từ khoảng 6,7 tỉ tham số, mô hình ngôn ngữ có những chiều ngoại lai như vậy.
  • Thang theo hàng, theo kênh hay theo nhóm giới hạn ảnh hưởng của ngoại lai, đổi lại tốn thêm bit để lưu thang: nhóm 64 số với thang 32 bit tốn thêm 0,5 bit mỗi tham số.
  • GPTQ làm tròn có bù sai số nên giữ được chất lượng ở 3-4 bit; QLoRA tinh chỉnh được mô hình 65 tỉ tham số đã nén 4 bit trên một GPU 48 GB.

Code trong bài là Python 3 với numpy. Cách ước bộ nhớ (số tham số nhân số bit chia 8) và lời khuyên chọn mức 4 bit khi chạy trên máy cá nhân đã có trong bài chạy AI trên máy cá nhân; bài này nói phép tính bên trong và cái mất đi. Số liệu lấy từ bản PDF của bốn bài báo, đọc ngày 12/11/2026.

Lượng tử hóa là phép ánh xạ nào

Jacob và cộng sự (2018) đặt yêu cầu: mọi phép tính khi chạy mô hình chỉ dùng số nguyên. Muốn vậy, phép ánh xạ giữa số thực r và số nguyên q phải là hàm bậc nhất:

\[r = S\,(q - Z)\]

S là thang đo (scale), một số thực dương; Z là điểm không (zero-point), chính là số nguyên ứng với số thực 0. Nhờ Z, số 0 được biểu diễn đúng tuyệt đối, điều bài báo cần vì các phép tính trên ảnh hay đệm số 0 quanh biên. Nếu dữ liệu nằm trong [−1; 3] và dùng 8 bit không dấu, S = 4/255 và Z = round(63,75) = 64: số 0 thành q = 64 rồi giải ngược ra đúng 0.

Với trọng số phân bố quanh 0, cách thường gặp là lượng tử hóa đối xứng (absmax), Z = 0:

\[\begin{aligned} S &= \frac{\max_i |x_i|}{2^{b-1} - 1} \\ q_i &= \mathrm{round}(x_i / S), \quad \hat{x}_i = S \, q_i \end{aligned}\]

Ở 8 bit, mẫu số là 127, đúng như cách LLM.int8() mô tả. Phép làm tròn về mốc gần nhất bảo đảm mỗi số lệch không quá \(S/2\). Hình 1 làm tay ở 4 bit (mẫu số 7) với bốn số −1; 0; 0,3; 0,62. Số lớn nhất là 1 nên mốc cách nhau 1/7; 0,3 thành 2/7 (lệch 0,014), 0,62 thành 4/7 (lệch 0,049).

Lượng tử hóa 4 bit: đưa mỗi số về mốc gần nhất Lớn nhất là 1: các mốc cách nhau 1/7 −1 0 0,3 0,62 lệch 0,014 lệch 0,049 Thêm một số ngoại lai 6,0: các mốc cách nhau 6/7 6,0 ở xa −1 thành −0,86 0,3 thành 0 0,62 thành 0,86 Cách chữa: mỗi hàng, kênh hoặc nhóm 64 số một thang; giữ ngoại lai ở 16 bit
Lượng tử hóa 4 bit đưa mỗi số về mốc gần nhất Lớn nhất là 1: mốc cách nhau 1/7 0 1 0,3 0,62 thành 2/7 và 4/7, lệch 0,014 và 0,049 Thêm ngoại lai 6,0: mốc cách 6/7 6,0 0,3 0,62 0,3 thành 0 0,62 thành 0,86 Cách chữa: mỗi hàng, kênh hoặc nhóm 64 số một thang; giữ ngoại lai ở 16 bit
Hình 1. Lượng tử hóa 4 bit bốn số −1; 0; 0,3; 0,62: với thang 1/7, mỗi số lệch tối đa nửa bước. Thêm một số 6,0 thì thang thành 6/7, và 0,3 bị làm tròn thành 0.

Giảm số bit thì mất gì

Mỗi bit bớt đi làm số mốc giảm một nửa, nên bước nhảy và sai số làm tròn tăng gấp đôi. Ở 8 bit, mất mát thường nhỏ. Bảng 4.1 của Jacob và cộng sự: ResNet-50 trên ImageNet đạt 76,4% khi dùng số thực và 74,9% khi chạy hoàn toàn bằng số nguyên 8 bit. Đó là kết quả có huấn luyện mô phỏng lượng tử hóa, tức cho mô hình làm quen với sai số làm tròn ngay khi học.

Ở 4 bit và 3 bit, làm tròn thẳng (round-to-nearest, RTN) bắt đầu hỏng. Bảng 3 của bài GPTQ đo perplexity của OPT-175B trên WikiText2: bản 16 bit là 8,34; RTN 4 bit lên 10,54; GPTQ 4 bit chỉ 8,37. Ở 3 bit, RTN sụp hẳn, perplexity cỡ 7300, trong khi GPTQ còn 8,68. Bài báo còn ghi một xu hướng có lợi: mô hình càng lớn thường càng dễ lượng tử hóa.

Giá trị ngoại lai

Một thang cho cả tensor nghĩa là số lớn nhất quyết định bước nhảy cho mọi số. Hình 1 cho thấy chuyện gì xảy ra: thêm số 6,0 vào bốn số trên, thang thành 6/7, và 0,3 thành 0, còn 0,62 thành 0,86. LLM.int8() viết đúng điều này: chỉ một giá trị ngoại lai cũng làm giảm độ chính xác của mọi giá trị khác.

Với mô hình ngôn ngữ lớn, đây không phải chuyện hiếm. Dettmers và cộng sự phát hiện các đặc trưng có độ lớn gấp tới 20 lần các chiều khác. Ở quy mô 6,7 tỉ tham số, mỗi chuỗi có khoảng 150.000 giá trị ngoại lai nhưng chúng chỉ nằm trong 6 chiều đặc trưng. Đặt các chiều đó về 0 làm xác suất chú ý cao nhất giảm hơn 20% và perplexity tệ đi 600-1000%, dù chúng chỉ chiếm khoảng 0,1% đặc trưng đầu vào.

Cách chữa của LLM.int8() là tách phép nhân ma trận làm hai phần: các chiều có giá trị vượt ngưỡng 6,0 nhân bằng số 16 bit, phần còn lại, hơn 99,9% giá trị, nhân bằng 8 bit. Với mô hình tới 13 tỉ tham số, số chiều ngoại lai không quá 7, nên phần thêm chỉ tốn khoảng 0,1% bộ nhớ. Bộ nhớ vẫn giảm gần một nửa: BLOOM-176B nhẹ đi 1,96 lần, và mô hình 175 tỉ tham số chạy ở 8 bit không giảm chất lượng.

Thang theo hàng, theo kênh và theo nhóm

Cách đơn giản để giới hạn ngoại lai là cho mỗi phần của tensor một thang riêng. LLM.int8() dùng thang theo vectơ: mỗi hàng của ma trận đầu vào và mỗi cột của ma trận trọng số một thang, vì mỗi tích vô hướng chỉ gặp đúng một hàng và một cột. Thang theo kênh (channel-wise) của mạng tích chập là cùng ý, và GPTQ dùng thang bất đối xứng cho từng hàng của ma trận trọng số.

Ở 4 bit, người ta chia nhỏ hơn nữa: mỗi nhóm (block) vài chục tới vài trăm số liền nhau một thang. Cái giá là phải lưu thang. QLoRA tính rõ: thang 32 bit cho nhóm 64 số tốn thêm 32/64 = 0,5 bit mỗi tham số. Lượng tử hóa kép (double quantization) lượng tử luôn các thang thành 8 bit, nhóm 256 thang một thang 32 bit, còn 8/64 + 32/(64 × 256) ≈ 0,127 bit, tiết kiệm khoảng 0,37 bit, tức chừng 3 GB với mô hình 65 tỉ tham số. Bài GPTQ cũng ghi nhóm 128 số tốn thêm khoảng 0,15 bit và giảm perplexity thêm khoảng 0,1.

GPTQ và QLoRA

GPTQ (Frantar và cộng sự) không làm tròn từng trọng số độc lập. Nó lượng tử hóa lần lượt từng cột của ma trận trọng số, và sau mỗi bước điều chỉnh các trọng số chưa lượng tử để bù phần sai vừa gây ra, dùng thông tin bậc hai (ma trận Hessian nghịch đảo) ước từ dữ liệu. Dữ liệu hiệu chỉnh chỉ là 128 đoạn ngẫu nhiên dài 2048 token lấy từ bộ C4. Cả mô hình 175 tỉ tham số được lượng tử hóa xuống 3-4 bit trong khoảng 4 giờ GPU, đủ nhỏ để chạy trên một GPU, và nhanh hơn bản 16 bit khoảng 3,25 lần trên A100, 4,5 lần trên A6000.

QLoRA (Dettmers và cộng sự, 2023) đưa lượng tử hóa vào khâu tinh chỉnh: giữ mô hình gốc ở 4 bit, đông cứng, và chỉ huấn luyện các bộ chuyển hạng thấp LoRA (xem bài fine-tuning và LoRA). Kiểu số mới NormalFloat 4 bit (NF4) đặt các mốc theo phân vị của phân phối chuẩn thay vì cách đều, vì trọng số đã huấn luyện thường phân bố chuẩn quanh 0. Kết hợp với lượng tử hóa kép, tinh chỉnh mô hình 65 tỉ tham số giảm từ hơn 780 GB bộ nhớ GPU xuống dưới 48 GB.

Thử bằng numpy

Đoạn code dưới đây cài lượng tử hóa đối xứng và bất đối xứng, thang theo hàng và theo nhóm, cách tách cột ngoại lai kiểu LLM.int8(), và tính số bit thật sự khi lưu thang.

"""Lượng tử hóa số thực sang số nguyên bằng numpy: đối xứng (absmax), bất đối xứng (thang S và điểm không Z),
sai số, giá trị ngoại lai, thang theo hàng và theo nhóm, và số bit thật sự cho mỗi tham số khi lưu thang."""
import numpy as np


def luong_tu_doi_xung(x, so_bit=8, truc=None):
    """absmax: thang = max|x| / (2^(b-1) - 1), q = round(x / thang). truc=1: mỗi hàng một thang."""
    qmax = 2 ** (so_bit - 1) - 1
    m = np.max(np.abs(x), axis=truc, keepdims=truc is not None)
    thang = np.where(m == 0, 1.0, m / qmax)
    q = np.clip(np.round(x / thang), -qmax, qmax).astype(np.int32)
    return q, thang


def giai_luong_tu(q, thang, diem_khong=0):
    """Đổi ngược ra số thực: r = S * (q - Z)."""
    return thang * (q - diem_khong)


def luong_tu_bat_doi_xung(x, so_bit=8):
    """r = S (q - Z) với q trong [0, 2^b - 1]; khoảng [min, max] được nới để chứa số 0, Z = round(-min / S)."""
    lo, hi = min(float(x.min()), 0.0), max(float(x.max()), 0.0)
    qmax = 2 ** so_bit - 1
    S = (hi - lo) / qmax
    Z = int(round(-lo / S))
    q = np.clip(np.round(x / S) + Z, 0, qmax).astype(np.int32)
    return q, S, Z


def theo_nhom(w, so_bit=4, co_nhom=64):
    """Chia w thành các nhóm co_nhom số liền nhau, mỗi nhóm một thang riêng; trả về bản đã giải lượng tử."""
    q, thang = luong_tu_doi_xung(w.reshape(-1, co_nhom), so_bit, truc=1)
    return giai_luong_tu(q, thang).reshape(w.shape)


def tach_ngoai_lai(X, nguong=6.0, so_bit=8):
    """Kiểu LLM.int8(): cột nào có giá trị tuyệt đối vượt ngưỡng thì giữ nguyên số thực, các cột còn lại lượng tử theo hàng."""
    ngoai = np.any(np.abs(X) > nguong, axis=0)
    ra = X.copy()
    q, thang = luong_tu_doi_xung(X[:, ~ngoai], so_bit, truc=1)
    ra[:, ~ngoai] = giai_luong_tu(q, thang)
    return ra, int(ngoai.sum())


def sai_so(x, x_hat):
    """Sai số trung bình bình phương."""
    return float(np.mean((np.asarray(x) - x_hat) ** 2))


def bit_moi_tham_so(so_bit, co_nhom, bit_thang=32):
    """Số bit thật sự cho mỗi tham số khi mỗi nhóm co_nhom số lưu thêm một thang bit_thang bit."""
    return so_bit + bit_thang / co_nhom


if __name__ == "__main__":
    x = np.array([-1.0, 0.0, 0.3, 0.62])
    q, s = luong_tu_doi_xung(x, so_bit=4)
    print("4 bit: thang %.4f, q =" % s, q.tolist(), "giải ra", np.round(giai_luong_tu(q, s), 4).tolist())
    x2 = np.append(x, 6.0)
    q2, s2 = luong_tu_doi_xung(x2, so_bit=4)
    print("Thêm 6,0: thang %.4f, q =" % s2, q2.tolist(), "giải ra", np.round(giai_luong_tu(q2, s2), 4).tolist())
    qa, S, Z = luong_tu_bat_doi_xung(np.array([-1.0, 0.0, 0.7, 3.0]))
    print("Bất đối xứng [-1, 3]: S = %.6f, Z = %d, q =" % (S, Z), qa.tolist(), "số 0 giải ra", giai_luong_tu(qa[1], S, Z))

    rng = np.random.default_rng(0)
    w = rng.normal(0, 0.02, size=4096)
    w[::512] *= 40                       # vài trọng số rất lớn
    for b in (8, 4, 3):
        qt, st = luong_tu_doi_xung(w, b)
        print("%d bit: cả tensor một thang MSE %.2e | nhóm 64 số MSE %.2e"
              % (b, sai_so(w, giai_luong_tu(qt, st)), sai_so(w, theo_nhom(w, b, 64))))

    X = rng.normal(size=(16, 64))
    X[:, 5] *= 20                        # một chiều đặc trưng ngoại lai, như LLM.int8() mô tả
    qt, st = luong_tu_doi_xung(X)
    qh, sh = luong_tu_doi_xung(X, truc=1)
    Xn, so_cot = tach_ngoai_lai(X)
    thuong = np.ones(64, dtype=bool)
    thuong[5] = False
    print("8 bit, sai số trên các cột thường: một thang %.2e | theo hàng %.2e | tách %d cột ngoại lai %.2e"
          % (sai_so(X[:, thuong], giai_luong_tu(qt, st)[:, thuong]), sai_so(X[:, thuong], giai_luong_tu(qh, sh)[:, thuong]),
             so_cot, sai_so(X[:, thuong], Xn[:, thuong])))

    print("4 bit, nhóm 64, thang 32 bit: %.3f bit mỗi tham số" % bit_moi_tham_so(4, 64))
    print("Thang lượng tử hóa kép (8 bit, nhóm 256 cho thang): %.3f bit" % (4 + 8 / 64 + 32 / (64 * 256)))
    for b in (16, 8, 4.5):
        print("Mô hình 8 tỉ tham số ở %.1f bit: %.1f GB trọng số" % (b, 8e9 * b / 8 / 1e9))

Ba dòng đầu lặp lại phần tính tay: thang 1/7 cho 0,2857 và 0,5714; thêm 6,0 thì 0,3 thành 0; dữ liệu [−1; 3] cho S ≈ 0,015686, Z = 64 và số 0 giải ra đúng 0. Với 4096 trọng số độ lệch chuẩn 0,02, trong đó cứ 512 số có một số lớn gấp 40 lần, dùng một thang cho cả tensor ở 4 bit cho sai số 4,08 × 10⁻⁴, gần bằng phương sai của trọng số: hầu hết trọng số đã thành 0. Nhóm 64 số hạ sai số xuống 3,57 × 10⁻⁵. Với ma trận đầu vào có một cột ngoại lai, sai số trên các cột thường là 1,86 × 10⁻² khi dùng một thang, 1,97 × 10⁻³ khi dùng thang theo hàng, và 2,91 × 10⁻⁵ khi tách riêng cột ngoại lai: thang theo hàng không đủ, vì cột đó có mặt ở mọi hàng.

Khi tự viết, hãy kiểm hai điều: mỗi số không lệch quá nửa thang, và số 0 giải ra đúng 0. So với một bản viết bằng vòng lặp Python thuần trên dữ liệu nhỏ, kể cả mảng toàn số 0.

Cẩn thận
  • Quên tính bit của thang: 4 bit với nhóm 64 số là 4,5 bit mỗi tham số, không phải 4.
  • Dùng một thang cho cả tensor khi có giá trị ngoại lai: các số nhỏ thành 0 hết.
  • So hai bản lượng tử hóa bằng một câu hỏi thử: sai số thể hiện rõ ở bộ đo như perplexity hay ở việc cụ thể của bạn.
  • Coi mọi bản 4 bit như nhau: làm tròn thẳng và GPTQ, NF4 cho kết quả rất khác ở cùng số bit.

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

Quantization là gì?

Là cách lưu các số của mô hình bằng số nguyên ít bit theo công thức r = S(q − Z), với S là thang và Z là điểm không, để mô hình nhẹ hơn và chạy nhanh hơn.

Int8 quantization có làm mô hình kém đi không?

Thường rất ít. ResNet-50 giảm từ 76,4% xuống 74,9% trên ImageNet; LLM.int8() chạy được mô hình 175 tỉ tham số ở 8 bit không giảm chất lượng nhờ tách riêng các chiều ngoại lai.

Vì sao 4 bit cần GPTQ hay NF4 mà không làm tròn thẳng?

Vì ở 4 bit bước nhảy lớn, sai số cộng dồn qua nhiều lớp. GPTQ bù sai số sau mỗi cột; NF4 đặt mốc dày ở vùng nhiều trọng số.

Lượng tử hóa khác cắt tỉa thế nào?

Lượng tử hóa giữ mọi trọng số nhưng dùng ít bit hơn cho mỗi số; cắt tỉa bỏ hẳn một phần trọng số. Hai cách dùng chung được với nhau.

Học tiếp

Bài cắt tỉa mạng nơ-ron nói cách bỏ bớt trọng số thay vì giảm số bit, còn bài KV cache cho thấy lượng tử hóa cũng dùng cho bộ nhớ của ngữ cảnh. 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