Bài 42: Denoising Autoencoder — học biểu diễn robust

Sau bài học, bạn sẽ:

• Phát biểu được vấn đề identity function của AE cơ bản và lý do DAE giải được.
• Viết được công thức DAE: \( \tilde{x} = x + \epsilon \), loss \( L = \| x - g(f(\tilde{x})) \|^2 \), nhấn mạnh target là \( x \) (clean), không phải \( \tilde{x} \).
• Liệt kê 4 loại noise (Gaussian, salt-and-pepper, masking, multiplicative) và biết khi nào dùng.
• Implement DAE MNIST bằng PyTorch với Gaussian noise.
• So sánh DAE và AE cùng architecture trên cùng dataset.
• Hiểu Stacked DAE (Vincent 2010) là tiền đề của modern pretraining.
• Kết nối DAE với Masked Autoencoder (He 2021), BERT (Devlin 2018), Diffusion Model (Ho 2020) — cùng ý tưởng "khôi phục thông tin bị che/nhiễu".

Bài này tiếp Bài 41 — Autoencoder và mở đường cho Bài 43 — VAE intuition.

AE cơ bản train với mục tiêu reconstruct chính input:

\[ \min_{f, g} \; \mathbb{E}_x \big[ \| x - g(f(x)) \|^2 \big] \]

Nếu bottleneck \( z = f(x) \) có chiều \( d_z < d_x \), mô hình bị ép phải nén → học manifold của data. Nhưng khi:

• Bottleneck đủ rộng (\( d_z \geq d_x \), over-complete), hoặc
• Encoder–decoder đủ capacity (deep, nhiều parameter),

thì tồn tại nghiệm tầm thường: \( f = \text{id} \), \( g = \text{id} \), loss = 0, nhưng latent space không chứa gì có nghĩa. Đây là identity function risk.

AE cơ bản dựa vào bottleneck hẹp như regularization implicit. Nhưng đôi khi ta muốn latent rộng hơn input (over-complete sparse code, mục đích biểu diễn feature) — lúc đó cần dạng regularization khác. DAE là một dạng như vậy.

Vincent, Larochelle, Bengio, Manzagol (2008) — "Extracting and Composing Robust Features with Denoising Autoencoders" — đề xuất sửa đổi rất nhỏ:

1. Cho input sạch \( x \).
2. Sinh phiên bản nhiễu \( \tilde{x} \sim q(\tilde{x} \mid x) \) — ví dụ \( \tilde{x} = x + \epsilon \) với \( \epsilon \sim \mathcal{N}(0, \sigma^2 I) \).
3. Cho \( \tilde{x} \) vào encoder, decoder reconstruct ra \( \hat{x} = g(f(\tilde{x})) \).
4. So sánh \( \hat{x} \) với \( x \) (sạch), không phải \( \tilde{x} \) (nhiễu).

AE cơ bản:           x  ──► encoder ──► z ──► decoder ──► x̂  ≈ x
DAE (Vincent 2008):  x ─►(thêm noise)─► x̃ ──► encoder ──► z ──► decoder ──► x̂  ≈ x  (clean)
                                                                              ▲
                                                                              └─ target sạch

Chú ý: target là \( x \), không phải \( \tilde{x} \). Đây là điểm dễ nhầm khi implement lần đầu — feed nhiễu, học để output sạch.

Gọi \( q(\tilde{x} \mid x) \) là phân phối corruption (do ta chọn). Loss DAE:

\[ L_{\text{DAE}} = \mathbb{E}_{x \sim p_{\text{data}}}\; \mathbb{E}_{\tilde{x} \sim q(\tilde{x} \mid x)} \big[ \| x - g(f(\tilde{x})) \|^2 \big] \]

Với noise Gaussian additive đơn giản:

\[ \tilde{x} = x + \epsilon, \quad \epsilon \sim \mathcal{N}(0, \sigma^2 I) \] \[ L = \| x - g(f(\tilde{x})) \|^2 \]

So với AE cơ bản (\( L_{\text{AE}} = \| x - g(f(x)) \|^2 \)), chỉ khác đối số bên trong \( g(f(\cdot)) \). Đơn giản về mặt code, nhưng hệ quả khác hẳn.

Cho ảnh nhị phân hoặc pixel \( \in [0, 1] \) (MNIST), có thể dùng binary cross-entropy thay MSE:

\[ L = -\sum_i \big[ x_i \log \hat{x}_i + (1 - x_i) \log (1 - \hat{x}_i) \big] \]

Bốn lý do chính:

1. Không thể học identity. Vì input là \( \tilde{x} \) còn output kỳ vọng là \( x \), \( f = \text{id}, g = \text{id} \) không còn là nghiệm tối ưu. Encoder–decoder buộc phải làm gì đó hữu ích.
2. Học invariant feature. Mọi phiên bản nhiễu \( \tilde{x}_1, \tilde{x}_2, \ldots \) của cùng một \( x \) phải map về vùng latent gần nhau (để decoder ra cùng \( \hat{x} \approx x \)). Encoder học biểu diễn robust với nhiễu input.
3. Học manifold data. Trực giác hình học: data thật nằm trên manifold \( \mathcal{M} \subset \mathbb{R}^d \) chiều thấp. Khi thêm noise, \( \tilde{x} \) bị đẩy ra ngoài manifold. Decoder học cách chiếu lại \( \tilde{x} \) về \( \mathcal{M} \) — tức là học cấu trúc của \( \mathcal{M} \). Bengio, Yao, Alain, Vincent (2013) chứng minh DAE xấp xỉ score function \( \nabla_x \log p(x) \) — kết quả này là nền tảng cho Diffusion Model sau này (mục 17).
4. Implicit regularization. Alain & Bengio (2014) chỉ ra với noise Gaussian nhỏ, DAE tương đương AE với contractive penalty \( \| \nabla_x f(x) \|^2 \) — encoder bị phạt khi quá nhạy với input. Một dạng regularization tự nhiên.

Latent của DAE, vì các lý do trên, thường tách lớp tốt hơn AE thường khi dùng làm feature cho downstream task (classification, clustering).

Việc chọn \( q(\tilde{x} \mid x) \) ảnh hưởng đến loại feature mà DAE học. Bốn dạng phổ biến:

Vincent 2008 dùng chính masking noise với \( p = 0.25 \) cho MNIST. Gaussian noise được Bengio và đồng nghiệp phân tích kỹ về mặt lý thuyết (2013, 2014).

Cho dữ liệu khác ảnh: text dùng masking (BERT), audio dùng additive Gaussian hoặc background noise, embedding dùng Gaussian nhỏ.

Noise level (\( \sigma \) cho Gaussian, \( p \) cho masking) là siêu tham số quan trọng nhất:

• Quá thấp (\( \sigma \to 0 \), \( p \to 0 \)): DAE thoái hoá về AE thường — không có regularization đáng kể.
• Quá cao (\( \sigma \) lớn, \( p \to 1 \)): \( \tilde{x} \) không còn đủ thông tin để khôi phục \( x \) — model học một loại trung bình thô của data, output bị blur.
• Sweet spot: phụ thuộc data. Cho MNIST với pixel \( \in [0, 1] \), Gaussian \( \sigma \in [0.1, 0.5] \) hoặc masking \( p \in [0.1, 0.5] \) là khoảng thử thường dùng.

Cách chọn thực dụng: train 3 model với 3 mức noise (vd 0.1, 0.3, 0.5), so sánh chất lượng reconstruction trên test set và chất lượng feature khi linear-probe sang classification.

Quan sát: noise level tối ưu cho reconstruction thường thấp hơn noise level tối ưu cho downstream feature. Khi mục tiêu là feature pretraining, có thể dùng noise mạnh hơn.

DAE không đổi kiến trúc — chỉ đổi cách feed dữ liệu. Một số lưu ý nhỏ:

• Bottleneck có thể rộng hơn AE thường vì không sợ identity. Vincent 2008 chính dùng cấu hình over-complete (hidden > input) cho MNIST 784 với hidden 1000.
• Activation: ReLU hoặc Sigmoid (output cuối) tuỳ data range.
• Loss: MSE cho continuous, BCE cho \( [0, 1] \).
• Optimizer: Adam, lr 1e-3 là default tốt.

Cho ảnh, biến thể phổ biến là Convolutional DAE (mục 10) — encoder Conv + decoder ConvTranspose.

DAE fully-connected cho MNIST 784 chiều, Gaussian noise:

import torch
import torch.nn as nn
import torch.nn.functional as F

class DAE(nn.Module):
    def __init__(self, in_dim=784, hid=400, z_dim=64):
        super().__init__()
        self.enc = nn.Sequential(nn.Linear(in_dim, hid), nn.ReLU(),
                                 nn.Linear(hid, z_dim), nn.ReLU())
        self.dec = nn.Sequential(nn.Linear(z_dim, hid), nn.ReLU(),
                                 nn.Linear(hid, in_dim), nn.Sigmoid())

    def forward(self, x):
        z = self.enc(x)
        return self.dec(z)

def add_noise(x, noise_factor=0.3):
    return torch.clamp(x + noise_factor * torch.randn_like(x), 0.0, 1.0)

model = DAE().cuda()
optim = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(20):
    for x, _ in train_loader:                  # x: (B, 1, 28, 28) -> flatten
        x_clean = x.view(x.size(0), -1).cuda()
        x_noisy = add_noise(x_clean, 0.3)
        x_recon = model(x_noisy)
        loss    = F.mse_loss(x_recon, x_clean)  # target = CLEAN, not noisy
        optim.zero_grad(); loss.backward(); optim.step()

Các điểm dễ sai khi mới làm:

• x_recon so với x_clean, KHÔNG so với x_noisy. Quên dòng này → model học identity của noisy input → không denoising được gì.
• Clamp về \( [0, 1] \) sau khi thêm noise nếu data là pixel — tránh giá trị âm hoặc > 1.
• Sinh noise mới mỗi batch (\( \text{randn\_like}(x) \)), không cache — mục đích là model thấy nhiều biến thể noise của cùng một sample qua các epoch.

Cho ảnh kích thước > 32×32, fully-connected nhanh chóng vô lý (số param khổng lồ, mất cấu trúc không gian). Convolutional DAE dùng Conv + ConvTranspose:

class ConvDAE(nn.Module):
    def __init__(self):
        super().__init__()
        self.enc = nn.Sequential(
            nn.Conv2d(1, 32, 3, stride=2, padding=1), nn.ReLU(),   # 28 -> 14
            nn.Conv2d(32, 64, 3, stride=2, padding=1), nn.ReLU(),  # 14 -> 7
        )
        self.dec = nn.Sequential(
            nn.ConvTranspose2d(64, 32, 3, stride=2, padding=1, output_padding=1), nn.ReLU(),
            nn.ConvTranspose2d(32, 1, 3, stride=2, padding=1, output_padding=1), nn.Sigmoid(),
        )

    def forward(self, x):
        return self.dec(self.enc(x))

Input giữ nguyên shape (B, 1, 28, 28); add Gaussian noise trực tiếp trên tensor 4D. Loss và training loop không đổi so với fully-connected DAE.

Cho CIFAR-10 (B26), CelebA, dùng cấu trúc tương tự với 3 channel và stack sâu hơn (3–4 conv block mỗi side).

Kết luận thực dụng: nếu mục tiêu chỉ là nén lossy thuần (vd lưu trữ), AE thường đủ. Nếu mục tiêu là feature learning hoặc denoising thật, DAE gần như luôn tốt hơn với chi phí thêm không đáng kể.

• Image denoising: cleanup ảnh y khoa (CT, MRI), ảnh camera điều kiện thiếu sáng, ảnh quét tài liệu. Train trên cặp (ảnh sạch, ảnh nhiễu) sinh tổng hợp.
• Speech enhancement: remove background noise trong tín hiệu thoại. Input là spectrogram nhiễu, output là spectrogram sạch. Dùng nhiều trong tai nghe khử ồn, ASR pipeline.
• OCR preprocessing: làm sạch document quét trước khi OCR — bóng, vệt mực, jpeg artifact.
• Pretrained representation: train DAE trên unlabeled data lớn, dùng encoder làm feature cho downstream task. Đây là dạng self-supervised learning đầu tiên (Vincent 2008, ~5 năm trước word2vec).
• Anomaly detection: tương tự AE — sample bất thường có reconstruction error lớn. DAE thường robust hơn với outlier nhỏ.

Trước neural net, image denoising được giải bằng filter cổ điển:

• Wavelet shrinkage (Donoho 1995): biến đổi wavelet, ngưỡng hệ số nhỏ về 0, biến đổi ngược.
• BM3D (Dabov và cộng sự, 2007): block matching và collaborative filtering trong miền 3D. Long state-of-the-art trong gần một thập kỷ.
• Non-local means (Buades 2005): trung bình có trọng số trên patch tương tự.

Nguyên tắc thực dụng: nếu có labeled cặp clean–noisy đủ và domain ổn định, neural denoiser thường thắng. Nếu không có data hoặc cần generalize rộng, classic vẫn là lựa chọn tốt.

Vincent, Larochelle, Lajoie, Bengio, Manzagol (2010) — "Stacked Denoising Autoencoders" — mở rộng DAE thành scheme pretraining nhiều tầng:

1. Train DAE layer 1 (input → hidden 1 → reconstruct input).
2. Đóng băng layer 1. Lấy output \( h_1(x) \) làm input mới.
3. Train DAE layer 2 (\( h_1 \) → hidden 2 → reconstruct \( h_1 \)).
4. Đóng băng. Tiếp tục cho layer 3, 4, ...
5. Sau cùng, ghép tất cả layer encoder lại, thêm 1 classifier head, fine-tune end-to-end với label.

Đây là kỹ thuật greedy layer-wise pretraining — cùng thời với Hinton DBN (Deep Belief Network, 2006). Trong giai đoạn 2006–2012, khi training deep network end-to-end còn rất khó do vanishing gradient (B36) và init kém (B33), Stacked DAE và DBN là cách thực dụng để khởi tạo trọng số tốt cho deep network.

Từ ~2012 trở đi, với ReLU (B22), BatchNorm (B28), Adam (B19), residual connection (B25), training end-to-end trở nên dễ → layer-wise pretraining không còn cần. Nhưng ý tưởng self-supervised pretraining không mất — nó tái sinh dưới dạng word2vec, BERT, MAE, SimCLR và toàn bộ foundation model hiện nay.

He, Chen, Xie, Li, Dollár, Girshick (2021) — "Masked Autoencoders Are Scalable Vision Learners" — đưa ý tưởng DAE vào ViT (Vision Transformer):

• Chia ảnh thành patch 16×16 (giống ViT).
• Mask ngẫu nhiên 75% patch.
• Chỉ feed 25% patch còn lại vào encoder ViT (rất hiệu quả vì input ngắn).
• Decoder (nhỏ, lightweight) reconstruct toàn bộ patch — cả visible và masked.
• Loss MSE trên pixel của patch bị mask.

Mask ratio 75% là điểm khác biệt với BERT (15%) và DAE classic. Tác giả lý giải: ảnh có nhiều redundancy không gian, mask ít quá thì task trivial (interpolate hàng xóm). 75% buộc model học cấu trúc semantic.

MAE pretraining đạt 87.8% top-1 ImageNet với ViT-Huge — vượt cả supervised pretraining cùng kích thước, mở đường cho self-supervised vision lớn.

MAE thực chất là DAE với masking noise cực mạnh — một mạch trực tiếp từ Vincent 2008 đến He 2021.

Devlin, Chang, Lee, Toutanova (2018) — "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding" — áp dụng cùng ý tưởng cho text:

• Cho câu input, mask ngẫu nhiên ~15% token bằng special token [MASK].
• Train Transformer encoder predict token bị mask, điều kiện trên các token còn lại (cả trái và phải — bidirectional).
• Loss: cross-entropy trên token bị mask.

Đây chính là masked language model (MLM), và về bản chất là DAE cho text với masking noise:

DAE (Vincent 2008):  x ─►(mask 25% pixel)─► x̃ ─► encoder ─► decoder ─► x̂  ≈ x
BERT (Devlin 2018):  câu ─►(mask 15% token)─► câũ ─► Transformer ─► token bị mask
MAE (He 2021):       ảnh ─►(mask 75% patch)─► ảnh̃ ─► ViT enc ─► decoder ─► patch bị mask

Tất cả cùng paradigm: "Predict the missing parts." Đây là một trong hai trục chính của self-supervised learning (trục còn lại là contrastive learning — SimCLR, CLIP). Series 4 Module 2 sẽ deep dive BERT, masked language model, và downstream fine-tuning.

Mở rộng DAE theo trục nhiều mức noise dẫn thẳng tới Diffusion Model:

• Thay vì 1 mức noise cố định, định nghĩa chuỗi noise tăng dần \( x_0 \to x_1 \to \ldots \to x_T \) qua \( T \) bước (thường \( T = 1000 \)), mỗi bước \( x_t = \sqrt{1 - \beta_t} x_{t-1} + \sqrt{\beta_t} \epsilon \).
• Tại \( t = T \), \( x_T \) gần như Gaussian thuần.
• Train một mạng (U-Net) làm DAE cho mọi mức noise — input \( x_t \) và \( t \), predict \( x_0 \) (hoặc noise \( \epsilon \), tương đương).
• Sinh ảnh mới: bắt đầu từ \( x_T \sim \mathcal{N}(0, I) \), apply mạng denoise lặp \( T \) lần để đi ngược về \( x_0 \).

Sohl-Dickstein và cộng sự (2015) đặt nền lý thuyết. Ho, Jain, Abbeel (2020) — "Denoising Diffusion Probabilistic Models" (DDPM) — chứng minh thực nghiệm chất lượng sinh ảnh vượt GAN. Stable Diffusion, DALL-E 2/3, Imagen, Sora đều là biến thể của paradigm này.

Bengio và cộng sự (2013) chứng minh DAE xấp xỉ \( \nabla_x \log p(x) \) — score function — và Diffusion Model dùng chính score function này để sample. Mạch lý thuyết DAE → score matching → Diffusion là một trong những kết nối đẹp nhất của deep learning gần đây.

Series 4 Module image generation sẽ deep dive: forward/reverse process, U-Net cho diffusion, classifier-free guidance, latent diffusion, conditioning text-to-image.

1. Implement DAE MNIST với 3 mức Gaussian noise \( \sigma \in \{0.1, 0.3, 0.5\} \). Train 20 epoch mỗi config, so sánh MSE reconstruction trên test set (input noisy với cùng \( \sigma \)). Mức noise nào cho reconstruction tốt nhất? Visualize 8 sample noisy + reconstruction cho mỗi config.
2. Train AE và DAE cùng architecture (hidden 400, z 64) trên MNIST. Test cả 2 model với input nhiễu (\( \sigma = 0.3 \)). So sánh MSE — DAE thắng bao nhiêu?
3. Đổi noise sang masking: random 50% pixel = 0. Train DAE và visualize reconstruction. Khác gì so với Gaussian noise về mặt định tính?
4. Test out-of-distribution: train DAE với Gaussian \( \sigma = 0.3 \). Test với 2 loại noise không thấy ở train: (a) salt-and-pepper \( p = 0.1 \), (b) Gaussian \( \sigma = 0.5 \). Generalize tốt không? Vì sao?
5. Train DAE rồi đóng băng encoder; thêm linear head (z_dim → 10) và train classifier MNIST. So sánh accuracy với (a) AE pretrained, (b) random init + supervised. Có pretraining boost không?
6. Implement Convolutional DAE cho CIFAR-10 (B26 dataset). Add Gaussian noise \( \sigma = 0.1 \). Train 50 epoch. Visualize reconstruction — model có giữ được màu, texture không?
7. Đọc paper DDPM (Ho 2020) đến hết Section 3. Trả lời ngắn: "score function" trong diffusion bằng cách nào kế thừa DAE? Hint: xem Equation 14 và liên hệ với mục 17 bài này.

• AE cơ bản có rủi ro học identity function khi capacity đủ lớn — latent không chứa thông tin có nghĩa.
• DAE (Vincent 2008) sửa bằng cách feed \( \tilde{x} = x + \epsilon \) (nhiễu), target reconstruction là \( x \) (sạch).
• Loss: \( L = \| x - g(f(\tilde{x})) \|^2 \). Target là \( x \), không phải \( \tilde{x} \) — điểm dễ nhầm khi implement.
• 4 loại noise: Gaussian (continuous), salt-and-pepper, masking (input dropout), multiplicative Bernoulli.
• DAE buộc model học invariant feature, manifold projection, xấp xỉ score function \( \nabla_x \log p(x) \) (Bengio 2013, Alain 2014).
• Noise level là hyperparameter quan trọng nhất — thử 0.1, 0.3, 0.5 cho MNIST.
• Architecture giống AE thường; chỉ thêm 1 hàm add_noise ở training loop.
• Conv DAE cho ảnh: Conv encoder + ConvTranspose decoder.
• Use case: image denoising, speech enhancement, OCR cleanup, pretrained representation, anomaly detection.
• Stacked DAE (Vincent 2010) là tiền đề của modern pretraining — greedy layer-wise.
• Masked Autoencoder (He 2021): mask 75% patch ViT, reconstruct — DAE với masking cực mạnh. SOTA self-supervised vision.
• BERT (Devlin 2018): masked language model — DAE cho text với masking 15% token. Foundation pretraining LLM.
• Diffusion Model (Ho 2020, DDPM): chuỗi DAE cho nhiều mức noise. Stable Diffusion, DALL-E là descendant. Series 4 deep dive.
• Mạch xuyên: AE → DAE → Stacked DAE → BERT/MAE/Diffusion. Một ý tưởng đơn giản "predict the missing parts" trải dài 15 năm và là backbone của nhiều SOTA hiện nay.