GAN生成对抗网络入门实战：从理论到13.2版本核心实现

1次阅读

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

刚接触 GAN 时，我发现两个最让人崩溃的问题：

模式崩溃（Mode Collapse）：生成器总是输出相似的图片，比如手写数字生成时只会画 ”7″。这是因为判别器被局部最优解困住，生成器发现反复生成同一类样本就能骗过判别器。
训练不稳定 ：经常遇到梯度消失或爆炸，表现为：
生成器 loss 降为 0 但生成垃圾图片
判别器准确率过早达到 100%
训练过程中生成质量剧烈波动

通过对比早期 GAN，13.2 版本主要优化在：

Wasserstein 距离替代 JS 散度
原始 GAN 的损失函数：$L_D = -\mathbb{E}[\log D(x)] – \mathbb{E}[\log(1-D(G(z)))]$
改用 Wasserstein 距离：$W(P_r, P_g) = \sup_{|f|_L \leq 1} \mathbb{E}[f(x)] – \mathbb{E}[f(G(z))]$
优势：即使两个分布没有重叠也能计算距离
梯度惩罚（Gradient Penalty）
原始 WGAN 需要权重裁剪导致容量下降
13.2 版本改用：$GP = \lambda \mathbb{E}[(|\nabla D(\hat{x})|_2 – 1)^2]$
其中 $\hat{x}$ 是真实样本和生成样本的随机插值
自适应学习率调度
判别器和生成器使用不同的学习率衰减策略
引入 warm-up 阶段避免早期震荡

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.LeakyReLU(0.2),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2),
            nn.Linear(1024, 784),  # MNIST 尺寸
            nn.Tanh())

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

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.main = nn.Sequential(nn.Linear(784, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1)  # 去掉 sigmoid！)

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

梯度惩罚实现：

def compute_gradient_penalty(D, real_samples, fake_samples):
    alpha = torch.rand(real_samples.size(0), 1)
    interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True)
    d_interpolates = D(interpolates)
    gradients = torch.autograd.grad(
        outputs=d_interpolates,
        inputs=interpolates,
        grad_outputs=torch.ones_like(d_interpolates),
        create_graph=True,
        retain_graph=True
    )[0]
    return ((gradients.norm(2, dim=1) - 1) ** 2).mean()

训练循环核心：

for epoch in range(epochs):
    for i, (real_imgs, _) in enumerate(dataloader):

        # 训练判别器（5 次迭代才训练 1 次生成器）if i % 5 == 0:
            optimizer_D.zero_grad()

            # 真实样本损失
            real_validity = D(real_imgs)
            d_loss_real = -torch.mean(real_validity)

            # 生成样本损失
            z = torch.randn(batch_size, latent_dim)
            fake_imgs = G(z).detach()
            fake_validity = D(fake_imgs)
            d_loss_fake = torch.mean(fake_validity)

            # 梯度惩罚
            gp = compute_gradient_penalty(D, real_imgs.data, fake_imgs.data)
            d_loss = d_loss_real + d_loss_fake + lambda_gp * gp

            d_loss.backward()
            optimizer_D.step()

        # 训练生成器
        optimizer_G.zero_grad()
        z = torch.randn(batch_size, latent_dim)
        gen_imgs = G(z)
        g_loss = -torch.mean(D(gen_imgs))
        g_loss.backward()
        optimizer_G.step()