Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.
Mạng nén dữ liệu vào biểu diễn chiều thấp rồi tái tạo lại, học đặc trưng quan trọng nhất.
lesson115 minKiến trúc tiên tiếnAI Researcher
Dự đoán
Hãy tưởng tượng bạn cần gửi một tấm ảnh 1 MB qua đường truyền chỉ cho phép 10 KB mỗi gói. Bạn nén ảnh xuống, gửi đi, rồi giải nén ở đầu bên kia. Câu hỏi là...
Nén 100 lần thì buộc phải mất chi tiết! Nhưng thuật toán nén thông minh sẽ giữ lại bản chất (hình dạng, màu chính) và bỏ chi tiết nhỏ (texture, noise). Autoencoder học cách nén thông minh này một cách tự động, không cần ai dạy.
Bottleneck quyết định điều gì
Bottleneck càng nhỏ → càng mờ, nhưng mạng buộc phải học bản chất của chữ số (đường cong, hình dạng) thay vì nhớ từng pixel.
Khoảnh khắc A-ha
Autoencoder không chỉ nén — nó học ra bản chất. Bottleneck buộc mạng phải tìm ra đặc trưng quan trọng nhất của dữ liệu. Với chữ số viết tay, 2 chiều latent có thể tự học ra độ nghiêng và nét dày. Không ai dạy mạng khái niệm "độ nghiêng" — nó tự khám phá vì đó là chiều biến đổi lớn nhất trong dữ liệu.
Đây là một ví dụ đẹp của unsupervised learning: mạng tự tìm ra cấu trúc ẩn trong dữ liệu, chỉ bằng một nguyên tắc duy nhất — tái tạo lại chính mình.
Các biến thể quan trọng
Vanilla Autoencoder
Nén → giải nén. Học biểu diễn nén. Dùng cho giảm chiều, trích xuất đặc trưng, pretrain encoder.
x → z → x̂
Denoising AE
Input = ảnh bị nhiễu, target = ảnh sạch. Học lọc nhiễu tự động, biểu diễn robust hơn.
x̃ → z → x (sạch)
Sparse AE
Thêm ràng buộc: phần lớn neuron bottleneck phải = 0. Mỗi input chỉ kích hoạt vài neuron. Gần với lí thuyết về "neuron khái niệm" trong não.
L=∥x−x^∥2+λ⋅sparsity(z)
VAE (Variational)
Latent space = phân phối xác suất (thường là Gaussian). Có thể sinh dữ liệu mới bằng lấy mẫu. Nền tảng cho nhiều generative model.
x → μ, σ → sample → x̂
Contractive AE
Thêm phạt Jacobian: ép encoder ít nhạy với biến đổi nhỏ của input. Kết quả: biểu diễn ổn định, gần như bất biến với nhiễu nhỏ.
L=∥x−x^∥2+λ∥∇xfθ(x)∥F2
Masked AE (MAE)
Xóa ngẫu nhiên 75% patch của ảnh, bắt mạng tái tạo lại. Phương pháp self-supervised mạnh cho pretrain Vision Transformer (He et al. 2022).
x → mask → encoder → decoder → x̂
Thử thách nhanh 1
Khi bottleneck ≥ input size, mạng có thể chỉ đơn giản copy input → output (identity mapping). Bottleneck phải NHỎ HƠN input để buộc mạng nén — đây là nguồn gốc tên 'cổ chai'. Denoising AE giải quyết bằng cách thêm nhiễu, buộc mạng phải học bản chất dù bottleneck to.
Giải thích chi tiết
Autoencoder là mạng nơ-ron học ra một cặp hàm: một encoder nén dữ liệu và một decoder tái tạo lại. Mục tiêu là output giống input nhất có thể, với điều kiện phải đi qua một bottleneck thấp chiều.
Encoder: z=fθ(x)∈Rd
Decoder: x^=gϕ(z)∈RD
L(θ,ϕ)=∥x−x^∥2=∥x−gϕ(fθ(x))∥2
Trong đó d << D (bottleneck nhỏ hơn input). Mạng phải tìm cách nén D chiều vào d chiều mà vẫn tái tạo được. Cả θ và φ được học qua stochastic gradient descent — target chính là input, nên autoencoder là self-supervised: không cần nhãn.
Chứng minh: AE tuyến tính = PCA
Chứng minh: AE tuyến tính = PCA (chi tiết)
Xét autoencoder tuyến tính: z = W_1 x, x̂ = W_2 z = W_2 W_1 x, với W_1 ∈ R^{d×D}, W_2 ∈ R^{D×d}, d < D.
Loss MSE cho N mẫu:
L=N1n=1∑N∥xn−W2W1xn∥2
Đặt A = W_2 W_1. Vì rank(A) ≤ d, ta đi tìm ma trận "gần" với I nhất có rank ≤ d dưới norm Frobenius, weighted theo covariance của x. Định lí Eckart-Young cho: nghiệm tối ưu là phép chiếu lên không gian con của d vector riêng ứng với eigenvalue lớn nhất của Σ = (1/N) Σ x_n x_n^T — đây chính là PCA.
Nghĩa là AE tuyến tính đạt cùng một subspace với PCA (dù ma trận W_1 không nhất thiết là các eigenvector đơn vị — chúng có thể sai khác một xoay trong không gian latent).
Khi thêm phi tuyến (ReLU giữa các lớp), autoencoder có thể học manifold cong — điều PCA không làm được. Đây là lí do AE vượt trội PCA trên dữ liệu thực tế (ảnh, âm thanh, văn bản).
Chọn loss function
Chọn loss function cho autoencoder
MSE (||x − x̂||²) là mặc định, nhưng không phải lúc nào cũng tối ưu:
Binary Cross-Entropy cho ảnh nhị phân (MNIST sau khi binarize) hoặc ảnh grayscale normalized [0, 1]. Phạt mạnh hơn khi sai xa biên.
L1 loss khi muốn reconstruction sắc cạnh hơn (MSE dễ cho ra ảnh mờ vì phạt quadratic).
SSIM / Perceptual loss cho ảnh tự nhiên. Dùng features từ VGG pre-trained làm đại diện cho "giống nhau về ngữ nghĩa" thay vì pixel.
Adversarial loss (VAE-GAN) kết hợp AE với discriminator để ép output trông thực.
Spectral loss cho audio — so sánh magnitude spectrum thay vì waveform.
Một quan sát kinh điển: MSE trên ảnh tự nhiên tạo ra output "mờ" vì nó ưa thích giá trị trung bình. Ví dụ, với 2 ảnh có thể là đáp án hợp lệ, MSE tối ưu là lấy trung bình hai ảnh — thường trông xấu. Perceptual loss giải quyết bằng cách đo "giống nhau về nội dung".
Loss tổng quát và code mẫu
Về mặt công thức, loss tổng quát của autoencoder có dạng:
Số hạng regularizer thay đổi theo biến thể: sparsity (sparse AE), KL divergence (VAE), Jacobian norm (contractive AE), adversarial (AAE), v.v.
autoencoder_mnist.py
importtorchimporttorch.nnasnnimporttorch.optimasoptimfromtorch.utils.dataimportDataLoaderfromtorchvisionimportdatasets,transformsclassAutoencoder(nn.Module):"""MNIST autoencoder: 784 → 128 → 32 → 8 → 32 → 128 → 784."""def__init__(self,latent_dim:int=8):super().__init__()self.latent_dim=latent_dim# ─── Encoder ───self.encoder=nn.Sequential(nn.Linear(784,128),nn.ReLU(),nn.Linear(128,32),nn.ReLU(),nn.Linear(32,latent_dim),# ← Bottleneck!)# ─── Decoder (đối xứng) ───self.decoder=nn.Sequential(nn.Linear(latent_dim,32),nn.ReLU(),nn.Linear(32,128),nn.ReLU(),nn.Linear(128,784),nn.Sigmoid(),# Output ∈ [0, 1] — phù hợp với ảnh normalized)defforward(self,x:torch.Tensor)->tuple[torch.Tensor,torch.Tensor]:# x: [B, 784] — flatten ảnh 28×28z=self.encoder(x)# [B, latent_dim]x_hat=self.decoder(z)# [B, 784]returnx_hat,zdefencode(self,x:torch.Tensor)->torch.Tensor:"""Chỉ lấy latent code — dùng cho giảm chiều / anomaly detection."""returnself.encoder(x)defdecode(self,z:torch.Tensor)->torch.Tensor:"""Generate từ latent — lưu ý: vanilla AE không generative tốt."""returnself.decoder(z)# ─── Training loop ───deftrain(latent_dim:int=8,epochs:int=20,batch_size:int=256):device=torch.device("cuda"iftorch.cuda.is_available()else"cpu")transform=transforms.Compose([transforms.ToTensor(),transforms.Lambda(lambdax:x.view(-1)),# flatten 28×28 → 784])train_ds=datasets.MNIST("./data",train=True,download=True,transform=transform)loader=DataLoader(train_ds,batch_size=batch_size,shuffle=True)model=Autoencoder(latent_dim=latent_dim).to(device)optimizer=optim.Adam(model.parameters(),lr=1e-3)# BCE phù hợp với ảnh normalized [0, 1]loss_fn=nn.BCELoss()forepochinrange(epochs):total=0.0forx,_inloader:# bỏ qua nhãn — self-supervised!x=x.to(device)x_hat,_=model(x)loss=loss_fn(x_hat,x)optimizer.zero_grad()loss.backward()optimizer.step()total+=loss.item()*x.size(0)avg=total/len(train_ds)print(f"Epoch {epoch + 1:2d}/{epochs} | loss = {avg:.4f}")returnmodel# ─── Sử dụng latent code cho anomaly detection ───@torch.no_grad()defanomaly_score(model:Autoencoder,x:torch.Tensor)->torch.Tensor:"""Reconstruction error cao → anomaly."""x_hat,_=model(x)# Per-sample MSEreturn((x-x_hat)**2).mean(dim=-1)if__name__=="__main__":model=train(latent_dim=8,epochs=10)# Kiểm tra: sample 1 mẫu, xem lossx_sample=next(iter(DataLoader(datasets.MNIST("./data",train=False,download=True,transform=transforms.Compose([transforms.ToTensor(),transforms.Lambda(lambdax:x.view(-1)),]),),batch_size=1,)))[0]scores=anomaly_score(model,x_sample)print(f"Anomaly score: {scores.item():.4f}")
denoising_autoencoder.py
"""Denoising Autoencoder — variant quan trọng:
input = ảnh + nhiễu, target = ảnh sạch.
Mạng phải hiểu bản chất dữ liệu để lọc nhiễu."""importtorchimporttorch.nnasnnclassDenoisingAE(nn.Module):"""Convolutional Denoising AE cho MNIST."""def__init__(self,latent_dim:int=32):super().__init__()# Encoder: 28×28 → 14×14 → 7×7 → latentself.encoder=nn.Sequential(nn.Conv2d(1,16,3,stride=2,padding=1),# 28 → 14nn.ReLU(),nn.Conv2d(16,32,3,stride=2,padding=1),# 14 → 7nn.ReLU(),nn.Flatten(),nn.Linear(32*7*7,latent_dim),)# Decoder: latent → 7×7 → 14×14 → 28×28self.decoder=nn.Sequential(nn.Linear(latent_dim,32*7*7),nn.ReLU(),nn.Unflatten(1,(32,7,7)),nn.ConvTranspose2d(32,16,3,stride=2,padding=1,output_padding=1),nn.ReLU(),nn.ConvTranspose2d(16,1,3,stride=2,padding=1,output_padding=1),nn.Sigmoid(),)defforward(self,x_noisy):z=self.encoder(x_noisy)x_hat=self.decoder(z)returnx_hatdefadd_gaussian_noise(x:torch.Tensor,sigma:float=0.3)->torch.Tensor:"""Thêm nhiễu Gaussian. sigma lớn → nhiễu mạnh."""return(x+sigma*torch.randn_like(x)).clamp(0,1)deftrain_denoising(model,loader,optimizer,loss_fn,epochs=20,sigma=0.3):model.train()forepochinrange(epochs):total=0.0forx,_inloader:x_clean=x# target là ảnh sạchx_noisy=add_gaussian_noise(x_clean,sigma=sigma)x_hat=model(x_noisy)# Loss giữa output và ảnh SẠCH (không phải noisy input!)loss=loss_fn(x_hat,x_clean)optimizer.zero_grad()loss.backward()optimizer.step()total+=loss.item()*x.size(0)print(f"Epoch {epoch + 1:2d} | loss = {total / len(loader.dataset):.4f}")# Điểm mấu chốt: mạng không thể chỉ copy input sang output# (vì input ≠ target). Nó BUỘC phải học lọc nhiễu → biểu diễn robust.## Denoising AE là tiền thân của:# - BERT: mask 15% token, dự đoán lại → "denoising" trong NLP# - MAE (Masked AE): mask 75% patch ảnh → pretrain cho ViT# - Diffusion models: denoising lặp lại thành generative mạnh nhất hiện nay
Một cách nhìn đang rất thịnh hành gần đây: mọi mô hình denoising đủ mạnh đều trở thành generative model. Diffusion models (Stable Diffusion, DALL-E 3, Imagen) về cơ bản là chuỗi các denoising autoencoder lặp lại — mỗi bước khử một ít nhiễu. Bằng cách học phân phối của noise ở mọi mức, chúng có thể sinh ảnh từ pure noise. Autoencoder — tưởng chừng chỉ là kĩ thuật nén — đang là gốc rễ của generative AI hiện đại.
Thử thách nhanh 2
Vanilla AE không ràng buộc phân phối của z. Có thể encoder chỉ dùng một vùng bé trong latent space. Sample từ N(0, I) rơi vào vùng encoder chưa bao giờ "thăm" → decoder chưa học cách xử lí → output vô nghĩa. VAE giải quyết bằng KL divergence với N(0, I).
Ghi nhớ về Autoencoder
Ghi nhớ về Autoencoder
Encoder + Bottleneck + Decoder. Mục tiêu: x̂ ≈ x qua một cổ chai d << D.
Bottleneck buộc mạng học đặc trưng quan trọng nhất — nonlinear PCA.
AE tuyến tính + MSE ≡ PCA. Phi tuyến → mạnh hơn PCA, học được manifold cong.