从对抗博弈到图像生成：深入解析2014年Goodfellow提出的GAN原理与实现

1次阅读

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

2014 年，Ian Goodfellow 等人提出了生成对抗网络（GAN），一种通过对抗训练来生成数据的全新框架。GAN 的核心思想是让两个神经网络——生成器（Generator）和判别器（Discriminator）——互相博弈，最终达到生成逼真数据的目的。

GAN 由两个主要部分组成：

生成器（G）：负责从随机噪声中生成数据，试图“欺骗”判别器。
判别器（D）：负责判断输入数据是真实的还是生成器生成的，试图“识破”生成器的欺骗。

GAN 的训练过程可以看作是一个极小极大博弈（minimax game）。生成器试图最小化判别器的正确率，而判别器试图最大化自己的正确率。这种对抗训练使得生成器逐渐生成更逼真的数据，判别器也逐渐变得更难被欺骗。

与传统的生成模型（如变分自编码器 VAE）相比，GAN 具有以下优势：

无需显式建模概率分布：GAN 通过对抗训练直接学习数据的分布，而不需要像 VAE 那样显式地建模概率分布。
生成样本质量更高：GAN 生成的样本通常更清晰、更逼真，尤其是在图像生成任务中。

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)

其中：

(p_{data}(x) ) 是真实数据的分布。
(p_z(z) ) 是随机噪声的分布。
(D(x) ) 是判别器对真实数据的输出。
(G(z) ) 是生成器从噪声生成的数据。

生成器和判别器的损失函数分别为：

生成器损失：(\mathcal{L}G = \mathbb{E}[\log (1 – D(G(z)))] )
判别器损失：(\mathcal{L}D = -\mathbb{E}[\log (1 – D(G(z)))] )}(x)}[\log D(x)] – \mathbb{E}_{z \sim p_z(z)

原始 GAN 的损失函数等价于优化生成数据分布与真实数据分布之间的 Jensen-Shannon（JS）散度。然而，当两者分布没有重叠时，JS 散度会饱和，导致梯度消失，使得训练变得困难。

以下是一个简单的 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

# 定义生成器
class Generator(nn.Module):
    def __init__(self, latent_dim, img_shape):
        super(Generator, self).__init__()
        self.model = 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, img_shape),
            nn.Tanh())

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

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

    def forward(self, img):
        return self.model(img)

# 训练过程
latent_dim = 100
img_shape = 28 * 28
batch_size = 64
epochs = 100

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

# 定义优化器
optimizer_G = optim.Adam(G.parameters(), lr=0.0002)
optimizer_D = optim.Adam(D.parameters(), lr=0.0002)

# 损失函数
criterion = nn.BCELoss()

# 训练循环
for epoch in range(epochs):
    for i, (imgs, _) in enumerate(dataloader):
        # 训练判别器
        optimizer_D.zero_grad()
        real_imgs = imgs.view(imgs.size(0), -1)
        real_labels = torch.ones(imgs.size(0), 1)
        fake_labels = torch.zeros(imgs.size(0), 1)

        # 真实数据的损失
        real_loss = criterion(D(real_imgs), real_labels)

        # 生成假数据
        z = torch.randn(imgs.size(0), latent_dim)
        fake_imgs = G(z)

        # 假数据的损失
        fake_loss = criterion(D(fake_imgs.detach()), fake_labels)

        # 总损失
        d_loss = real_loss + fake_loss
        d_loss.backward()
        optimizer_D.step()

        # 训练生成器
        optimizer_G.zero_grad()
        z = torch.randn(imgs.size(0), latent_dim)
        fake_imgs = G(z)

        # 生成器的损失
        g_loss = criterion(D(fake_imgs), real_labels)
        g_loss.backward()
        optimizer_G.step()