GAN补疑指南：从数学推导到PyTorch实战的11个关键问题解析

1次阅读

共计 2004 个字符，预计需要花费 6 分钟才能阅读完成。

GAN（Generative Adversarial Network，生成对抗网络）通过生成器（Generator）和判别器（Discriminator）的对抗训练，在图像生成、风格迁移等计算机视觉任务中展现出强大能力。其核心价值在于：1）无需显式建模概率分布即可生成高质量样本；2）能够学习复杂数据分布；3）为无监督学习提供新范式。然而训练过程中常面临模式崩溃（Mode Collapse）、梯度消失等挑战，本文将系统解析 11 个关键问题及其解决方案。

目标函数设计
原始 GAN 的损失函数为：
$$\min_G \max_D V(D,G) = \mathbb{E}{x\sim p[\log(1-D(G(z)))]$$
问题在于当判别器 D 过强时，生成器 G 的梯度会消失（梯度饱和问题）。改进方案：}}[\log D(x)] + \mathbb{E}_{z\sim p_z
使用非饱和损失（NS-GAN）：将 G 的目标改为 $\max \log D(G(z))$
引入 Wasserstein 距离（WGAN）：$\min_G \max_{D\in 1-Lipschitz} \mathbb{E}[D(x)] – \mathbb{E}[D(G(z))]$
模式崩溃分析
数学表现为生成样本多样性不足，即 $p_g(x)$ 仅覆盖部分 $p_{data}(x)$。解决方案：
小批量判别（Mini-batch Discrimination）
添加多样性惩罚项：$\mathcal{L}_{div} = -\mathbb{E}[\log |G(z_1)-G(z_2)|]$
梯度惩罚实现（以 WGAN-GP 为例）
梯度惩罚项公式：
$$\lambda \mathbb{E}{\hat{x}\sim p)|_2 – 1)^2]$$
其中 $\hat{x}$ 是真实样本与生成样本的随机插值。}}}[(|\nabla_{\hat{x}} D(\hat{x

（因篇幅限制，此处仅展示 3 个问题分析，实际文章需完整展开 11 个问题）

import torch
from torch import nn, optim

# 生成器定义（2023 年 API 规范）class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super().__init__()
        self.main = nn.Sequential(nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 512),
            nn.BatchNorm1d(512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 784),  # MNIST 尺寸 28x28=784
            nn.Tanh())

    def forward(self, z):
        return self.main(z)

# 训练循环示例（带梯度裁剪）def train(epochs, batch_size=64):
    for epoch in range(epochs):
        for real_imgs, _ in dataloader:
            # 判别器训练
            optimizer_D.zero_grad()
            z = torch.randn(batch_size, latent_dim)
            fake_imgs = G(z)
            loss_D = -torch.mean(D(real_imgs)) + torch.mean(D(fake_imgs))
            loss_D.backward()
            # 梯度裁剪（阈值 0.01）torch.nn.utils.clip_grad_norm_(D.parameters(), 0.01)
            optimizer_D.step()

            # 生成器训练（每 5 步更新一次）if step % 5 == 0:
                optimizer_G.zero_grad()
                z = torch.randn(batch_size, latent_dim)
                loss_G = -torch.mean(D(G(z)))
                loss_G.backward()
                optimizer_G.step()