深入解析CGAN损失函数：从理论到PyTorch实战

1次阅读

没有评论

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

传统 GAN 在条件生成任务中常面临以下问题：

梯度消失 ：当判别器过于强大时，生成器梯度会趋近于零，导致训练停滞。这种现象在传统 GAN 的 JS 散度优化中尤为明显
模式崩溃 ：生成器倾向于生成有限种类的样本，无法覆盖全部数据分布。例如在 MNIST 生成任务中可能只产生某几个数字
条件信息缺失 ：传统 GAN 无法利用类别标签等辅助信息，导致生成过程缺乏可控性

CGAN 通过将条件变量 $y$（如类别标签）同时输入生成器和判别器，解决了上述问题：

条件信息引导生成方向，避免无意义输出
条件对抗损失提供更明确的优化信号
可控生成支持特定样本生成（如指定生成数字 ”7″）

CGAN 采用 Wasserstein 距离（Earth-Mover 距离）衡量分布差异，其条件形式定义为：

$$ W(P_r, P_g|y) = \inf_{\gamma \in \Pi(P_r, P_g)} \mathbb{E}_{(x,\hat{x}) \sim \gamma} [|x-\hat{x}||y] $$

其中 $P_r$ 为真实数据分布，$P_g$ 为生成分布，$\Pi$ 为联合分布集合。相比传统 GAN 的 JS 散度，Wasserstein 距离具有：

处处可导的特性
与生成质量的相关性更强

原始 GAN 的判别器目标：

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

CGAN 引入条件后的改进形式：

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

Wasserstein-GAN 进一步改进为：

$$ L_D = \mathbb{E}[D(x|y)] – \mathbb{E}[D(G(z|y)|y)] + \lambda \mathbb{E}[(|\nabla_{\hat{x}}D(\hat{x}|y)|_2 – 1)^2] $$

其中最后一项为梯度惩罚项（$\hat{x}$ 是真实样本和生成样本的随机插值），用于满足 Lipschitz 约束。

class ConditionalEmbedding(nn.Module):
    """将离散标签映射为连续向量"""
    def __init__(self, num_classes, latent_dim):
        super().__init__()
        self.embedding = nn.Embedding(num_classes, latent_dim)

    def forward(self, y):
        # y 形状: (batch_size,) 包含类别索引
        return self.embedding(y)  # 输出: (batch_size, latent_dim)

def compute_gradient_penalty(D, real_samples, fake_samples, conditions):
    """计算 WGAN-GP 中的梯度惩罚项"""
    # 生成随机插值样本
    alpha = torch.rand(real_samples.size(0), 1, 1, 1).to(device)
    interpolates = (alpha * real_samples + (1-alpha) * fake_samples).requires_grad_(True)

    # 计算判别器输出
    d_interpolates = D(interpolates, conditions)

    # 计算梯度
    gradients = torch.autograd.grad(
        outputs=d_interpolates,
        inputs=interpolates,
        grad_outputs=torch.ones_like(d_interpolates),
        create_graph=True,
        retain_graph=True
    )[0]

    # 梯度惩罚 (L2 范数偏离 1 的惩罚)
    gradients = gradients.view(gradients.size(0), -1)
    gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
    return gradient_penalty

class Generator(nn.Module):
    def __init__(self, latent_dim, num_classes):
        super().__init__()
        self.label_embedding = ConditionalEmbedding(num_classes, latent_dim)

        self.model = nn.Sequential(
            # 将噪声 z 和条件向量拼接后输入
            nn.Linear(2 * latent_dim, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 256),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(0.2),
            # 输出层...
        )

    def forward(self, z, labels):
        # z 形状: (batch_size, latent_dim)
        c = self.label_embedding(labels)  # (batch_size, latent_dim)
        x = torch.cat([z, c], dim=1)     # (batch_size, 2*latent_dim)
        return self.model(x)

损失曲线观察 ：
判别器损失应在零附近波动（Wasserstein 距离可正可负）
持续上升的生成器损失可能说明模式崩溃
两损失差值过大需调整学习率
超参数经验值 ：
学习率：通常设为 2e-4（Adam 优化器）
梯度惩罚系数 $\lambda$：推荐 10
判别器更新次数：通常比生成器多 3 - 5 次

# 混合精度训练示例
scaler = torch.cuda.amp.GradScaler()

with torch.cuda.amp.autocast():
    fake_images = generator(z, labels)
    d_loss = compute_d_loss(real_images, fake_images, labels)

scaler.scale(d_loss).backward()
scaler.step(optimizer_D)
scaler.update()