深入解析GAN架构：从核心组件到实战应用

1次阅读

没有评论

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

生成对抗网络（GAN）自 2014 年由 Ian Goodfellow 提出以来，迅速成为深度学习领域最具影响力的架构之一。GAN 在图像生成、风格迁移、数据增强等任务中展现出惊人的能力，但其训练过程也以 ” 不稳定 ” 著称。

常见的痛点包括：

模式崩溃（Mode Collapse）：生成器只学会生成少数几种样本，缺乏多样性
训练不稳定：判别器或生成器一方过于强大，导致另一方无法继续学习
梯度消失：在训练早期就可能出现的致命问题

这些挑战使得许多开发者对 GAN 望而却步，但理解了其核心原理后，这些问题都可以被有效缓解。

GAN 的核心思想是让两个神经网络——生成器（Generator）和判别器（Discriminator）在对抗中共同进步。

接收随机噪声向量作为输入（通常来自正态分布）
通过多层神经网络逐步将噪声 ” 塑造 ” 成目标数据分布
目标是产生足以欺骗判别器的 ” 假 ” 样本

接收真实样本和生成样本作为输入
输出一个概率值（0 到 1 之间），表示输入样本来自真实分布的可能性
目标是准确区分真实样本和生成样本

两者的关系可以用 minimax 游戏来描述：

min_G max_D V(D,G) = E_{x~p_data(x)}[logD(x)] + E_{z~p_z(z)}[log(1-D(G(z)))]

在实际训练中，我们交替更新生成器和判别器：

固定生成器，训练判别器识别真假样本
固定判别器，训练生成器产生更逼真的样本

下面是一个基础的 DCGAN（Deep Convolutional GAN）实现，用于生成 MNIST 手写数字：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 数据预处理
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_set = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_set, batch_size=64, shuffle=True)

# 生成器定义
class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.main = nn.Sequential(
            # 输入是 100 维的噪声
            nn.Linear(100, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 784),
            nn.Tanh()  # 输出在 - 1 到 1 之间)

    def forward(self, x):
        return self.main(x).view(-1, 1, 28, 28)

# 判别器定义
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.main = nn.Sequential(nn.Linear(784, 512),
            nn.LeakyReLU(0.2),
            nn.Dropout(0.3),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2),
            nn.Dropout(0.3),
            nn.Linear(256, 1),
            nn.Sigmoid())

    def forward(self, x):
        x = x.view(-1, 784)
        return self.main(x)

# 初始化模型
G = Generator()
D = Discriminator()

# 损失函数和优化器
criterion = nn.BCELoss()
G_optimizer = optim.Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999))
D_optimizer = optim.Adam(D.parameters(), lr=0.0002, betas=(0.5, 0.999))

# 训练循环
for epoch in range(50):
    for real_images, _ in train_loader:
        batch_size = real_images.size(0)

        # 训练判别器
        D.zero_grad()

        # 真实样本
        real_labels = torch.ones(batch_size, 1)
        real_output = D(real_images)
        D_loss_real = criterion(real_output, real_labels)

        # 生成样本
        noise = torch.randn(batch_size, 100)
        fake_images = G(noise)
        fake_labels = torch.zeros(batch_size, 1)
        fake_output = D(fake_images.detach())
        D_loss_fake = criterion(fake_output, fake_labels)

        D_loss = D_loss_real + D_loss_fake
        D_loss.backward()
        D_optimizer.step()

        # 训练生成器
        G.zero_grad()
        output = D(fake_images)
        G_loss = criterion(output, real_labels)  # 希望判别器将生成样本识别为真实
        G_loss.backward()
        G_optimizer.step()

通过实践，我总结了以下提高 GAN 训练稳定性的技巧：