生成对抗网络（GAN）核心原理与实战：从理论到图像生成应用

1次阅读

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

生成对抗网络（GAN）由 Ian Goodfellow 在 2014 年提出，迅速成为 AI 领域的热门技术。GAN 的核心思想是通过两个神经网络的对抗训练，生成高度逼真的数据。然而，尽管 GAN 潜力巨大，许多开发者在实际应用中常遇到训练不稳定、模式崩溃等问题。

训练不稳定 ：生成器和判别器的动态平衡难以维持，常导致一方压倒另一方。
模式崩溃 ：生成器倾向于生成有限的几种样本，缺乏多样性。
评估困难 ：缺乏统一的量化指标来评估生成质量。

GAN 由生成器（G）和判别器（D）组成，两者通过对抗过程共同提升。生成器试图生成逼真的假数据，而判别器则尝试区分真假数据。

原始 GAN 的损失函数为：

[\min_G \max_D V(D, G) = \mathbb{E}{x \sim p[\log (1 – D(G(z)))] ]}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)

生成器目标 ：最小化判别器对生成样本的判别能力。
判别器目标 ：最大化对真实和生成样本的区分能力。

WGAN：使用 Wasserstein 距离替代原始 GAN 的 JS 散度，缓解梯度消失问题。
WGAN-GP：通过梯度惩罚（Gradient Penalty）进一步稳定训练。
SNGAN：引入谱归一化（Spectral Normalization）提升判别器的鲁棒性。

以下是一个基于 PyTorch 的 DCGAN 实现，用于生成手写数字图像（MNIST 数据集）。

import torch
from torchvision import datasets, transforms

transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

dataloader = torch.utils.data.DataLoader(dataset, batch_size=64, shuffle=True)

class Generator(nn.Module):
    def __init__(self, latent_dim):
        super(Generator, self).__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),
            nn.Tanh())

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

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__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),
            nn.Sigmoid())

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

# 初始化网络与优化器
G = Generator(latent_dim=100).to(device)
D = Discriminator().to(device)
optimizer_G = torch.optim.Adam(G.parameters(), lr=0.0002)
optimizer_D = torch.optim.Adam(D.parameters(), lr=0.0002)

for epoch in range(epochs):
    for i, (real_imgs, _) in enumerate(dataloader):
        real_imgs = real_imgs.view(-1, 784).to(device)

        # 训练判别器
        z = torch.randn(real_imgs.size(0), 100).to(device)
        fake_imgs = G(z)

        real_loss = torch.log(D(real_imgs)).mean()
        fake_loss = torch.log(1 - D(fake_imgs.detach())).mean()
        d_loss = -(real_loss + fake_loss)

        optimizer_D.zero_grad()
        d_loss.backward()
        optimizer_D.step()

        # 训练生成器
        fake_loss = torch.log(1 - D(fake_imgs)).mean()
        g_loss = -fake_loss

        optimizer_G.zero_grad()
        g_loss.backward()
        optimizer_G.step()