- Autoencoder gồm bộ mã hóa (dữ liệu thành mã ngắn
z) và bộ giải mã (mã thành dữ liệu dựng lại), huấn luyện để bản dựng lại giống bản gốc nhất; không cần nhãn. - Autoencoder tuyến tính với sai số bình phương học đúng không gian của PCA; thêm hàm kích hoạt phi tuyến thì học được cả mặt cong.
- VAE cho bộ mã hóa ra một phân phối (trung bình và độ lệch chuẩn), lấy mẫu
zbằng mẹo tham số hóa lại, và phạt độ lệch KL để mã nằm gần phân phối chuẩn; nhờ đó sinh được mẫu mới. - Stable Diffusion bản 1 nén ảnh 512×512×3 thành mảng ẩn 64×64×4 (ít số hơn 48 lần) bằng một bộ tự mã hóa; nút VAE trong ComfyUI chính là bộ này.
Bài dựa trên bản PDF của bài báo VAE (Kingma, Welling, arXiv 1312.6114v11), bài báo Latent Diffusion (Rombach và cộng sự, arXiv 2112.10752v2) và bài tổng quan về autoencoder của Michelucci (arXiv 2201.03898), cùng thẻ mô hình Stable Diffusion v1 và tài liệu ComfyUI, đọc ngày 12/11/2026. Bài cũ về giảm chiều dữ liệu giới thiệu phép chiếu và học đa tạp; autoencoder là cách làm việc đó bằng mạng nơ-ron.
Autoencoder là gì
Autoencoder có hai nửa. Bộ mã hóa (encoder) nhận dữ liệu x, ví dụ một ảnh chữ số 28×28 tức 784 số, và cho ra một mã z ngắn hơn nhiều, ví dụ 2 số. Bộ giải mã (decoder) nhận z và dựng lại một bản \(\hat{x}\) cũng 784 số. Hai nửa được huấn luyện cùng nhau để bản dựng lại giống bản gốc nhất, thường bằng sai số bình phương trung bình:
\[\mathcal{L} = \frac{1}{n}\sum_{i=1}^{n} \lVert x_i - g(f(x_i)) \rVert^2\]
với f là bộ mã hóa, g là bộ giải mã. Dữ liệu tự làm "nhãn" cho chính nó, nên không cần ai gán nhãn. Phần giữa, nơi mã z nằm, gọi là nút thắt cổ chai (bottleneck), và không gian chứa các mã z gọi là không gian ẩn (latent space).
Nút thắt: vì sao phải nhỏ
Nếu z có nhiều số như x, mạng chỉ cần chép nguyên dữ liệu qua là xong và chẳng học được gì. Nút thắt nhỏ buộc mạng phải chọn: giữ những hướng biến thiên lớn nhất của dữ liệu, bỏ phần nhiễu và chi tiết vụn.
Trường hợp đơn giản nhất cho thấy rõ nút thắt học gì. Bài tổng quan của Michelucci nhắc lại một kết quả cũ (Baldi và Hornik, 1989): nếu bộ mã hóa và bộ giải mã đều tuyến tính, hàm mất mát là sai số bình phương và dữ liệu đã trừ trung bình, thì autoencoder tương đương với phân tích thành phần chính (PCA): nó học đúng không gian của k thành phần chính đầu tiên. Khác biệt là autoencoder học được theo từng lô dữ liệu, còn PCA cổ điển cần cả tập. Thêm hàm kích hoạt phi tuyến, autoencoder không còn bị giới hạn ở mặt phẳng mà học được cả những mặt cong, đúng tinh thần học đa tạp.
Bài tổng quan đó liệt kê các ứng dụng điển hình: giảm chiều, dùng mã z làm đặc trưng để phân loại, khử nhiễu (đưa vào ảnh nhiễu, bắt dựng lại ảnh sạch) và phát hiện bất thường (mẫu lạ thì dựng lại kém, sai số khôi phục cao).
Code numpy: autoencoder tuyến tính và PCA
Đoạn code dưới đây tạo 300 điểm ba chiều nằm gần một mặt phẳng, huấn luyện một autoencoder tuyến tính bằng hạ gradient với nút thắt 2 chiều rồi 1 chiều, và so sai số khôi phục với PCA. Nửa sau là các mảnh của VAE và phép tính độ nén của Stable Diffusion, giải thích ở các mục kế tiếp.
"""Autoencoder và VAE bằng numpy: autoencoder tuyến tính học lại đúng mặt phẳng của PCA, mẹo tham số hóa lại
và số hạng KL của VAE, cùng phép tính độ nén của không gian ẩn trong Stable Diffusion bản 1.
Chạy: python autoencoder_vae.py (cần numpy)
"""
import numpy as np
def du_lieu(n=300, seed=0):
"""300 điểm 3 chiều nằm gần một mặt phẳng (thêm chút nhiễu theo chiều thứ ba)."""
rng = np.random.default_rng(seed)
t = rng.normal(size=(n, 2)) * [3.0, 1.0]
mat_phang = np.array([[1.0, 1.0, 0.0], [-1.0, 1.0, 1.0]]) / np.sqrt([[2.0], [3.0]])
return t @ mat_phang + rng.normal(scale=0.1, size=(n, 3))
def autoencoder_tuyen_tinh(X, k, buoc=4000, toc_do=0.02, seed=1):
"""Mã hóa z = X @ We (d -> k), giải mã X_hat = z @ Wd (k -> d); hạ gradient trên sai số bình phương trung bình."""
rng = np.random.default_rng(seed)
X = X - X.mean(axis=0)
n, d = X.shape
We, Wd = rng.normal(scale=0.1, size=(d, k)), rng.normal(scale=0.1, size=(k, d))
for _ in range(buoc):
z = X @ We
sai = z @ Wd - X # (n, d)
g_wd = 2 * z.T @ sai / n
g_we = 2 * X.T @ (sai @ Wd.T) / n
We -= toc_do * g_we
Wd -= toc_do * g_wd
return float(np.mean(np.sum((X @ We @ Wd - X) ** 2, axis=1))), Wd
def sai_so_pca(X, k):
"""Sai số khôi phục khi chỉ giữ k thành phần chính (tính bằng SVD)."""
X = X - X.mean(axis=0)
s = np.linalg.svd(X, compute_uv=False)
return float(np.sum(s[k:] ** 2) / len(X))
def tham_so_hoa_lai(mu, sigma, so_mau, seed=2):
"""z = mu + sigma * eps với eps ~ N(0, 1): ngẫu nhiên nằm ở eps, nên lấy được gradient theo mu và sigma."""
eps = np.random.default_rng(seed).standard_normal(so_mau)
return mu + sigma * eps
def kl_chuan(mu, sigma):
"""KL(N(mu, sigma^2) || N(0, 1)) = 1/2 (mu^2 + sigma^2 - 1 - ln sigma^2), phụ lục B của Kingma và Welling."""
return 0.5 * (mu ** 2 + sigma ** 2 - 1 - np.log(sigma ** 2))
def kl_monte_carlo(mu, sigma, so_mau=200_000):
z = tham_so_hoa_lai(mu, sigma, so_mau)
log_q = -0.5 * ((z - mu) / sigma) ** 2 - np.log(sigma) - 0.5 * np.log(2 * np.pi)
log_p = -0.5 * z ** 2 - 0.5 * np.log(2 * np.pi)
return float(np.mean(log_q - log_p))
def so(n):
return f"{n:,}".replace(",", ".")
def chay_thu():
X = du_lieu()
for k in (2, 1):
mse, _ = autoencoder_tuyen_tinh(X, k)
print(f"Nút thắt {k} chiều: autoencoder tuyến tính {mse:.4f}, PCA giữ {k} thành phần {sai_so_pca(X, k):.4f}")
mu, sigma = 1.0, 0.5
z = tham_so_hoa_lai(mu, sigma, 200_000)
print(f"z = mu + sigma·eps với mu = 1, sigma = 0,5: trung bình {z.mean():.3f}, độ lệch chuẩn {z.std():.3f}")
print(f"KL công thức đóng {kl_chuan(mu, sigma):.4f}, ước lượng Monte Carlo {kl_monte_carlo(mu, sigma):.4f}")
anh, an = 512 * 512 * 3, (512 // 8) * (512 // 8) * 4
print(f"Ảnh 512×512×3 = {so(anh)} số; không gian ẩn 64×64×4 = {so(an)} số; nhỏ hơn {anh // an} lần")
if __name__ == "__main__":
chay_thu()
Hai dòng đầu cho cùng một con số ở hai cột: với nút thắt 2 chiều, autoencoder học bằng hạ gradient đạt sai số 0,0101, đúng bằng sai số khi giữ 2 thành phần chính; với 1 chiều, cả hai cùng 0,9961, vì phải bỏ một hướng biến thiên thật của mặt phẳng. Muốn tự kiểm một autoencoder tuyến tính của mình, so với PCA tính bằng trị riêng của ma trận hiệp phương sai, và thử với dữ liệu nằm đúng trên một đường thẳng: nút thắt 1 chiều phải khôi phục gần như hoàn hảo.
Vì sao autoencoder thường chưa sinh được mẫu mới
Sau khi học xong, bạn có thể lấy một điểm z bất kỳ đưa vào bộ giải mã. Nhưng với autoencoder thường, không có gì buộc các mã của dữ liệu thật nằm gọn trong một vùng biết trước. Chúng có thể nằm rải rác, chừa những khoảng trống mà bộ giải mã chưa từng thấy, và giải mã một điểm trong khoảng trống thường cho ra thứ vô nghĩa. Muốn sinh mẫu mới, cần một mô hình xác suất cho z. Đó là việc của VAE.
VAE: mã hóa thành một phân phối
Kingma và Welling (2013) xuất phát từ một mô hình xác suất: mỗi điểm dữ liệu được sinh bằng cách lấy z từ một phân phối tiên nghiệm \(p(z)\) (thường là chuẩn tắc), rồi lấy x từ \(p_\theta(x \mid z)\). Hậu nghiệm \(p(z \mid x)\) không tính được, nên họ học một mạng nhận dạng \(q_\phi(z \mid x)\) để xấp xỉ nó. Với dạng chuẩn, mạng này cho ra trung bình \(\mu\) và độ lệch chuẩn \(\sigma\) của z: đó là bộ mã hóa của VAE. Hàm mục tiêu là cận dưới biến phân (phương trình 3):
\[\begin{aligned} \log p_\theta(x) \ge\ & \mathbb{E}_{q_\phi(z|x)}[\log p_\theta(x \mid z)] \\ & - D_{KL}(q_\phi(z \mid x) \,\|\, p(z)) \end{aligned}\]
Số hạng đầu là độ dựng lại tốt; số hạng sau phạt các mã lệch xa phân phối tiên nghiệm. Khi cả hai đều là phân phối chuẩn, số hạng KL có công thức đóng (phụ lục B), với J là số chiều của z:
\[-D_{KL} = \frac{1}{2}\sum_{j=1}^{J}\left(1 + \log \sigma_j^2 - \mu_j^2 - \sigma_j^2\right)\]
Bài báo dùng mỗi lô gồm 100 điểm và chỉ 1 mẫu z cho mỗi điểm, thử trên MNIST và Frey Face. Nhóm tác giả ghi nhận tăng số chiều ẩn không làm mô hình quá khớp, nhờ tác dụng điều chuẩn của cận dưới.
Mẹo tham số hóa lại
Lấy mẫu là phép ngẫu nhiên, không lấy đạo hàm được. Mẹo của bài báo (mục 2.4) là dời phần ngẫu nhiên ra ngoài:
\[z = \mu + \sigma \odot \varepsilon, \qquad \varepsilon \sim \mathcal{N}(0, I)\]
Giờ z là hàm xác định của \(\mu\) và \(\sigma\), còn \(\varepsilon\) chỉ là dữ liệu đầu vào, nên gradient chảy ngược qua được tới bộ mã hóa. Dòng thứ ba của code kiểm điều này: mẫu lấy theo cách đó có trung bình 0,999 và độ lệch chuẩn 0,500, đúng \(\mu = 1\), \(\sigma = 0{,}5\). Dòng thứ tư so công thức đóng của KL (0,8181) với ước lượng bằng 200 nghìn mẫu (0,8165). Học xong, muốn sinh ảnh mới chỉ cần lấy z từ phân phối chuẩn rồi cho qua bộ giải mã.
Autoencoder trong Stable Diffusion và ComfyUI
Mô hình khuếch tán chạy trực tiếp trên điểm ảnh rất tốn kém. Latent Diffusion (nền của Stable Diffusion) huấn luyện trước một bộ tự mã hóa, rồi cho mô hình khuếch tán làm việc trong không gian ẩn của nó. Bộ mã hóa giảm kích thước theo hệ số \(f = H/h = W/w\); bài báo thử f từ 1 tới 32 và thấy mức 4 tới 16 cân bằng tốt nhất giữa tốc độ và độ trung thực. Sau 2 triệu bước, FID của bản làm việc trên điểm ảnh (f = 1) kém bản f = 8 tới 38 điểm. Bộ tự mã hóa được huấn luyện với hàm mất mát cảm nhận cộng một bộ phân biệt theo từng mảng ảnh, và phạt KL với trọng số rất nhỏ, cỡ \(10^{-6}\), để không gian ẩn không bị co giãn tùy ý. Nói cách khác, đây là một "VAE" có số hạng KL rất yếu.
Thẻ mô hình Stable Diffusion v1 ghi: bộ tự mã hóa có hệ số giảm 8 và biến ảnh H×W×3 thành mảng ẩn H/8×W/8×4. Dòng cuối của code làm phép tính cho ảnh 512×512: 786.432 số thành 16.384 số, ít hơn 48 lần. Trong ComfyUI, nút Load Checkpoint cho ra ba thứ: mô hình chính, bộ mã hóa chữ CLIP và VAE; nút VAE Decode, theo tài liệu ComfyUI, giải mã biểu diễn ẩn thành ảnh bằng VAE được chọn. Vì thế "VAE trong ComfyUI" là nửa giải mã của bộ tự mã hóa trên: mọi bước khử nhiễu diễn ra trên mảng 64×64×4, chỉ bước cuối mới đổi ra điểm ảnh. Phần khuếch tán được giải thích ở bài mô hình khuếch tán tạo ảnh thế nào.
- Cho nút thắt to bằng dữ liệu: mạng học cách chép nguyên, mã
zkhông nói lên điều gì. - Lấy điểm ngẫu nhiên trong không gian ẩn của autoencoder thường để sinh mẫu: dễ rơi vào khoảng trống chưa ai học.
- Quên trừ trung bình dữ liệu khi so autoencoder tuyến tính với PCA.
- Viết sai dấu số hạng KL: công thức trong bài báo là âm của KL; mất mát cần cộng KL vào sai số dựng lại.
- Đặt trọng số KL quá lớn: mã bị ép về phân phối chuẩn, ảnh dựng lại mờ; Latent Diffusion cố ý dùng trọng số cỡ \(10^{-6}\).
Câu hỏi thường gặp
Autoencoder khác PCA thế nào?
Bản tuyến tính với sai số bình phương học đúng không gian của PCA. Bản có hàm kích hoạt phi tuyến học được cả mặt cong, và huấn luyện được theo từng lô trên dữ liệu rất lớn.
VAE khác autoencoder thường ở đâu?
VAE cho bộ mã hóa ra một phân phối thay vì một điểm, lấy mẫu bằng mẹo tham số hóa lại và phạt độ lệch KL. Nhờ đó không gian ẩn liền mạch và lấy mẫu từ phân phối chuẩn là sinh được dữ liệu mới.
VAE trong ComfyUI là gì?
Là bộ tự mã hóa đi kèm mô hình Stable Diffusion. Nút VAE Decode dùng nửa giải mã để đổi mảng ẩn sau khi khử nhiễu thành ảnh; nút VAE Encode làm chiều ngược lại, đổi một ảnh có sẵn thành mảng ẩn.
Vì sao ảnh của VAE hay bị mờ?
Một nguyên nhân là sai số bình phương thưởng cho bản dựng lại "trung bình". Latent Diffusion thêm hàm mất mát cảm nhận và bộ phân biệt theo mảng để giữ chi tiết sắc nét.
Học tiếp
- Mô hình khuếch tán làm việc trong không gian ẩn này: mô hình khuếch tán tạo ảnh thế nào.
- Một họ mô hình sinh khác, học bằng đối nghịch: GAN trong AI là gì.
- Giấy phép và cách chạy Stable Diffusion trên máy: Stable Diffusion là gì.
Nếu bạn muốn học Python và 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
- Kingma, Welling (2013): Auto-Encoding Variational Bayes, arXiv 1312.6114v11 (đọc bản PDF ngày 12/11/2026)
- Rombach và cộng sự (CVPR 2022): High-Resolution Image Synthesis with Latent Diffusion Models, arXiv 2112.10752v2 (đọc bản PDF ngày 12/11/2026)
- Michelucci (2022): An Introduction to Autoencoders, arXiv 2201.03898 (đọc bản PDF ngày 12/11/2026)
- CompVis/stable-diffusion: Stable Diffusion v1 Model Card (đọc ngày 12/11/2026)
- ComfyUI Docs: VAE Decode (đọc ngày 12/11/2026)
- ComfyUI Docs: VAE Encode (đọc ngày 12/11/2026)


