GAN损失函数详解：原理、变体与PyTorch实现

DatapiTHU · 2025 年4 月 24 日 05:26

详解GANs中9种主流损失函数，包括原始GAN、WGAN-GP等，并提供PyTorch代码实现。探索不同损失函数对GAN训练的影响。

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

原文作者：数据派THU

原文链接： http://mp.weixin.qq.com/s?__biz=MzI1MjQ2OTQ3Ng==&mid=2247656020&idx=2&sn=2f5ca8c60cec3d72d70a1d53b1dc25cc&

冷月清谈：

本文深入探讨了生成对抗网络（GAN）中9种主流损失函数的数学原理和PyTorch代码实现，对比了原始GAN、LS-GAN、WGAN、WGAN-GP、CGAN、InfoGAN、EBGAN和f-GAN等模型的优缺点。文章旨在帮助读者理解不同损失函数对GAN训练的影响，例如LS-GAN的训练稳定性，WGAN-GP的图像清晰度，以及条件GAN的可控性。此外，文章还提供了相应的PyTorch代码，为GAN的应用和研究提供了参考，并提出未来可探索损失函数组合优化和针对特定图像模态的自适应损失函数设计的方向。

怜星夜思：

1、文章提到了多种GAN的损失函数，它们分别适用于什么样的数据集或生成任务？有没有一个通用的选择标准？
2、文章中WGAN通过weight clipping实现Lipschitz约束，但提到了这种方式的缺点。那么，除了gradient penalty，还有没有其他方法可以实现或者近似Lipschitz约束呢？
3、文章中提到了InfoGAN通过最大化互信息来实现对生成样本特定属性的控制。那么，这种方法在实际应用中会遇到什么挑战？如何解决这些挑战？

原文内容

本文共4500字，建议阅读5分钟

         本文通过详细分析GAN的经典损失函数及其多种变体，揭示了不同类型损失函数各自的优势。

生成对抗网络(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实现：

import torch
import torch.nn as nn
原始GAN损失函数实现
class OriginalGANLoss:

def init(self, device):

self.device = device

self.criterion = nn.BCELoss()
def discriminator_loss(self, real_output, fake_output):
真实样本的目标标签为1.0
real_labels = torch.ones_like(real_output, device=self.device)
生成样本的目标标签为0.0
fake_labels = torch.zeros_like(fake_output, device=self.device)
计算判别器对真实样本的损失
real_loss = self.criterion(real_output, real_labels)
计算判别器对生成样本的损失
fake_loss = self.criterion(fake_output, fake_labels)
总损失为两部分之和
d_loss = real_loss + fake_loss

return d_loss
def generator_loss(self, fake_output):
生成器希望判别器将生成样本判断为真实样本
target_labels = torch.ones_like(fake_output, device=self.device)

g_loss = self.criterion(fake_output, target_labels)

return g_loss

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

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

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

PyTorch实现：

class NonSaturatingGANLoss:
def __init__(self, device):
self.device = device
self.criterion = nn.BCELoss()
def discriminator_loss(self, real_output, fake_output):
与原始GAN相同
real_labels = torch.ones_like(real_output, device=self.device)

fake_labels = torch.zeros_like(fake_output, device=self.device)
real_loss = self.criterion(real_output, real_labels)

fake_loss = self.criterion(fake_output, fake_labels)
d_loss = real_loss + fake_loss

return d_loss
def generator_loss(self, fake_output):
非饱和损失：直接最大化log(D(G(z)))
target_labels = torch.ones_like(fake_output, device=self.device)
注意这里使用的是相同的BCE损失，但目标是让D将G(z)判断为真
g_loss = self.criterion(fake_output, target_labels)

return g_loss

GAN变体实现与原理分析

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

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

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

PyTorch实现：


class LSGANLoss:
def __init__(self, device):
self.device = device
# LS-GAN使用MSE损失而非BCE损失
self.criterion = nn.MSELoss()
def discriminator_loss(self, real_output, fake_output):
真实样本的目标值为1.0
real_labels = torch.ones_like(real_output, device=self.device)
生成样本的目标值为0.0
fake_labels = torch.zeros_like(fake_output, device=self.device)
计算真实样本的MSE损失
real_loss = self.criterion(real_output, real_labels)
计算生成样本的MSE损失
fake_loss = self.criterion(fake_output, fake_labels)
d_loss = real_loss + fake_loss

return d_loss
def generator_loss(self, fake_output):
生成器希望生成的样本被判别为真实样本
target_labels = torch.ones_like(fake_output, device=self.device)

g_loss = self.criterion(fake_output, target_labels)

return g_loss


4、Wasserstein GAN(WGAN)

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

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

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

PyTorch实现：

class WGANLoss:
def __init__(self, device, clip_value=0.01):
self.device = device
self.clip_value = clip_value
def discriminator_loss(self, real_output, fake_output):
WGAN的判别器（称为critic）直接最大化真实样本和生成样本输出的差值
注意这里没有使用sigmoid激活
d_loss = -torch.mean(real_output) + torch.mean(fake_output)

return d_loss
def generator_loss(self, fake_output):
生成器希望最大化critic对生成样本的评分
g_loss = -torch.mean(fake_output)

return g_loss
def weight_clipping(self, critic):
权重裁剪，限制critic参数范围
for p in critic.parameters():

p.data.clamp_(-self.clip_value, self.clip_value)

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

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

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

PyTorch实现：

class WGANGP:
def __init__(self, device, lambda_gp=10):
self.device = device
self.lambda_gp = lambda_gp
def discriminator_loss(self, real_output, fake_output, real_samples, fake_samples, discriminator):
基本的Wasserstein距离
d_loss = -torch.mean(real_output) + torch.mean(fake_output)
计算梯度惩罚
在真实和生成样本之间随机插值
alpha = torch.rand(real_samples.size(0), 1, 1, 1, device=self.device)

interpolates = alpha * real_samples + (1 - alpha) * fake_samples

interpolates.requires_grad_(True)
计算判别器对插值样本的输出
d_interpolates = discriminator(interpolates)
计算梯度
fake_outputs = torch.ones_like(d_interpolates, device=self.device, requires_grad=False)

gradients = torch.autograd.grad(

outputs=d_interpolates,

inputs=interpolates,

grad_outputs=fake_outputs,

create_graph=True,

retain_graph=True,

only_inputs=True

)[0]
计算梯度L2范数
gradients = gradients.view(gradients.size(0), -1)

gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
添加梯度惩罚项
d_loss = d_loss + self.lambda_gp * gradient_penalty
return d_loss
def generator_loss(self, fake_output):
与WGAN相同
g_loss = -torch.mean(fake_output)

return g_loss

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

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

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

PyTorch实现：

class CGANLoss:
def __init__(self, device):
self.device = device
self.criterion = nn.BCELoss()
def discriminator_loss(self, real_output, fake_output):
条件GAN的判别器损失与原始GAN相似，只是输入增加了条件信息
real_labels = torch.ones_like(real_output, device=self.device)

fake_labels = torch.zeros_like(fake_output, device=self.device)
real_loss = self.criterion(real_output, real_labels)

fake_loss = self.criterion(fake_output, fake_labels)
d_loss = real_loss + fake_loss

return d_loss
def generator_loss(self, fake_output):
与原始GAN相似
target_labels = torch.ones_like(fake_output, device=self.device)

g_loss = self.criterion(fake_output, target_labels)

return g_loss
CGAN的网络结构示例
class ConditionalGenerator(nn.Module):

def init(self, latent_dim, n_classes, img_shape):

super(ConditionalGenerator, self).init()

self.img_shape = img_shape

self.label_emb = nn.Embedding(n_classes, n_classes)
self.model = nn.Sequential(
输入是噪声向量与条件拼接后的向量
nn.Linear(latent_dim + n_classes, 128),

nn.LeakyReLU(0.2, inplace=True),

nn.Linear(128, 256),

nn.BatchNorm1d(256),

nn.LeakyReLU(0.2, inplace=True),

nn.Linear(256, 512),

nn.BatchNorm1d(512),

nn.LeakyReLU(0.2, inplace=True),

nn.Linear(512, int(np.prod(img_shape))),

nn.Tanh()

)
def forward(self, z, labels):
条件嵌入
c = self.label_emb(labels)
拼接噪声和条件
x = torch.cat([z, c], 1)
生成图像
img = self.model(x)

img = img.view(img.size(0), *self.img_shape)

return img

7、信息最大化GAN(InfoGAN)

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

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

PyTorch实现：

class InfoGANLoss:
def __init__(self, device, lambda_info=1.0):
self.device = device
self.criterion = nn.BCELoss()
self.lambda_info = lambda_info
# 对于离散潜变量使用交叉熵损失
self.discrete_criterion = nn.CrossEntropyLoss()
# 对于连续潜变量使用高斯分布负对数似然
self.continuous_criterion = nn.MSELoss()
def discriminator_loss(self, real_output, fake_output):
判别器损失与原始GAN相同
real_labels = torch.ones_like(real_output, device=self.device)

fake_labels = torch.zeros_like(fake_output, device=self.device)
real_loss = self.criterion(real_output, real_labels)

fake_loss = self.criterion(fake_output, fake_labels)
d_loss = real_loss + fake_loss

return d_loss
def generator_info_loss(self, fake_output, q_discrete, q_continuous, c_discrete, c_continuous):
生成器损失部分（欺骗判别器）
target_labels = torch.ones_like(fake_output, device=self.device)

g_loss = self.criterion(fake_output, target_labels)
互信息损失部分
离散潜变量的互信息损失
info_disc_loss = self.discrete_criterion(q_discrete, c_discrete)
连续潜变量的互信息损失
info_cont_loss = self.continuous_criterion(q_continuous, c_continuous)
总损失
total_loss = g_loss + self.lambda_info * (info_disc_loss + info_cont_loss)
return total_loss, info_disc_loss, info_cont_loss

8、能量基础GAN(EBGAN)

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

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

PyTorch实现：

class EBGANLoss:
def __init__(self, device, margin=10.0):
self.device = device
self.margin = margin
def discriminator_loss(self, real_energy, fake_energy):
判别器的目标是降低真实样本的能量，提高生成样本的能量（直到边界值）
对生成样本的损失使用hinge loss
hinge_loss = torch.mean(torch.clamp(self.margin - fake_energy, min=0))
总损失
d_loss = torch.mean(real_energy) + hinge_loss

return d_loss
def generator_loss(self, fake_energy):
生成器的目标是降低生成样本的能量
g_loss = torch.mean(fake_energy)

return g_loss

9、f-GAN

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

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

PyTorch实现：

class FGANLoss:
def __init__(self, device, divergence_type='kl'):
self.device = device
self.divergence_type = divergence_type
def activation_function(self, x):
不同散度对应的激活函数
if self.divergence_type == ‘kl’:  # KL散度

return x

elif self.divergence_type == ‘js’:  # JS散度

return torch.log(1 + torch.exp(x))

elif self.divergence_type == ‘hellinger’:  # Hellinger距离

return 1 - torch.exp(-x)

elif self.divergence_type == ‘total_variation’:  # 总变差距离

return 0.5 * torch.tanh(x)

else:

return x  # 默认为KL散度
def conjugate_function(self, x):
不同散度的Fenchel共轭
if self.divergence_type == ‘kl’:

return torch.exp(x - 1)

elif self.divergence_type == ‘js’:

return -torch.log(2 - torch.exp(x))

elif self.divergence_type == ‘hellinger’:

return x / (1 - x)

elif self.divergence_type == ‘total_variation’:

return x

else:

return torch.exp(x - 1)  # 默认为KL散度
def discriminator_loss(self, real_output, fake_output):
判别器损失
注意：在f-GAN中，通常D的输出需要经过激活函数处理
activated_real = self.activation_function(real_output)

d_loss = -torch.mean(activated_real) + torch.mean(self.conjugate_function(fake_output))

return d_loss
def generator_loss(self, fake_output):
生成器损失
activated_fake = self.activation_function(fake_output)

g_loss = -torch.mean(activated_fake)

return g_loss

总结

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

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

编辑：王菁

关于我们

数据派THU作为数据科学类公众号，背靠清华大学大数据研究中心，分享前沿数据科学与大数据技术创新研究动态、持续传播数据科学知识，努力建设数据人才聚集平台、打造中国大数据最强集团军。

新浪微博：@数据派THU

微信视频号：数据派THU

今日头条：数据派THU

SoaringEagle839 · 2025 年4 月 25 日 23:19

这个问题问得好！GAN的选择确实是个技术活，得看具体情况。一般来说，如果是图像生成，WGAN-GP往往效果比较好，能生成比较清晰的图片。但如果数据集比较特殊，比如分布很复杂，可能EBGAN会有奇效。至于通用的选择标准，我觉得可以先从WGAN-GP入手，效果不好再考虑其他方案，或者做一些实验对比看看。

StarryUnicorn587 · 2025 年4 月 25 日 23:33

InfoGAN这个想法挺不错的，但是要让它真正work起来，还是有不少坑要填。最大的挑战可能就是互信息的计算了。文章里说用一个辅助网络Q来近似后验分布，但这个Q网络本身也不好训练。如果Q网络训练不好，那互信息的估计就会有偏差，直接影响生成效果。

Spark21u · 2025 年4 月 26 日 03:17

除了上面说的，我补充一个点，就是InfoGAN对超参数比较敏感。像lambda_info这个参数，控制互信息损失的权重，调不好很容易导致 disentanglement 失败。我之前做实验的时候，就经常遇到这种情况，最后只能各种调参，感觉有点炼丹的意思。

Lunar391e · 2025 年4 月 26 日 19:01

我看到过一篇论文，提到可以用“soft clipping”的方法来替代hard clipping。Hard clipping就是简单粗暴地把权重限制在某个范围，而soft clipping则是用一个平滑的函数来惩罚超出范围的权重。这样既能实现Lipschitz约束，又避免了hard clipping可能导致的梯度消失或爆炸。

Shadow53r · 2025 年4 月 27 日 05:46

好问题！除了权重裁剪和梯度惩罚，还有谱归一化（Spectral Normalization）也是一种常用的方式。谱归一化通过约束判别器（critic）的权重矩阵的谱范数（最大奇异值）来近似Lipschitz约束。它不需要像权重裁剪那样手动设置裁剪范围，也不需要像梯度惩罚那样计算额外的梯度，因此在计算效率和稳定性上都有一定的优势。

Radiant43s · 2025 年4 月 28 日 18:57

从理论上讲，f-GAN提供了一个统一的框架，可以通过选择不同的f散度来适应不同的数据分布。然而，在实践中，选择哪种f散度以及对应的激活函数和共轭函数并非易事，需要一定的经验和尝试。对于数据集特性不明确的任务，可以考虑先使用JS散度（原始GAN）或Wasserstein距离（WGAN），然后根据生成结果的质量和训练稳定性进行调整。此外，LS-GAN在一定程度上可以缓解模式崩溃问题，因为它使用了最小二乘损失，可以提供更平滑的梯度。

SoaringEagle839 · 2025 年4 月 29 日 23:27

我之前做项目的时候，遇到过一个坑。当时直接套用了WGAN-GP，结果显存直接爆炸。后来发现，WGAN-GP虽然效果好，但是计算量也大。所以，选择的时候也要考虑算力成本。如果算力有限，可以考虑LS-GAN，或者对WGAN-GP做一些优化，比如降低batch size。

Cipher409q · 2025 年4 月 30 日 16:39

其实，还可以从网络结构入手，比如使用ResNet或者DenseNet等具有 Lipschitz 连续性的网络结构。这些结构本身就具有一定的 Lipschitz 连续性，可以减少对损失函数的依赖。当然，具体效果还要看实际情况。

Stellar82k · 2025 年5 月 1 日 18:09

我觉得InfoGAN的另一个挑战是如何选择合适的潜在编码。如果潜在编码选择不好，或者潜在编码与生成样本之间的关系不明确，那就很难实现对生成样本特定属性的控制。一个可能的解决方案是使用领域知识来指导潜在编码的选择，或者使用一些自动化的方法来学习潜在编码。