- Cắt tỉa bỏ trọng số (không cấu trúc) hoặc cả nơ-ron, kênh, hàng, cột (có cấu trúc). Độ thưa (sparsity) là tỉ lệ trọng số bằng 0.
- Cách cổ điển của Han và cộng sự: huấn luyện, bỏ trọng số nhỏ, huấn luyện lại. AlexNet nhỏ đi 9 lần, VGG-16 nhỏ đi 13 lần mà không giảm độ chính xác.
- Giả thuyết vé số: mạng lớn chứa sẵn mạng con chỉ bằng chưa tới 10-20% kích thước mạng gốc, học tốt nếu giữ đúng giá trị khởi tạo ban đầu.
- Với mô hình ngôn ngữ lớn, cắt theo độ lớn sụp sớm; SparseGPT cắt 50-60% trọng số của OPT-175B trong một lần, không huấn luyện lại.
Code trong bài là Python 3 với numpy. Bài này nói chuyện bỏ trọng số; giảm số bit cho mỗi trọng số có ở bài lượng tử hóa mô hình, còn các mạng AlexNet, VGG được nhắc tới là mạng nơ-ron tích chập. Số liệu lấy từ bản PDF của ba bài báo, đọc ngày 12/11/2026.
Cắt tỉa là gì
Một mạng đã huấn luyện thường có rất nhiều trọng số gần 0, đóng góp rất ít vào đầu ra. Cắt tỉa đặt các trọng số đó bằng 0 hẳn, bằng một mặt nạ M gồm 0 và 1 nhân từng phần tử với ma trận trọng số: \(\hat{W} = M \odot W\). Độ thưa là tỉ lệ số 0 trong mặt nạ.
Có hai kiểu. Cắt không cấu trúc (unstructured) chọn từng trọng số riêng lẻ, nên giữ chất lượng tốt nhất nhưng ma trận thưa lộn xộn, khó chạy nhanh trên GPU. Cắt có cấu trúc (structured) bỏ cả hàng, cột, kênh hay đầu chú ý, nên ma trận nhỏ đi thật và chạy nhanh ngay, nhưng khó giữ độ chính xác hơn nhiều. Bài SparseGPT dẫn ví dụ: cắt có cấu trúc ResNet-50 quá 50% mà không giảm độ chính xác là khó kể cả khi huấn luyện lại nhiều, còn cắt không cấu trúc tới 90% thì làm được dễ dàng. Ở giữa là mẫu bán cấu trúc n:m, ví dụ 2:4: trong mỗi nhóm 4 trọng số liền nhau giữ đúng 2; theo bài SparseGPT, mẫu 2:4 chạy nhanh hơn trên GPU NVIDIA thế hệ Ampere.
Cắt theo độ lớn: huấn luyện, cắt, huấn luyện lại
Han và cộng sự (2015) đặt bài toán từ góc năng lượng. Ở công nghệ 45 nm, đọc một số 32 bit từ SRAM trên chip tốn 5 pJ, còn từ DRAM bên ngoài tốn 640 pJ; một mạng 1 tỉ kết nối chạy 20 lần mỗi giây cần 12,8 W chỉ để đọc DRAM, quá sức một chiếc điện thoại. Mạng nhỏ hơn thì nằm vừa bộ nhớ nhanh hơn.
Cách của họ gồm ba bước. Bước một, huấn luyện bình thường để biết kết nối nào quan trọng. Bước hai, bỏ mọi kết nối có trọng số nhỏ hơn một ngưỡng. Bước ba, huấn luyện lại phần còn lại, bắt đầu từ chính các trọng số đã học chứ không khởi tạo lại. Bài báo nhấn mạnh bước ba là thiết yếu: không huấn luyện lại thì độ chính xác bắt đầu giảm khi mới bỏ hai phần ba số kết nối, còn có huấn luyện lại thì tới khi chỉ còn một phần mười. Lặp lại vòng cắt và huấn luyện nhiều lần nâng mức nén AlexNet từ 5 lần lên 9 lần so với cắt mạnh một lần.
Kết quả trên ImageNet: AlexNet từ 61 triệu còn 6,7 triệu tham số (9 lần), VGG-16 từ 138 triệu còn 10,3 triệu (13 lần), không giảm độ chính xác. Bài báo cũng so hai kiểu chuẩn hóa: chuẩn hóa L1 đẩy nhiều trọng số về gần 0 nên tốt hơn ngay sau khi cắt, nhưng sau khi huấn luyện lại thì L2 tốt hơn. Hai kiểu này có trong bài overfitting và regularization.
Giả thuyết vé số
Nếu mạng cắt tỉa tốt như vậy, sao không huấn luyện thẳng một mạng nhỏ? Frankle và Carbin ghi nhận kinh nghiệm chung: kiến trúc thưa có được từ cắt tỉa thường khó huấn luyện lại từ đầu. Họ thử một cách khác: huấn luyện, bỏ các trọng số nhỏ nhất, rồi đặt các trọng số còn lại về đúng giá trị khởi tạo ban đầu, trước khi huấn luyện, và huấn luyện lại mạng con đó.
Từ đó họ phát biểu giả thuyết vé số (lottery ticket hypothesis): một mạng đặc khởi tạo ngẫu nhiên chứa sẵn mạng con, gọi là vé trúng, khi huấn luyện riêng đạt độ chính xác tương đương mạng gốc trong số bước tương tự. Các vé trúng họ tìm được chỉ bằng chưa tới 10-20% kích thước mạng gốc trên MNIST và CIFAR10. Với mạng Lenet cắt lặp mỗi vòng 20%, vé còn 21,1% trọng số học nhanh hơn mạng gốc, còn 13,5% thì độ chính xác cao hơn hơn 0,3 điểm phần trăm, và phải xuống 3,6% mới quay về mức của mạng gốc. Điểm mấu chốt là khởi tạo: giữ nguyên cấu trúc vé nhưng khởi tạo ngẫu nhiên lại thì mạng học chậm hơn hẳn. Với mạng sâu hơn, bài báo ghi cần khởi động tốc độ học (warmup) mới tìm được vé khi huấn luyện với tốc độ học cao.
SparseGPT: cắt mô hình ngôn ngữ lớn trong một lần
Huấn luyện lại một mô hình 175 tỉ tham số tốn kém không kém huấn luyện mới, nên Frantar và Alistarh tìm cách cắt trong một lần (one-shot), không huấn luyện lại. Họ chia bài toán theo từng lớp: tìm mặt nạ M và trọng số mới \(\hat{W}\) để đầu ra của lớp trên dữ liệu X lệch ít nhất:
\[\min_{M,\ \hat{W}} \big\| W X - (M \odot \hat{W})\, X \big\|_2^2\]
Với mặt nạ cố định, trọng số tốt nhất của mỗi hàng là nghiệm bình phương tối thiểu trên các đặc trưng còn giữ. Khó ở chỗ mỗi hàng có mặt nạ riêng nên phải nghịch đảo một ma trận riêng. SparseGPT dùng công thức của Optimal Brain Surgeon: bỏ trọng số m làm sai số tăng thêm khoảng \(w_m^2 / [H^{-1}]_{mm}\), và các trọng số còn lại được chỉnh để bù; nhờ một cách xấp xỉ khéo, các hàng dùng chung được ma trận nghịch đảo.
Bảng 1 của bài báo cho thấy khoảng cách với cắt theo độ lớn. OPT-175B đặc có perplexity 8,35 trên WikiText2. Cắt 50% theo độ lớn đẩy perplexity lên cỡ 43.000, tức mô hình hỏng hẳn; theo bài báo, cắt theo độ lớn chỉ giữ được chất lượng tới 10% độ thưa với mô hình này. SparseGPT cắt 50% còn 8,21, mẫu 4:8 là 8,45, mẫu 2:4 là 8,74. Cả OPT-175B và BLOOM-176B được cắt trong chưa tới 4,5 giờ, tới 60% độ thưa mà perplexity tăng không đáng kể: hơn 100 tỉ trọng số có thể bỏ qua khi chạy. Mô hình càng lớn càng dễ cắt, và cách này kết hợp được với lượng tử hóa 4 bit.
Thử bằng numpy
Đoạn code dưới đây cài mặt nạ theo độ lớn, mẫu 2:4, đo độ thưa, và huấn luyện lại một mô hình hồi quy tuyến tính với trọng số bị cắt giữ bằng 0. Dữ liệu là 64 đặc trưng tương quan với nhau, trong đó đáp án thật chỉ dùng 16.
"""Cắt tỉa theo độ lớn (Han và cộng sự 2015) trên một mô hình hồi quy tuyến tính nhỏ, bằng numpy:
mặt nạ không cấu trúc, mẫu thưa 2:4, đo độ thưa, và huấn luyện lại phần trọng số còn lại."""
import numpy as np
def mat_na_do_lon(w, ti_le):
"""Bỏ ti_le phần trọng số có |w| nhỏ nhất, không theo cấu trúc nào. True = giữ."""
k = int(round(ti_le * w.size))
m = np.ones(w.size, dtype=bool)
if k:
m[np.argsort(np.abs(w).ravel(), kind="stable")[:k]] = False
return m.reshape(w.shape)
def mat_na_2_4(w):
"""Mẫu bán cấu trúc 2:4: trong mỗi nhóm 4 số liền nhau, giữ 2 số có |w| lớn nhất."""
g = np.abs(w).reshape(-1, 4)
m = np.zeros(g.shape, dtype=bool)
np.put_along_axis(m, np.argsort(-g, axis=1, kind="stable")[:, :2], True, axis=1)
return m.reshape(w.shape)
def do_thua(w):
"""Tỉ lệ trọng số bằng 0."""
return float(np.mean(np.asarray(w) == 0))
def huan_luyen(X, y, mat_na=None, w0=None, so_buoc=3000, lr=0.1):
"""Hồi quy tuyến tính bằng gradient descent. Trọng số bị cắt được giữ bằng 0 suốt quá trình."""
m = np.ones(X.shape[1], dtype=bool) if mat_na is None else mat_na
w = (np.zeros(X.shape[1]) if w0 is None else w0.copy()) * m
for _ in range(so_buoc):
w -= lr * (X.T @ (X @ w - y) / len(y)) * m
return w
def sai_so(X, y, w):
return float(np.mean((X @ w - y) ** 2))
if __name__ == "__main__":
w = np.array([0.9, -0.8, 0.7, 0.05, -0.3, 0.1, 0.2, -0.15])
print("Cắt 50% theo độ lớn:", np.where(mat_na_do_lon(w, 0.5), w, 0.0).tolist())
print("Mẫu 2:4: ", np.where(mat_na_2_4(w), w, 0.0).tolist())
rng = np.random.default_rng(0)
n, d = 2000, 64
Z = rng.normal(size=(n, d))
X = Z + 0.6 * Z[:, rng.permutation(d)] # các đặc trưng tương quan với nhau
w_that = np.zeros(d)
w_that[rng.choice(d, 16, replace=False)] = rng.normal(0, 1, 16)
y = X @ w_that + 0.1 * rng.normal(size=n)
Xa, ya, Xb, yb = X[:1500], y[:1500], X[1500:], y[1500:] # dữ liệu học, dữ liệu thử
w_day = huan_luyen(Xa, ya)
print("Mô hình đầy đủ: sai số trên dữ liệu thử %.4f" % sai_so(Xb, yb, w_day))
for tl in (0.5, 0.75, 0.9):
m = mat_na_do_lon(w_day, tl)
w_cat = w_day * m
w_lai = huan_luyen(Xa, ya, m, w_cat)
m_nn = np.zeros(d, dtype=bool)
m_nn[rng.choice(d, int(m.sum()), replace=False)] = True
w_nn = huan_luyen(Xa, ya, m_nn, w_day * m_nn)
print("Cắt %2d%% (độ thưa %.2f): chưa học lại %.4f | học lại %.4f | cắt ngẫu nhiên rồi học lại %.4f"
% (tl * 100, do_thua(w_cat), sai_so(Xb, yb, w_cat), sai_so(Xb, yb, w_lai), sai_so(Xb, yb, w_nn)))
Hai dòng đầu là Hình 1. Mô hình đầy đủ có sai số 0,0103 trên dữ liệu thử, gần đúng mức nhiễu 0,01 đã đặt. Cắt 50% hay 75% trọng số không làm sai số tăng, vì các trọng số bị bỏ gần như vô dụng. Cắt 90% thì phải bỏ cả trọng số cần thiết: sai số lên 2,24, huấn luyện lại kéo xuống 2,08 nhờ các trọng số còn lại bù một phần. Cắt ngẫu nhiên cùng số lượng rồi huấn luyện lại cho sai số 8,5 tới 11,8: tiêu chí chọn trọng số nào bỏ quan trọng hơn bản thân việc bỏ.
Với hồi quy tuyến tính, huấn luyện lại trên mặt nạ cố định phải hội tụ về nghiệm bình phương tối thiểu trên các cột còn giữ, đúng công thức 2 của SparseGPT. Bạn có thể kiểm code của mình bằng cách so với np.linalg.lstsq trên các cột đó.
- Nghĩ rằng độ thưa 50% là nhanh gấp đôi: thưa không cấu trúc cần phần cứng, thư viện hỗ trợ; mẫu 2:4 hay cắt có cấu trúc mới dễ thành tốc độ.
- Cắt mạnh một lần rồi bỏ qua huấn luyện lại với mạng nhỏ: Han và cộng sự cho thấy huấn luyện lại là bước quyết định.
- Khởi tạo lại mạng con sau khi cắt rồi kết luận mạng thưa học kém: giả thuyết vé số cần đúng giá trị khởi tạo ban đầu.
- Dùng cắt theo độ lớn cho mô hình ngôn ngữ lớn mà không huấn luyện lại: chất lượng sụp từ độ thưa thấp.
Câu hỏi thường gặp
Pruning trong deep learning là gì?
Là bỏ bớt trọng số, nơ-ron hay kênh ít đóng góp của một mạng đã huấn luyện để mạng nhỏ hơn, nhanh hơn mà độ chính xác gần như giữ nguyên.
Sparsity là gì?
Là tỉ lệ trọng số bằng 0. Độ thưa 90% nghĩa là chỉ còn 1 trên 10 trọng số khác 0.
Cắt tỉa khác lượng tử hóa thế nào?
Cắt tỉa bỏ hẳn một phần trọng số; lượng tử hóa giữ mọi trọng số nhưng lưu mỗi số bằng ít bit hơn. SparseGPT cho thấy dùng được cả hai cùng lúc.
Có cần huấn luyện lại sau khi cắt không?
Với mạng thông thường thì nên, vì đó là bước giữ độ chính xác. Với mô hình ngôn ngữ rất lớn, các cách cắt một lần như SparseGPT giữ được chất lượng mà không cần huấn luyện lại.
Học tiếp
Cắt tỉa thường đi cùng lượng tử hóa: một cách giảm số trọng số, một cách giảm số bit cho mỗi trọng số. Còn nếu muốn mô hình lớn mà mỗi token chỉ dùng một phần trọng số, xem bài Mixture of Experts. 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
- Han, Pool, Tran, Dally (2015), Learning both Weights and Connections for Efficient Neural Networks, arXiv 1506.02626v3 (PDF, đọc 12/11/2026)
- Frankle, Carbin (2019), The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks, arXiv 1803.03635v5 (PDF, đọc 12/11/2026)
- Frantar, Alistarh (2023), SparseGPT: Massive Language Models Can Be Accurately Pruned in One-Shot, arXiv 2301.00774v3 (PDF, đọc 12/11/2026)


