0
0

9个主流GAN损失函数的数学原理和Pytorch代码实现：从经典模型到现代变体

生成对抗网络(GANs)的训练效果很大程度上取决于其损失函数的选择。本研究首先介绍经典GAN损失函数的理论基础，随后使用PyTorch实现包括原始GAN、最小二乘GAN(LS-GAN)、Wasserstein GAN(WGAN)及带梯度惩罚的WGAN(WGAN-GP)在内的多种损失函数。
生成对抗网络(GANs)的工作原理堪比一场精妙的艺术创作过程——生成器(Generator)扮演创作者角色，不断生成作品；判别器(Discriminator)则如同严苛的评论家，持续提供改进建议。这种对抗学习机制促使两个网络在竞争中共同进步。判别器向生成器提供反馈的方式——即损失函数的设计——对整个网络的学习表现有着决定性影响。

GAN的基本原理与经典损失函数

1、原始GAN

Goodfellow等人于2014年提出的原始GAN采用极小极大博弈(Minimax Game)框架，其损失函数可表述为：

其中：

  • D(x)表示判别器对输入x判定为真实样本的概率
  • G(z)表示生成器将随机噪声z转换为合成图像的函数
  • p_{data}(x)表示真实数据分布
  • p_z(z)表示噪声先验分布，通常为标准正态分布

原始GAN在理论上试图最小化生成分布与真实分布之间的Jensen-Shannon散度(JS散度)，但在实际训练中存在梯度消失、模式崩溃和训练不稳定等问题。这些局限性促使研究者开发了多种改进的损失函数。

PyTorch实现：

  1.  import torch
  2. import torch.nn as nn
  4. # 原始GAN损失函数实现
  5. class OriginalGANLoss:
  6.     def __init__(self, device):
  7.         self.device = device
  8.         self.criterion = nn.BCELoss()
  9.         
  10.     def discriminator_loss(self, real_output, fake_output):
  11.         # 真实样本的目标标签为1.0
  12.         real_labels = torch.ones_like(real_output, device=self.device)
  13.         # 生成样本的目标标签为0.0
  14.         fake_labels = torch.zeros_like(fake_output, device=self.device)
  15.         
  16.         # 计算判别器对真实样本的损失
  17.         real_loss = self.criterion(real_output, real_labels)
  18.         # 计算判别器对生成样本的损失
  19.         fake_loss = self.criterion(fake_output, fake_labels)
  20.         
  21.         # 总损失为两部分之和
  22.         d_loss = real_loss + fake_loss
  23.         return d_loss
  24.     
  25.     def generator_loss(self, fake_output):
  26.         # 生成器希望判别器将生成样本判断为真实样本
  27.         target_labels = torch.ones_like(fake_output, device=self.device)
  28.         g_loss = self.criterion(fake_output, target_labels)
  29.          return g_loss

2、非饱和损失函数(Non-Saturating Loss)

为解决原始GAN中生成器梯度消失问题，Goodfellow提出了非饱和损失，将生成器的目标函数修改为：

这种修改保持了相同的最优解，但提供了更强的梯度信号，特别是在训练初期生成样本质量较差时，有效改善了学习效率。非饱和损失通过直接最大化判别器对生成样本的预测概率，而不是最小化判别器正确分类的概率，从而避免了在生成器表现不佳时梯度趋近于零的问题。

PyTorch实现：

  1.  class NonSaturatingGANLoss:
  2.     def __init__(self, device):
  3.         self.device = device
  4.         self.criterion = nn.BCELoss()
  5.         
  6.     def discriminator_loss(self, real_output, fake_output):
  7.         # 与原始GAN相同
  8.         real_labels = torch.ones_like(real_output, device=self.device)
  9.         fake_labels = torch.zeros_like(fake_output, device=self.device)
  10.         
  11.         real_loss = self.criterion(real_output, real_labels)
  12.         fake_loss = self.criterion(fake_output, fake_labels)
  13.         
  14.         d_loss = real_loss + fake_loss
  15.         return d_loss
  16.     
  17.     def generator_loss(self, fake_output):
  18.         # 非饱和损失：直接最大化log(D(G(z)))
  19.         target_labels = torch.ones_like(fake_output, device=self.device)
  20.         # 注意这里使用的是相同的BCE损失，但目标是让D将G(z)判断为真
  21.         g_loss = self.criterion(fake_output, target_labels)
  22.          return g_loss

GAN变体实现与原理分析

3、最小二乘GAN(LS-GAN)

LS-GAN通过用最小二乘损失替代标准GAN中的二元交叉熵损失，有效改善了训练过程：

这一修改使得模型在训练过程中梯度变化更为平滑，显著降低了训练不稳定性。LS-GAN的主要优势在于能够有效减轻模式崩溃问题（即生成器仅产生有限类型样本的现象），同时促进学习过程的连续性与稳定性，使模型能够更加渐进地学习数据分布特征。理论上，LS-GAN试图最小化Pearson \chi^2 散度，这对于分布重叠较少的情况提供了更好的训练信号。

PyTorch实现：

  1.  class LSGANLoss:
  2.     def __init__(self, device):
  3.         self.device = device
  4.         # LS-GAN使用MSE损失而非BCE损失
  5.         self.criterion = nn.MSELoss()
  6.         
  7.     def discriminator_loss(self, real_output, fake_output):
  8.         # 真实样本的目标值为1.0
  9.         real_labels = torch.ones_like(real_output, device=self.device)
  10.         # 生成样本的目标值为0.0
  11.         fake_labels = torch.zeros_like(fake_output, device=self.device)
  12.         
  13.         # 计算真实样本的MSE损失
  14.         real_loss = self.criterion(real_output, real_labels)
  15.         # 计算生成样本的MSE损失
  16.         fake_loss = self.criterion(fake_output, fake_labels)
  17.         
  18.         d_loss = real_loss + fake_loss
  19.         return d_loss
  20.     
  21.     def generator_loss(self, fake_output):
  22.         # 生成器希望生成的样本被判别为真实样本
  23.         target_labels = torch.ones_like(fake_output, device=self.device)
  24.         g_loss = self.criterion(fake_output, target_labels)
  25.          return g_loss

4、Wasserstein GAN(WGAN)

WGAN通过引入Wasserstein距离（也称为地球移动者距离）作为分布差异度量，从根本上改变了GAN的训练机制：

其中\mathcal{D}是所有满足1-Lipschitz约束的函数集合。与传统GAN关注样本真假二分类不同，WGAN评估的是生成分布与真实分布之间的距离，这一方法提供了更为连续且有意义的梯度信息。WGAN能够显著改善梯度传播问题，有效防止判别器过度主导训练过程，同时大幅减轻模式崩溃现象，提高生成样本的多样性。

原始WGAN通过权重裁剪(weight clipping)实现Lipschitz约束，具体做法是将判别器参数限制在某个固定范围内，如[-c, c]，但这种方法可能会限制网络容量并导致病态行为。

PyTorch实现：

  1.  class WGANLoss:
  2.     def __init__(self, device, clip_value=0.01):
  3.         self.device = device
  4.         self.clip_value = clip_value
  5.         
  6.     def discriminator_loss(self, real_output, fake_output):
  7.         # WGAN的判别器（称为critic）直接最大化真实样本和生成样本输出的差值
  8.         # 注意这里没有使用sigmoid激活
  9.         d_loss = -torch.mean(real_output) + torch.mean(fake_output)
  10.         return d_loss
  11.     
  12.     def generator_loss(self, fake_output):
  13.         # 生成器希望最大化critic对生成样本的评分
  14.         g_loss = -torch.mean(fake_output)
  15.         return g_loss
  16.     
  17.     def weight_clipping(self, critic):
  18.         # 权重裁剪，限制critic参数范围
  19.         for p in critic.parameters():
  20.              p.data.clamp_(-self.clip_value, self.clip_value)

5、带梯度惩罚的WGAN(WGAN-GP)

WGAN-GP是对WGAN的进一步优化，通过引入梯度惩罚项来满足Lipschitz连续性约束：

其中\hat{x}是真实样本和生成样本之间的随机插值点。这一改进避免了原始WGAN中权重裁剪可能带来的容量限制和训练不稳定问题。梯度惩罚使模型训练过程更加稳定，同时减少了生成图像中的伪影，提高了最终生成结果的质量与真实度。WGAN-GP已成为许多高质量图像生成任务的首选损失函数。

PyTorch实现：

  1.  class WGANGP:
  2.     def __init__(self, device, lambda_gp=10):
  3.         self.device = device
  4.         self.lambda_gp = lambda_gp
  5.         
  6.     def discriminator_loss(self, real_output, fake_output, real_samples, fake_samples, discriminator):
  7.         # 基本的Wasserstein距离
  8.         d_loss = -torch.mean(real_output) + torch.mean(fake_output)
  9.         
  10.         # 计算梯度惩罚
  11.         # 在真实和生成样本之间随机插值
  12.         alpha = torch.rand(real_samples.size(0), 1, 1, 1, device=self.device)
  13.         interpolates = alpha * real_samples + (1 - alpha) * fake_samples
  14.         interpolates.requires_grad_(True)
  15.         
  16.         # 计算判别器对插值样本的输出
  17.         d_interpolates = discriminator(interpolates)
  18.         
  19.         # 计算梯度
  20.         fake_outputs = torch.ones_like(d_interpolates, device=self.device, requires_grad=False)
  21.         gradients = torch.autograd.grad(
  22.             outputs=d_interpolates,
  23.             inputs=interpolates,
  24.             grad_outputs=fake_outputs,
  25.             create_graph=True,
  26.             retain_graph=True,
  27.             only_inputs=True
  28.         )[0]
  29.         
  30.         # 计算梯度L2范数
  31.         gradients = gradients.view(gradients.size(0), -1)
  32.         gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
  33.         
  34.         # 添加梯度惩罚项
  35.         d_loss = d_loss + self.lambda_gp * gradient_penalty
  36.         
  37.         return d_loss
  38.     
  39.     def generator_loss(self, fake_output):
  40.         # 与WGAN相同
  41.         g_loss = -torch.mean(fake_output)
  42.          return g_loss

6、条件生成对抗网络(CGAN)

CGAN通过在生成器和判别器中引入条件信息y（如类别标签），实现对生成过程的控制：

CGAN能够生成特定类别的样本，大大增强了模型的实用性，特别是在医学影像等需要精确控制生成内容的应用场景中。通过条件控制，CGAN可以引导生成过程，使得生成结果满足特定的语义或结构要求，为个性化内容生成提供了可靠技术支持。

PyTorch实现：

  1.  class CGANLoss:
  2.     def __init__(self, device):
  3.         self.device = device
  4.         self.criterion = nn.BCELoss()
  5.         
  6.     def discriminator_loss(self, real_output, fake_output):
  7.         # 条件GAN的判别器损失与原始GAN相似，只是输入增加了条件信息
  8.         real_labels = torch.ones_like(real_output, device=self.device)
  9.         fake_labels = torch.zeros_like(fake_output, device=self.device)
  10.         
  11.         real_loss = self.criterion(real_output, real_labels)
  12.         fake_loss = self.criterion(fake_output, fake_labels)
  13.         
  14.         d_loss = real_loss + fake_loss
  15.         return d_loss
  16.     
  17.     def generator_loss(self, fake_output):
  18.         # 与原始GAN相似
  19.         target_labels = torch.ones_like(fake_output, device=self.device)
  20.         g_loss = self.criterion(fake_output, target_labels)
  21.         return g_loss
  23. # CGAN的网络结构示例
  24. class ConditionalGenerator(nn.Module):
  25.     def __init__(self, latent_dim, n_classes, img_shape):
  26.         super(ConditionalGenerator, self).__init__()
  27.         self.img_shape = img_shape
  28.         self.label_emb = nn.Embedding(n_classes, n_classes)
  29.         
  30.         self.model = nn.Sequential(
  31.             # 输入是噪声向量与条件拼接后的向量
  32.             nn.Linear(latent_dim + n_classes, 128),
  33.             nn.LeakyReLU(0.2, inplace=True),
  34.             nn.Linear(128, 256),
  35.             nn.BatchNorm1d(256),
  36.             nn.LeakyReLU(0.2, inplace=True),
  37.             nn.Linear(256, 512),
  38.             nn.BatchNorm1d(512),
  39.             nn.LeakyReLU(0.2, inplace=True),
  40.             nn.Linear(512, int(np.prod(img_shape))),
  41.             nn.Tanh()
  42.         )
  43.     
  44.     def forward(self, z, labels):
  45.         # 条件嵌入
  46.         c = self.label_emb(labels)
  47.         # 拼接噪声和条件
  48.         x = torch.cat([z, c], 1)
  49.         # 生成图像
  50.         img = self.model(x)
  51.         img = img.view(img.size(0), *self.img_shape)
  52.          return img

7、信息最大化GAN(InfoGAN)

InfoGAN在无监督学习框架下实现了对生成样本特定属性的控制，其核心思想是最大化潜在编码c与生成样本G(z,c)之间的互信息：

其中Q是一个辅助网络，用于近似后验分布P(c|x)，而I(c;G(z,c))表示互信息。InfoGAN能够在无监督的情况下学习数据的解耦表示，对于医学图像分析中的特征提取和异常检测具有潜在价值。

PyTorch实现：

  1.  class InfoGANLoss:
  2.     def __init__(self, device, lambda_info=1.0):
  3.         self.device = device
  4.         self.criterion = nn.BCELoss()
  5.         self.lambda_info = lambda_info
  6.         # 对于离散潜变量使用交叉熵损失
  7.         self.discrete_criterion = nn.CrossEntropyLoss()
  8.         # 对于连续潜变量使用高斯分布负对数似然
  9.         self.continuous_criterion = nn.MSELoss()
  10.         
  11.     def discriminator_loss(self, real_output, fake_output):
  12.         # 判别器损失与原始GAN相同
  13.         real_labels = torch.ones_like(real_output, device=self.device)
  14.         fake_labels = torch.zeros_like(fake_output, device=self.device)
  15.         
  16.         real_loss = self.criterion(real_output, real_labels)
  17.         fake_loss = self.criterion(fake_output, fake_labels)
  18.         
  19.         d_loss = real_loss + fake_loss
  20.         return d_loss
  21.     
  22.     def generator_info_loss(self, fake_output, q_discrete, q_continuous, c_discrete, c_continuous):
  23.         # 生成器损失部分（欺骗判别器）
  24.         target_labels = torch.ones_like(fake_output, device=self.device)
  25.         g_loss = self.criterion(fake_output, target_labels)
  26.         
  27.         # 互信息损失部分
  28.         # 离散潜变量的互信息损失
  29.         info_disc_loss = self.discrete_criterion(q_discrete, c_discrete)
  30.         # 连续潜变量的互信息损失
  31.         info_cont_loss = self.continuous_criterion(q_continuous, c_continuous)
  32.         
  33.         # 总损失
  34.         total_loss = g_loss + self.lambda_info * (info_disc_loss + info_cont_loss)
  35.         
  36.          return total_loss, info_disc_loss, info_cont_loss

8、能量基础GAN(EBGAN)

EBGAN将判别器视为能量函数，而非传统的概率函数，其损失函数为：

其中[·]^+表示\max(0,·)，m是边界参数。EBGAN通过能量视角重新诠释GAN训练过程，为模型设计提供了新的思路，尤其适合处理具有复杂分布的医学数据。EBGAN的判别器不再输出概率值，而是输出能量分数，真实样本的能量应当低于生成样本。

PyTorch实现：

  1.  class EBGANLoss:
  2.     def __init__(self, device, margin=10.0):
  3.         self.device = device
  4.         self.margin = margin
  5.         
  6.     def discriminator_loss(self, real_energy, fake_energy):
  7.         # 判别器的目标是降低真实样本的能量，提高生成样本的能量（直到边界值）
  8.         # 对生成样本的损失使用hinge loss
  9.         hinge_loss = torch.mean(torch.clamp(self.margin - fake_energy, min=0))
  10.         # 总损失
  11.         d_loss = torch.mean(real_energy) + hinge_loss
  12.         return d_loss
  13.     
  14.     def generator_loss(self, fake_energy):
  15.         # 生成器的目标是降低生成样本的能量
  16.         g_loss = torch.mean(fake_energy)
  17.          return g_loss

9、f-GAN

f-GAN是一种基于f-散度的GAN框架，可以统一多种GAN变体：

其中f^*是凸函数f的Fenchel共轭。通过选择不同的f函数，f-GAN可以实现对不同散度的优化，如KL散度、JS散度、Hellinger距离等，为特定应用场景提供了更灵活的选择。f-GAN为GAN提供了一个统一的理论框架，使研究者能够根据具体任务需求设计最适合的散度度量。

PyTorch实现：

  1.  class FGANLoss:
  2.     def __init__(self, device, divergence_type='kl'):
  3.         self.device = device
  4.         self.divergence_type = divergence_type
  5.         
  6.     def activation_function(self, x):
  7.         # 不同散度对应的激活函数
  8.         if self.divergence_type == 'kl':  # KL散度
  9.             return x
  10.         elif self.divergence_type == 'js':  # JS散度
  11.             return torch.log(1 + torch.exp(x))
  12.         elif self.divergence_type == 'hellinger':  # Hellinger距离
  13.             return 1 - torch.exp(-x)
  14.         elif self.divergence_type == 'total_variation':  # 总变差距离
  15.             return 0.5 * torch.tanh(x)
  16.         else:
  17.             return x  # 默认为KL散度
  18.     
  19.     def conjugate_function(self, x):
  20.         # 不同散度的Fenchel共轭
  21.         if self.divergence_type == 'kl':
  22.             return torch.exp(x - 1)
  23.         elif self.divergence_type == 'js':
  24.             return -torch.log(2 - torch.exp(x))
  25.         elif self.divergence_type == 'hellinger':
  26.             return x / (1 - x)
  27.         elif self.divergence_type == 'total_variation':
  28.             return x
  29.         else:
  30.             return torch.exp(x - 1)  # 默认为KL散度
  31.     
  32.     def discriminator_loss(self, real_output, fake_output):
  33.         # 判别器损失
  34.         # 注意：在f-GAN中，通常D的输出需要经过激活函数处理
  35.         activated_real = self.activation_function(real_output)
  36.         d_loss = -torch.mean(activated_real) + torch.mean(self.conjugate_function(fake_output))
  37.         return d_loss
  38.     
  39.     def generator_loss(self, fake_output):
  40.         # 生成器损失
  41.         activated_fake = self.activation_function(fake_output)
  42.         g_loss = -torch.mean(activated_fake)
  43.          return g_loss

总结

本文通过详细分析GAN的经典损失函数及其多种变体，揭示了不同类型损失函数各自的优势：LS-GAN训练稳定性好，WGAN-GP生成图像清晰度高，而条件类GAN如CGAN则在可控性方面表现突出。

这介绍代码对于相关领域的GAN应用具有重要参考价值。未来研究可进一步探索损失函数组合优化策略，以及针对特定图像模态的自适应损失函数设计。

标签： 深度学习 GAN 损失函数
登录后发布评论

“9个主流GAN损失函数的数学原理和Pytorch代码实现：从经典模型到现代变体”的评论:

还没有评论
关于作者
...
Deephub
更多文章请关注公众号：Deephub-IMBA
相关阅读

FlashTokenizer: 基于C++的高性能分词引擎，速度可以提升8-15倍

计算加速技术比较分析：GPU、FPGA、ASIC、TPU与NPU的技术特性、应用场景及产业生态

标签噪声下的模型评估：如何准确评估AI模型的真实性能，提高模型性能测量的可信度

VideoMind：Chain-of-LoRA突破时间盲区让AI真正看懂长视频

9个主流GAN损失函数的数学原理和Pytorch代码实现：从经典模型到现代变体

DAPO: 面向开源大语言模型的解耦裁剪与动态采样策略优化系统

多模态AI核心技术：CLIP与SigLIP技术原理与应用进展