- MoE thay khối mạng truyền thẳng của mỗi lớp transformer bằng nhiều chuyên gia. Bộ định tuyến chọn k chuyên gia cho mỗi token; các chuyên gia còn lại không tính gì.
- Tổng tham số khác tham số hoạt động: Mixtral 8x7B có 47 tỉ tham số, mỗi token chỉ dùng 13 tỉ. Bộ nhớ vẫn phải chứa đủ 47 tỉ.
- Không có ràng buộc, bộ định tuyến sẽ dồn token vào vài chuyên gia. Hàm phạt cân tải và sức chứa chuyên gia giữ cho tải đều.
- Chuyên gia không chia theo chủ đề như tên gọi gợi ý: bài báo Mixtral thấy việc chọn chuyên gia gắn với cú pháp nhiều hơn.
Code trong bài là Python 3 với numpy. Bài giả định bạn đã biết một khối transformer gồm lớp chú ý (attention) và mạng truyền thẳng; nếu chưa, đọc trước bài kiến trúc transformer. Mọi con số lấy từ bản PDF của ba bài báo, đọc ngày 12/11/2026.
MoE thay phần nào của transformer
Mỗi lớp transformer có hai phần: lớp chú ý trộn thông tin giữa các token, và mạng truyền thẳng (feed-forward network, viết tắt FFN) xử lý riêng từng token. Ở mô hình đặc (dense), mọi token đi qua cùng một FFN và dùng toàn bộ trọng số của nó.
MoE giữ nguyên lớp chú ý nhưng thay FFN bằng \(n\) mạng nhỏ \(E_0, \dots, E_{n-1}\) gọi là chuyên gia (expert), cộng một bộ định tuyến (router). Đầu ra cho token \(x\) là tổng có trọng số:
\[y = \sum_{i=0}^{n-1} G(x)_i \, E_i(x)\]
Mấu chốt là vectơ trọng số \(G(x)\) thưa: chỉ vài thành phần khác 0, và chuyên gia có trọng số 0 thì không cần tính. Bài báo năm 2017 của Shazeer và cộng sự gọi đây là tính toán có điều kiện (conditional computation). Nhóm tác giả dùng tới hàng nghìn chuyên gia, xây lớp MoE tới 137 tỉ tham số, và ghi rằng dung lượng mô hình tăng hơn 1000 lần mà hiệu quả tính toán chỉ giảm nhẹ.
Bộ định tuyến chọn k chuyên gia
Bộ định tuyến đơn giản nhất là một ma trận \(W_g\): nhân vectơ token với \(W_g\) được một điểm cho mỗi chuyên gia. Mixtral giữ K điểm cao nhất, đặt các điểm còn lại thành âm vô cùng, rồi lấy softmax:
\[G(x) = \mathrm{Softmax}\big(\mathrm{TopK}(x \cdot W_g)\big)\]
Softmax của âm vô cùng bằng 0, nên chỉ K chuyên gia được chọn có trọng số dương, và các trọng số đó cộng lại bằng 1. Mixtral có 8 chuyên gia, chọn K = 2. Switch Transformer chỉ chọn 1 chuyên gia để giảm tính toán định tuyến và việc truyền dữ liệu; trọng số của nó là xác suất softmax trên cả N chuyên gia, nhỏ hơn 1, nhờ vậy bộ định tuyến vẫn nhận được đạo hàm.
Hình 1 chạy tay một token qua lớp có 4 chuyên gia, chọn 2. Điểm là 2,0; 0,90; 0,5 và −1,0, nên E1 và E2 được chọn. Điểm 0,90 thật ra là 2 − ln 3: softmax của hai số chênh nhau ln 3 cho tỉ lệ 3 : 1, tức trọng số 0,75 và 0,25. Nếu E1 trả về (1; 0) và E2 trả về (0; 4) thì đầu ra là 0,75·(1; 0) + 0,25·(0; 4) = (0,75; 1). E3 và E4 không chạy.
Tổng tham số và tham số hoạt động
Bài báo Mixtral phân biệt số tham số thưa (sparse parameter count, tức tổng số tham số) với số tham số hoạt động (active parameter count, phần dùng cho một token). Tăng số chuyên gia mà giữ nguyên K thì tổng tăng, còn lượng tính cho mỗi token gần như không đổi.
Bạn có thể tính lại hai con số của Mixtral 8x7B từ bảng kiến trúc trong bài báo: chiều ẩn 4096, 32 lớp, chiều ẩn FFN 14336, 32 đầu truy vấn, 8 đầu khóa và giá trị, mỗi đầu 128 chiều, từ vựng 32000 token. Mỗi chuyên gia là khối SwiGLU gồm ba ma trận 4096 × 14336, tức 176.160.768 tham số. Phần chung của mỗi lớp (bốn ma trận chiếu của lớp chú ý, bộ định tuyến, hai lớp chuẩn hóa) là 41.984.000 tham số; bảng nhúng và lớp ra mỗi cái 32000 × 4096. Cộng cả 32 lớp với 8 chuyên gia được khoảng 46,70 tỉ; chỉ tính 2 chuyên gia mỗi lớp được 12,88 tỉ. Làm tròn ra đúng 47B và 13B như phần tóm tắt của bài báo.
Phần chênh nằm gần hết ở 6 chuyên gia không được chọn mỗi lớp: hơn 33,8 tỉ tham số nằm yên trong bộ nhớ. Lượng phép tính mỗi token gần với mô hình đặc 13 tỉ, nhưng bộ nhớ phải chứa cả 47 tỉ, vì token sau có thể cần chuyên gia mà token trước không dùng. Cách ước bộ nhớ theo số tham số và số bit có trong bài chạy AI trên máy cá nhân; bài Qwen là gì cũng nhắc quy tắc này khi đọc tên kiểu 35B-A3B.
Bảng 9 của bài báo Switch Transformer cho ví dụ rõ hơn: T5-Base có 0,2 tỉ tham số, Switch-Base có 7 tỉ, nhưng cả hai cùng tốn 124 tỉ phép tính dấu phẩy động (FLOP) cho mỗi chuỗi.
Vì sao phải cân tải
Huấn luyện bộ định tuyến cùng các chuyên gia dễ rơi vào vòng luẩn quẩn: vài chuyên gia được chọn nhiều nên được huấn luyện nhiều, càng tốt lên và càng được chọn. Phần lớn chuyên gia còn lại bị bỏ phí.
Bài báo 2017 thêm vào hàm mất mát một hàm phạt phụ (auxiliary loss): bình phương hệ số biến thiên của độ quan trọng các chuyên gia, trong đó độ quan trọng là tổng trọng số cổng \(G(x)_i\) trên cả lô. Bảng 6 cho thấy tác dụng: không có hàm phạt, perplexity là 39,8 và chuyên gia bận nhất gánh tải gấp 17,80 lần mức trung bình; với hệ số phạt độ quan trọng và hệ số phạt tải cùng bằng 0,1, perplexity còn 35,6 và tỉ lệ đó còn 1,14.
Switch Transformer dùng một hàm phạt gọn hơn. Với N chuyên gia và một lô B gồm T token:
\[\begin{aligned} \text{loss} &= \alpha \cdot N \sum_{i=1}^{N} f_i \, P_i \\ f_i &= \frac{1}{T} \sum_{x \in B} \mathbf{1}\{\operatorname{argmax} p(x) = i\} \\ P_i &= \frac{1}{T} \sum_{x \in B} p_i(x) \end{aligned}\]
Ở đây \(f_i\) là tỉ lệ token thật sự gửi tới chuyên gia i, còn \(P_i\) là xác suất trung bình bộ định tuyến dành cho chuyên gia đó. Khi tải chia đều, cả hai bằng 1/N và hàm phạt bằng đúng α; bài báo dùng \(\alpha = 10^{-2}\). Chỉ \(P_i\) lấy đạo hàm được, nên hàm phạt tác động bằng cách hạ xác suất của chuyên gia đang bị dồn.
Sức chứa chuyên gia và token bị bỏ
Trên GPU hay TPU, kích thước mảng phải cố định trước, nên mỗi chuyên gia chỉ nhận tối đa một số token trong một lô, gọi là sức chứa chuyên gia (expert capacity):
\[\text{capacity} = \frac{T}{N} \times c\]
với T là số token trong lô, N là số chuyên gia và c là hệ số sức chứa. Token tới khi chuyên gia đã đầy bị bỏ qua lớp đó: nó đi thẳng sang lớp sau qua kết nối tắt (residual). Switch Transformer ghi rằng với hàm phạt đủ mạnh, tỉ lệ token bị bỏ thường dưới 1%, và mô hình cho kết quả tốt hơn ở hệ số thấp như 1,0 và 1,25.
Thử bằng numpy
Đoạn code dưới đây cài bộ định tuyến top-k, hàm phạt cân tải của Switch Transformer, sức chứa chuyên gia, và đếm tham số Mixtral từ bảng kiến trúc.
"""Một lớp Mixture of Experts nhỏ bằng numpy: bộ định tuyến chọn k chuyên gia cho mỗi token,
hàm phạt cân tải kiểu Switch Transformer, sức chứa chuyên gia, và đếm tham số Mixtral 8x7B."""
import math
import numpy as np
def softmax(z):
z = z - z.max(axis=-1, keepdims=True)
e = np.exp(z)
return e / e.sum(axis=-1, keepdims=True)
def chon_top_k(logits, k):
"""Chỉ số k chuyên gia có điểm cao nhất của mỗi token, và trọng số = softmax trên đúng k điểm đó."""
idx = np.argsort(-logits, axis=-1, kind="stable")[:, :k]
diem = np.take_along_axis(logits, idx, axis=-1)
return idx, softmax(diem)
def lop_moe(x, W_g, chuyen_gia, k):
"""Đầu ra của mỗi token = tổng (trọng số x đầu ra chuyên gia) trên k chuyên gia được chọn.
Chuyên gia không được chọn thì không tính gì cả."""
idx, w = chon_top_k(x @ W_g, k)
y = np.zeros((x.shape[0], chuyen_gia[0](x[0]).shape[0]))
for t in range(x.shape[0]):
for j in range(k):
y[t] += w[t, j] * chuyen_gia[idx[t, j]](x[t])
return y, idx, w
def phat_can_tai(logits, alpha=0.01):
"""Hàm phạt cân tải của Switch Transformer: alpha * N * tổng f_i * P_i.
f_i: tỉ lệ token được gửi tới chuyên gia i (chọn top-1); P_i: xác suất trung bình bộ định tuyến dành cho i."""
T, N = logits.shape
f = np.bincount(logits.argmax(axis=-1), minlength=N) / T
P = softmax(logits).mean(axis=0)
return alpha * N * float(np.sum(f * P))
def suc_chua(so_token, so_chuyen_gia, he_so):
"""Số token tối đa một chuyên gia nhận trong một lô = (số token / số chuyên gia) x hệ số sức chứa."""
return int(so_token / so_chuyen_gia * he_so)
def dem_token_bi_bo(chon, so_chuyen_gia, cap):
"""Token tới khi chuyên gia đã đầy thì bị bỏ qua: đi thẳng sang lớp sau qua kết nối tắt."""
dem, bo = [0] * so_chuyen_gia, 0
for e in chon:
if dem[e] < cap:
dem[e] += 1
else:
bo += 1
return bo
def tham_so_mixtral(dim=4096, n_layers=32, hidden=14336, n_heads=32, n_kv_heads=8, head_dim=128,
vocab=32000, n_experts=8, top_k=2):
"""Đếm tham số theo bảng kiến trúc trong bài báo Mixtral: tổng, và phần dùng cho mỗi token."""
mot_chuyen_gia = 3 * dim * hidden # khối SwiGLU có ba ma trận
chu_y = 2 * dim * n_heads * head_dim + 2 * dim * n_kv_heads * head_dim # Wq, Wo và Wk, Wv
chung_moi_lop = chu_y + dim * n_experts + 2 * dim # chú ý, bộ định tuyến, hai lớp chuẩn hóa
nhung = 2 * vocab * dim + dim # bảng nhúng, lớp ra, chuẩn hóa cuối
tong = n_layers * (chung_moi_lop + n_experts * mot_chuyen_gia) + nhung
hoat_dong = n_layers * (chung_moi_lop + top_k * mot_chuyen_gia) + nhung
return tong, hoat_dong
if __name__ == "__main__":
# 1. Một token, bốn chuyên gia, chọn hai. Ma trận định tuyến cho ra đúng bốn điểm này.
x = np.array([[1.0]])
W_g = np.array([[2.0, 2.0 - math.log(3), 0.5, -1.0]])
E = [lambda v: np.array([1.0, 0.0]), lambda v: np.array([0.0, 4.0]),
lambda v: np.array([9.0, 9.0]), lambda v: np.array([-9.0, 9.0])]
y, idx, w = lop_moe(x, W_g, E, k=2)
print("Điểm", np.round((x @ W_g)[0], 3).tolist(), "-> chọn", idx[0].tolist(), "trọng số", np.round(w[0], 4).tolist())
print("Đầu ra =", np.round(y[0], 4).tolist())
# 2. Phạt cân tải với 8 token, 4 chuyên gia.
chia_deu = np.log(np.array([np.roll([0.4, 0.2, 0.2, 0.2], t % 4) for t in range(8)]))
don_cuc = np.log(np.array([[0.7, 0.1, 0.1, 0.1]] * 8))
print("Phạt cân tải: chia đều %.4f | dồn hết vào chuyên gia 0: %.4f" % (phat_can_tai(chia_deu), phat_can_tai(don_cuc)))
# 3. Sức chứa: 8 token, 4 chuyên gia.
for hs in (1.0, 1.5):
cap = suc_chua(8, 4, hs)
print("Hệ số %.1f: %d chỗ mỗi chuyên gia, chia đều bỏ %d token, dồn hết bỏ %d token"
% (hs, cap, dem_token_bi_bo([0, 1, 2, 3] * 2, 4, cap), dem_token_bi_bo([0] * 8, 4, cap)))
# 4. Mixtral 8x7B.
tong, hd = tham_so_mixtral()
print("Mixtral 8x7B: tổng %.2f tỉ tham số, mỗi token dùng %.2f tỉ" % (tong / 1e9, hd / 1e9))
Kết quả khớp với phần tính tay. Token của Hình 1 chọn chuyên gia 0 và 1 (code đánh số từ 0) với trọng số 0,75 và 0,25, đầu ra (0,75; 1). Với 8 token và 4 chuyên gia, tải chia đều cho hàm phạt 0,0100, đúng bằng α; dồn cả 8 token vào chuyên gia 0 với xác suất 0,7 thì hàm phạt lên 0,0280, tức 0,01 × 4 × 0,7. Với hệ số sức chứa 1,0, lô bị dồn mất 6 trong 8 token; hệ số 1,5 vẫn mất 5. Muốn chắc phần định tuyến đúng, hãy so với cách viết của bài báo 2017: đặt điểm ngoài top-k thành âm vô cùng, lấy softmax trên cả n chuyên gia rồi cộng đủ n chuyên gia; hai cách phải cho cùng kết quả.
Chuyên gia có chuyên về chủ đề nào không
Tên gọi chuyên gia dễ làm người ta nghĩ có chuyên gia toán, chuyên gia lập trình. Mục 5 của bài báo Mixtral kiểm điều này trên bộ dữ liệu The Pile và không thấy quy luật rõ theo chủ đề: phân bố chuyên gia cho bài báo ArXiv, tóm tắt y sinh PubMed và văn bản triết học gần như giống nhau. Việc chọn chuyên gia gắn với cú pháp nhiều hơn: từ self trong Python hay các token thụt lề trong code thường đi qua cùng một chuyên gia, và các token liền nhau hay được gửi tới cùng chuyên gia hơn mức ngẫu nhiên. MoE là cách chia nhỏ phép tính do mô hình tự học, không phải một hội đồng chuyên môn do con người đặt ra.
Khi nào MoE có lợi
MoE có lợi khi bạn muốn thêm dung lượng mà không thêm phép tính cho mỗi token. Mixtral với 13 tỉ tham số hoạt động ngang hoặc vượt Llama 2 70B và GPT-3.5 trên các bộ đo mà bài báo đánh giá.
Cái giá nằm ở ba chỗ. Thứ nhất là bộ nhớ: phải chứa mọi chuyên gia. Thứ hai là truyền dữ liệu: khi chuyên gia nằm trên nhiều GPU (song song chuyên gia, expert parallelism), token phải được gửi tới đúng máy rồi gửi kết quả về, và tải lệch biến một máy thành nút thắt. Thứ ba là huấn luyện kém ổn định hơn: Switch Transformer ghi rằng bản Switch-XXL đôi khi vẫn không ổn định. Trên máy cá nhân, MoE hợp khi máy nhiều bộ nhớ nhưng sức tính yếu; máy ít bộ nhớ nên chọn mô hình đặc nhỏ hoặc bản đã lượng tử hóa.
- Ước bộ nhớ theo số tham số hoạt động (13 tỉ của Mixtral) thay vì tổng số tham số (47 tỉ).
- Nghĩ rằng MoE là ghép nhiều mô hình riêng rẽ: chuyên gia chỉ thay khối FFN trong từng lớp, lớp chú ý vẫn dùng chung.
- Lấy softmax trên cả n điểm rồi cắt top-k khi mô hình gốc lấy softmax trên k điểm, hoặc ngược lại.
- Bỏ hàm phạt cân tải khi tự huấn luyện MoE: bộ định tuyến sẽ dồn token vào vài chuyên gia.
Câu hỏi thường gặp
MoE trong AI là gì?
Là kiến trúc có nhiều mạng con (chuyên gia) và một bộ định tuyến chọn vài chuyên gia cho từng token, nên mô hình có nhiều tham số mà mỗi token chỉ dùng một phần.
Mixtral 8x7B có phải là 8 mô hình 7 tỉ tham số không?
Không. Chỉ khối FFN được nhân thành 8 chuyên gia; lớp chú ý và bảng nhúng dùng chung, nên tổng là khoảng 47 tỉ chứ không phải 56 tỉ.
MoE có nhanh hơn mô hình đặc cùng số tham số không?
Phép tính mỗi token ít hơn nhiều, nhưng vẫn phải chứa đủ mọi chuyên gia trong bộ nhớ. Tốc độ thật còn tùy phần cứng và cỡ lô.
Vì sao Switch Transformer chỉ chọn 1 chuyên gia?
Bài báo cho thấy chọn 1 vẫn giữ chất lượng, lại giảm tính toán định tuyến, giảm sức chứa cần cho mỗi chuyên gia và đơn giản hóa việc truyền dữ liệu.
Học tiếp
MoE chỉ là một trong các cách làm mô hình lớn chạy nổi. Bài KV cache giải thích phần bộ nhớ tăng theo độ dài ngữ cảnh, còn bài lượng tử hóa mô hình nói cách giảm số bit cho mỗi tham số. 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
- Shazeer và cộng sự (2017), Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer, arXiv 1701.06538v1 (PDF, đọc 12/11/2026)
- Fedus, Zoph, Shazeer (2022), Switch Transformers, JMLR 23, arXiv 2101.03961v3 (PDF, đọc 12/11/2026)
- Jiang và cộng sự (2024), Mixtral of Experts, arXiv 2401.04088v1 (PDF, đọc 12/11/2026)


