ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Kiến trúc tiên tiến

AI Researcher

Mạng đối sinh

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Hai mạng cạnh tranh: Generator tạo dữ liệu giả, Discriminator phân biệt thật/giả

lesson115 minKiến trúc tiên tiếnAI Researcher

Dự đoán

Bạn nhìn 2 bức tranh. Một do hoạ sĩ vẽ, một do AI tạo. Bạn có thể phân biệt không?

AI sinh ảnh ngày nay rất giỏi — nhờ GAN, nơi AI 'giả mạo' và AI 'thám tử' cạnh tranh nhau!

Bài học này sẽ đưa bạn vào vai trò của Discriminator: một thám tử phải phân biệt ảnh thật và ảnh giả. Qua 8 vòng chơi, bạn sẽ cảm nhận được điều mà một mạng neural thực sự đối mặt — đối thủ ngày càng tinh vi hơn.

Loss dao động

Hai đường loss dao động quanh điểm cân bằng

Không giống mạng bình thường (loss chỉ giảm), GAN có 2 mạng chơi tay đôi. Khi D giỏi hơn, loss G tăng. Khi G giỏi hơn, loss D tăng. Cuối cùng cả hai dao động gần đường log 2 ≈ 0.69.

Mode collapse

Khi Generator chọn đường "dễ" — mode collapse

Nếu G tìm được một mẫu nào đó lừa được D, nó có thể "lười" và sinh mẫu đó mãi. Dữ liệu thật có 4 modes (cụm), nhưng G chỉ phủ 1 — thiếu đa dạng hoàn toàn.

Tại sao mode collapse lại xảy ra?

  • Cân bằng minimax rất bất ổn — G có thể kẹt ở "điểm chiến thắng cục bộ" (chỉ cần lừa D một pattern).
  • Learning rate G quá cao → G nhảy sang 1 mode rồi bỏ quên phần còn lại.
  • D không đủ mạnh hoặc cập nhật quá chậm — nó không phạt được G khi bỏ mode.

Cách giảm mode collapse

  • Dùng WGAN-GP — Wasserstein loss cho gradient mượt.
  • Minibatch discrimination: D nhìn cả batch, phát hiện "các ảnh giống hệt nhau".
  • Unrolled GAN: G nhìn trước vài bước của D khi tính gradient.
  • Chuyển sang Diffusion Models hoặc VAE nếu đa dạng quan trọng hơn sắc nét.

cGAN — sinh có điều kiện

Conditional GAN: nói cho G biết muốn tạo gì

Trong GAN gốc, G tạo ảnh ngẫu nhiên. Trong cGAN, ta đưa thêm label y (ví dụ: "số 7", "ảnh chó", "ảnh mũi tên") vào cả G và D. Ta điều khiển được loại ảnh được sinh ra.

cGAN học phân phối có điều kiện p(x∣y)p(x \mid y). Giữ nguyên y, đổi z → cùng loại, khác chi tiết. Đổi y → sang lớp khác.

Latent space walk và StyleGAN

Đi dạo trong latent space (StyleGAN style)

Một Generator tốt học một không gian latent liên tục: mỗi điểm z tương ứng một ảnh, và các điểm gần nhau sinh ra ảnh giống nhau. Di chuyển z dọc theo một chiều = biến đổi ảnh theo một thuộc tính.

StyleGAN học một latent space "disentangled": mỗi chiều kiểm soát một thuộc tính. Đi dạo mượt ở đây tương ứng với nội suy khuôn mặt, tuổi, hay phong cách trong các mô hình thực tế.

StyleGAN nổi bật nhờ điểm gì so với GAN gốc?

StyleGAN dùng mapping network (z → w) và chèn style w vào mỗi tầng của generator qua AdaIN. Kết quả: disentangled latents + kiểm soát phong cách ở nhiều scale (coarse: tư thế, middle: tóc, fine: màu da).

DCGAN vs WGAN

So sánh hai biến thể cơ bản

DCGAN (2015) là baseline CNN mạnh nhưng unstable. WGAN (2017) thay loss bằng Wasserstein distance — ổn định hơn nhiều, đổi lại tốc độ huấn luyện chậm hơn.

Loss:

v.lossFormulav.lossFormula

DCGAN trick: kiến trúc thuần CNN

  • Thay FC bằng strided convolutions (D) + fractional-strided conv (G).
  • Dùng BatchNorm ở cả G và D (trừ output layer).
  • G dùng ReLU + Tanh ở output; D dùng LeakyReLU.
  • Không dùng pooling — chỉ strided conv.

WGAN-GP trick: Gradient Penalty

WGAN gốc dùng weight clipping (|w| ≤ 0.01) để đảm bảo Lipschitz — đơn giản nhưng làm giảm capacity của D.

WGAN-GP thay bằng penalty:

λ⋅Ex^[(∥∇x^D(x^)∥2−1)2]\lambda \cdot \mathbb{E}_{\hat{x}}\left[(\|\nabla_{\hat{x}} D(\hat{x})\|_2 - 1)^2\right]

Trong đó x̂ lấy mẫu dọc đường thẳng giữa ảnh thật và giả. Mềm mà hiệu quả.

Giải thích và mã nguồn

GAN (Generative Adversarial Network) gồm hai mạng huấn luyện đối kháng theo trò chơi minimax:

min⁡Gmax⁡D  V(D,G)=Ex∼pdata[log⁡D(x)]+Ez∼pz[log⁡(1−D(G(z)))]\min_G \max_D \; V(D, G) = \mathbb{E}_{x \sim p_{data}}[\log D(x)] + \mathbb{E}_{z \sim p_z}[\log(1 - D(G(z)))]
  • D muốn tối đa V: phân biệt đúng thật/giả.
  • G muốn tối thiểu V: lừa D nghĩ ảnh giả là thật.
  • Cân bằng Nash: D∗(x)=pdata(x)pdata(x)+pg(x)D^*(x) = \tfrac{p_{data}(x)}{p_{data}(x) + p_g(x)} và khi pg=pdatap_g = p_{data} thì D∗(x)=0.5D^*(x) = 0.5 cho mọi x.

Vòng huấn luyện: Mỗi bước, ta huấn luyện D trước (cố định G), rồi huấn luyện G (cố định D). Hai mạng luân phiên cải thiện cho đến khi đạt cân bằng — hoặc phân kỳ nếu không cẩn thận.

Training loop cơ bản (DCGAN)

for epoch in range(epochs):
    for real_batch in dataloader:
        # 1. Huấn luyện Discriminator
        z = torch.randn(batch_size, latent_dim, device=device)
        fake = generator(z).detach()

        loss_D = -torch.mean(
            torch.log(discriminator(real_batch) + 1e-8)
            + torch.log(1 - discriminator(fake) + 1e-8)
        )
        optimizer_D.zero_grad()
        loss_D.backward()
        optimizer_D.step()

        # 2. Huấn luyện Generator
        z = torch.randn(batch_size, latent_dim, device=device)
        fake = generator(z)
        loss_G = -torch.mean(torch.log(discriminator(fake) + 1e-8))
        optimizer_G.zero_grad()
        loss_G.backward()
        optimizer_G.step()

WGAN-GP — biến thể ổn định hơn

def gradient_penalty(D, real, fake):
    alpha = torch.rand(real.size(0), 1, 1, 1, device=real.device)
    interp = alpha * real + (1 - alpha) * fake
    interp.requires_grad_(True)

    d_interp = D(interp)
    grads = torch.autograd.grad(
        outputs=d_interp, inputs=interp,
        grad_outputs=torch.ones_like(d_interp),
        create_graph=True, retain_graph=True,
    )[0]
    grads = grads.view(real.size(0), -1)
    gp = ((grads.norm(2, dim=1) - 1) ** 2).mean()
    return gp

# Trong training loop
for epoch in range(epochs):
    for real in dataloader:
        # D step (lặp 5 lần mỗi G step)
        for _ in range(5):
            z = torch.randn(real.size(0), latent_dim, device=device)
            fake = generator(z).detach()

            gp = gradient_penalty(discriminator, real, fake)
            loss_D = (
                discriminator(fake).mean()
                - discriminator(real).mean()
                + 10.0 * gp
            )
            optimizer_D.zero_grad()
            loss_D.backward()
            optimizer_D.step()

        # G step
        z = torch.randn(real.size(0), latent_dim, device=device)
        fake = generator(z)
        loss_G = -discriminator(fake).mean()
        optimizer_G.zero_grad()
        loss_G.backward()
        optimizer_G.step()

Biến thể quan trọng:

  • StyleGAN — kiểm soát phong cách ở nhiều mức (tóc, khuôn mặt, nền). Tạo khuôn mặt siêu thực.
  • CycleGAN — chuyển đổi phong cách không cần cặp ảnh (ngựa ↔ ngựa vằn, ảnh ↔ tranh Monet).
  • Pix2Pix — biến đổi ảnh theo cặp (bản phác → ảnh thật, nhãn → ảnh đường phố).
  • BigGAN / StyleGAN-XL — scale lên hàng trăm triệu tham số, ảnh 1024×1024 chất lượng cao.
  • GigaGAN — biến thể lớn cho text-to-image, cạnh tranh với diffusion về chất lượng nhưng nhanh hơn.
Nếu Generator quá giỏi nhưng chỉ tạo được MỘT loại ảnh (luôn là mèo), vấn đề gì xảy ra?

Mode collapse là khi Generator chỉ học 1 pattern 'an toàn'. Đây là thách thức lớn nhất của GAN!

Tóm tắt

  • GAN gồm Generator (tạo dữ liệu giả từ z ~ N(0,1)) và Discriminator (phân biệt thật/giả), huấn luyện đối kháng.
  • Mục tiêu minimax V(D,G): G cố lừa D, D cố phát hiện G — cân bằng Nash khi D(x) = 0.5 với mọi x.
  • Loss G và D dao động ngược pha; không bao giờ giảm mượt như mạng bình thường — đừng hoảng khi thấy loss lên xuống.
  • Thách thức lớn nhất: mode collapse — G chỉ học 1 pattern 'an toàn'. WGAN-GP giảm đáng kể rủi ro này.
  • cGAN thêm label y vào cả G và D để điều khiển loại ảnh; StyleGAN thêm mapping network cho latent disentangled.
  • Biến thể phổ biến: DCGAN (baseline CNN), WGAN-GP (ổn định), CycleGAN, Pix2Pix, BigGAN, StyleGAN. Diffusion Models đang dần thay thế GAN cho text-to-image.

Continue the module

Lesson 6 of 12