CGAN损失函数实战：解决生成对抗网络中的模式崩溃问题

1次阅读

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

生成对抗网络（GAN）在图像生成等领域取得了显著成果，但训练过程中常常会遇到模式崩溃（Mode Collapse）问题。模式崩溃指的是生成器倾向于生成有限的几种样本，而无法覆盖整个数据分布。这不仅导致生成的样本多样性不足，还严重影响了模型的实用价值。

模式崩溃的主要原因在于生成器和判别器的对抗训练过程中，生成器可能会找到一些能够欺骗判别器的特定样本模式，并不断强化这些模式，而忽略其他可能的样本分布。这种现象在传统 GAN 中尤为常见，因为其损失函数设计并没有显式地考虑如何引导生成器探索更广泛的样本空间。

传统 GAN 的损失函数由两部分组成：生成器损失和判别器损失。生成器的目标是最大化判别器对生成样本的错误分类概率，而判别器的目标是正确区分真实样本和生成样本。这种对抗性训练虽然有效，但缺乏对生成样本多样性的显式约束。

相比之下，条件生成对抗网络（CGAN）通过引入条件信息（如类别标签或其他辅助信息）来引导生成过程。CGAN 的损失函数在传统 GAN 的基础上增加了条件变量，使得生成器和判别器不仅需要学习样本的分布，还需要学习样本与条件变量之间的关系。这种设计能够有效缓解模式崩溃问题，因为生成器必须在给定不同条件时生成不同的样本。

CGAN 的损失函数可以表示为：

[L_{CGAN} = \mathbb{E}{x,y\sim p}(x,y)}[\log D(x|y)] + \mathbb{E{z\sim p_z(z), y\sim p[\log (1 – D(G(z|y)|y))] ]}(y)

其中，(D(x|y) ) 表示判别器在给定条件 (y) 下对样本 (x) 的判别概率，(G(z|y) ) 表示生成器在给定条件 (y) 和噪声 (z) 下生成的样本。

通过引入条件变量 (y)，CGAN 的损失函数迫使生成器在生成样本时必须考虑条件信息，从而避免生成器陷入单一模式的陷阱。判别器也需要在判别时考虑条件信息，确保生成样本与条件的一致性。

以下是一个简单的 CGAN 实现代码，重点展示了损失函数的计算部分：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义生成器和判别器
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim, condition_dim):
        super(Generator, self).__init__()
        self.fc = nn.Sequential(nn.Linear(input_dim + condition_dim, 256),
            nn.ReLU(),
            nn.Linear(256, output_dim),
            nn.Tanh())

    def forward(self, z, y):
        zy = torch.cat([z, y], dim=1)
        return self.fc(zy)

class Discriminator(nn.Module):
    def __init__(self, input_dim, condition_dim):
        super(Discriminator, self).__init__()
        self.fc = nn.Sequential(nn.Linear(input_dim + condition_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1),
            nn.Sigmoid())

    def forward(self, x, y):
        xy = torch.cat([x, y], dim=1)
        return self.fc(xy)

# 初始化模型
input_dim = 100
output_dim = 784  # 假设生成 28x28 的图像
condition_dim = 10  # 假设有 10 个类别

G = Generator(input_dim, output_dim, condition_dim)
D = Discriminator(output_dim, condition_dim)

# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer_G = optim.Adam(G.parameters(), lr=0.0002)
optimizer_D = optim.Adam(D.parameters(), lr=0.0002)

# 训练循环
for epoch in range(num_epochs):
    for i, (real_images, labels) in enumerate(dataloader):
        # 转换为 one-hot 编码
        y = torch.zeros(labels.size(0), condition_dim).scatter_(1, labels.unsqueeze(1), 1)

        # 训练判别器
        optimizer_D.zero_grad()

        # 真实样本
        real_outputs = D(real_images, y)
        real_loss = criterion(real_outputs, torch.ones_like(real_outputs))

        # 生成样本
        z = torch.randn(real_images.size(0), input_dim)
        fake_images = G(z, y)
        fake_outputs = D(fake_images.detach(), y)
        fake_loss = criterion(fake_outputs, torch.zeros_like(fake_outputs))

        d_loss = real_loss + fake_loss
        d_loss.backward()
        optimizer_D.step()

        # 训练生成器
        optimizer_G.zero_grad()

        fake_outputs = D(fake_images, y)
        g_loss = criterion(fake_outputs, torch.ones_like(fake_outputs))
        g_loss.backward()
        optimizer_G.step()

CGAN 的训练稳定性受多个超参数影响：