使用Pytorch实现频谱归一化生成对抗网络(SN-GAN)

自从扩散模型发布以来，GAN的关注度和论文是越来越少了，但是它们里面的一些思路还是值得我们了解和学习。所以本文我们来使用Pytorch 来实现SN-GAN

谱归一化生成对抗网络是一种生成对抗网络，它使用谱归一化技术来稳定鉴别器的训练。谱归一化是一种权值归一化技术，它约束了鉴别器中每一层的谱范数。这有助于防止鉴别器变得过于强大，从而导致不稳定和糟糕的结果。

SN-GAN由Miyato等人(2018)在论文“生成对抗网络的谱归一化”中提出，作者证明了sn - gan在各种图像生成任务上比其他gan具有更好的性能。

SN-GAN的训练方式与其他gan相同。生成器网络学习生成与真实图像无法区分的图像，而鉴别器网络学习区分真实图像和生成图像。这两个网络以竞争的方式进行训练，它们最终达到一个点，即生成器能够产生逼真的图像，从而欺骗鉴别器。

以下是SN-GAN相对于其他gan的优势总结:

更稳定，更容易训练

可以生成更高质量的图像

更通用，可以用来生成更广泛的内容。

模式崩溃

模式崩溃是生成对抗网络(GANs)训练中常见的问题。当GAN的生成器网络无法产生多样化的输出，而是陷入特定的模式时，就会发生模式崩溃。这会导致生成的输出出现重复，缺乏多样性和细节，有时甚至与训练数据完全无关。

GAN中发生模式崩溃有几个原因。一个原因是生成器网络可能对训练数据过拟合。如果训练数据不够多样化，或者生成器网络太复杂，就会发生这种情况。另一个原因是生成器网络可能陷入损失函数的局部最小值。如果学习率太高，或者损失函数定义不明确，就会发生这种情况。

以前有许多技术可以用来防止模式崩溃。比如使用更多样化的训练数据集。或者使用正则化技术，例如dropout或批处理归一化，使用合适的学习率和损失函数也很重要。

Wassersteian损失

Wasserstein损失，也称为Earth Mover’s Distance(EMD)或Wasserstein GAN (WGAN)损失，是一种用于生成对抗网络(GAN)的损失函数。引入它是为了解决与传统GAN损失函数相关的一些问题，例如Jensen-Shannon散度和Kullback-Leibler散度。

Wasserstein损失测量真实数据和生成数据的概率分布之间的差异，同时确保它具有一定的数学性质。他的思想是最小化这两个分布之间的Wassersteian距离(也称为地球移动者距离)。Wasserstein距离可以被认为是将一个分布转换为另一个分布所需的最小“成本”，其中“成本”被定义为将概率质量从一个位置移动到另一个位置所需的“工作量”。

Wasserstein损失的数学定义如下:

对于生成器G和鉴别器D, Wasserstein损失(Wasserstein距离)可以表示为:

Jensen-Shannon散度(JSD): Jensen-Shannon散度是一种对称度量，用于量化两个概率分布之间的差异

对于概率分布P和Q, JSD定义如下:

JSD(P∥Q)=1/2(KL(P∥M)+KL(Q∥M))

M为平均分布，KL为Kullback-Leibler散度，P∥Q为分布P与分布Q之间的JSD。

JSD总是非负的，在0和1之间有界，并且对称(JSD(P|Q) = JSD(Q|P))。它可以被解释为KL散度的“平滑”版本。

Kullback-Leibler散度(KL散度):Kullback-Leibler散度，通常被称为KL散度或相对熵，通过量化“额外信息”来测量两个概率分布之间的差异，这些“额外信息”需要使用另一个分布作为参考来编码一个分布。

对于两个概率分布P和Q，从Q到P的KL散度定义为:KL(P∥Q)=∑x P(x)log(Q(x)/P(x))。KL散度是非负非对称的，即KL(P∥Q)≠KL(Q∥P)。当且仅当P和Q相等时它为零。KL散度是无界的，可以用来衡量分布之间的不相似性。

1-Lipschitz Contiunity

1- lipschitz函数是斜率的绝对值以1为界的函数。这意味着对于任意两个输入x和y，函数输出之间的差不超过输入之间的差。

数学上函数f是1-Lipschitz，如果对于f定义域内的所有x和y，以下不等式成立:

|f(x) — f(y)|

在生成对抗网络(GANs)中强制Lipschitz连续性是一种用于稳定训练和防止与传统GANs相关的一些问题的技术，例如模式崩溃和训练不稳定。在GAN中实现Lipschitz连续性的主要方法是通过使用Lipschitz约束或正则化，一种常用的方法是Wasserstein GAN (WGAN)。

在标准gan中，鉴别器(也称为WGAN中的批评家)被训练来区分真实和虚假数据。为了加强Lipschitz连续性，WGAN增加了一个约束，即鉴别器函数应该是Lipschitz连续的，这意味着函数的梯度不应该增长得太大。在数学上，它被限制为:

∥∣D(x)−D(y)∣≤K⋅∥x−y∥

其中D(x)是评论家对数据点x的输出，D(y)是y的输出，K是Lipschitz 常数。

WGAN的权重裁剪:在原始的WGAN中，通过在每个训练步骤后将鉴别器网络的权重裁剪到一个小范围(例如，[-0.01,0.01])来强制执行该约束。权重裁剪确保了鉴别器的梯度保持在一定范围内，并加强了利普希茨连续性。

WGAN的梯度惩罚: WGAN的一种变体，称为WGAN-GP，它使用梯度惩罚而不是权值裁剪来强制Lipschitz约束。WGAN-GP基于鉴别器的输出相对于真实和虚假数据之间的随机点的梯度，在损失函数中添加了一个惩罚项。这种惩罚鼓励了Lipschitz约束，而不需要权重裁剪。

谱范数

从符号上看矩阵的谱范数通常表示为:对于神经网络矩阵表示网络层中的一个权重矩阵。矩阵的谱范数是矩阵的最大奇异值，可以通过奇异值分解(SVD)得到。

奇异值分解是特征分解的推广，用于将矩阵分解为

其中，q为正交矩阵，Σ为其对角线上的奇异值矩阵。注意Σ不一定是正方形的。

其中1和分别为最大奇异值和最小奇异值。更大的值对应于一个矩阵可以应用于另一个向量的更大的拉伸量。依此表示，()=1.

SVD在谱归一化中的应用

为了对权矩阵进行频谱归一化，将矩阵中的每个值除以它的频谱范数。谱归一化矩阵可以表示为

计算is的SVD非常昂贵，所以SN-GAN论文的作者做了一些简化。它们通过幂次迭代来近似左、右奇异向量和，分别为:)≈

代码实现

现在我们开始使用Pytorch实现

import torch

from torch import nn

from tqdm.auto import tqdm

from torchvision import transforms

from torchvision.datasets import MNIST

from torchvision.utils import make_grid

from torch.utils.data import DataLoader

import matplotlib.pyplot as plt

torch.manual_seed(0)

def show_tensor_images(image_tensor, num_images=25, size=(1, 28, 28)):

  image_tensor = (image_tensor + 1) / 2

  image_unflat = image_tensor.detach().cpu()

  image_grid = make_grid(image_unflat[:num_images], nrow=5)

  plt.imshow(image_grid.permute(1, 2, 0).squeeze())

  plt.show()

生成器：

class Generator(nn.Module):

    def __init__(self,z_dim=10,im_chan = 1,hidden_dim = 64):

        super(Generatoe,self).__init__()

        self.gen = nn.Sequential(

        self.make_gen_block(z_dim,hidden_dim * 4),

        self.make_gen_block(hidden_dim*4,hidden_dim * 2,kernel_size = 4,stride =1),

        self.make_gen_block(hidden_dim * 2,hidden_dim),

        self.make_gen_block(hidden_dim,im_chan,kernel_size=4,final_layer = True),

        )

  def make_gen_block(self,input_channels,output_channels,kernel_size=3,stride=2,final_layer = False):

        if not final_layer :

          return nn.Sequential(nn.ConvTranspose2D(input_layer,output_layer,kernel_size,stride),

                  nn.BatchNorm2d(output_channels),

                  nn.ReLU(inplace = True),

                    )

        else:

          return nn.Sequential(nn.ConvTranspose2D(input_layer,output_layer,kernel_size,stride),

                  nn.Tanh(),)

def unsqueeze_noise():

      return noise.view(len(noise), self.z_dim, 1, 1)

def forward(self,noise):

    x = self.unsqueeze_noise(noise)

    return self.gen(x)

def get_noise(n_samples, z_dim, device='cpu'):

  return torch.randn(n_samples, z_dim, device=device)

鉴频器

对于鉴别器，我们可以使用spectral_norm对每个Conv2D 进行处理。除了之外，还引入了、、和其他的参数，这样在运行时就可以计算出的二进制二进制运算符:、y、y、y、y

因为Pytorch还提供 nn.utils. spectral_norm，nn.utils. remove_spectral_norm函数，所以我们操作起来很方便。

我们只在推理期间将nn.utils. remove_spectral_norm应用于卷积层，以提高运行速度。

值得注意的是，谱范数并不能消除对批范数的需要。谱范数影响每一层的权重，批范数影响每一层的激活度。

class Discriminator(nn.Module):

    def __init__(self, im_chan=1, hidden_dim=16):

      super(Discriminator, self).__init__()

      self.disc = nn.Sequential(

          self.make_disc_block(im_chan, hidden_dim),

          self.make_disc_block(hidden_dim, hidden_dim * 2),

          self.make_disc_block(hidden_dim * 2, 1, final_layer=True),

      )

    def make_disc_block(self, input_channels, output_channels, kernel_size=4, stride=2, final_layer=False):

      if not final_layer:

          return nn.Sequential(

              nn.utils.spectral_norm(nn.Conv2d(input_channels, output_channels, kernel_size, stride)),

              nn.BatchNorm2d(output_channels),

              nn.LeakyReLU(0.2, inplace=True),

          )

      else:

          return nn.Sequential(

              nn.utils.spectral_norm(nn.Conv2d(input_channels, output_channels, kernel_size, stride)),

          )

  def forward(self, image):

      disc_pred = self.disc(image)

      return disc_pred.view(len(disc_pred), -1)训练

我们这里使用MNIST数据集，bcewithlogitsloss()函数计算logit和目标标签之间的二进制交叉熵损失。二值交叉熵损失是对两个分布差异程度的度量。在二元分类中，这两种分布分别是逻辑的分布和目标标签的分布。

criterion = nn.BCEWithLogitsLoss()

n_epochs = 50

z_dim = 64

display_step = 500

batch_size = 128

# A learning rate of 0.0002 works well on DCGAN

lr = 0.0002

beta_1 = 0.5

beta_2 = 0.999

device = 'cuda'

transform = transforms.Compose([

  transforms.ToTensor(),

  transforms.Normalize((0.5,), (0.5,)),

])

dataloader = DataLoader(

  MNIST(".", download=True, transform=transform),

  batch_size=batch_size,

  shuffle=True)

创建生成器和鉴别器

gen = Generator(z_dim).to(device)

gen_opt = torch.optim.Adam(gen.parameters(), lr=lr, betas=(beta_1, beta_2))

disc = Discriminator().to(device)

disc_opt = torch.optim.Adam(disc.parameters(), lr=lr, betas=(beta_1, beta_2))

# initialize the weights to the normal distribution

# with mean 0 and standard deviation 0.02

def weights_init(m):

  if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):

      torch.nn.init.normal_(m.weight, 0.0, 0.02)

  if isinstance(m, nn.BatchNorm2d):

      torch.nn.init.normal_(m.weight, 0.0, 0.02)

      torch.nn.init.constant_(m.bias, 0)

gen = gen.apply(weights_init)

disc = disc.apply(weights_init)

下面是训练步骤

cur_step = 0

mean_generator_loss = 0

mean_discriminator_loss = 0

for epoch in range(n_epochs):

  # Dataloader returns the batches

  for real, _ in tqdm(dataloader):

      cur_batch_size = len(real)

      real = real.to(device)

      ## Update Discriminator ##

      disc_opt.zero_grad()

      fake_noise = get_noise(cur_batch_size, z_dim, device=device)

      fake = gen(fake_noise)

      disc_fake_pred = disc(fake.detach())

      disc_fake_loss = criterion(disc_fake_pred, torch.zeros_like(disc_fake_pred))

      disc_real_pred = disc(real)

      disc_real_loss = criterion(disc_real_pred, torch.ones_like(disc_real_pred))

      disc_loss = (disc_fake_loss + disc_real_loss) / 2

      # Keep track of the average discriminator loss

      mean_discriminator_loss += disc_loss.item() / display_step

      # Update gradients

      disc_loss.backward(retain_graph=True)

      # Update optimizer

      disc_opt.step()

      ## Update Generator ##

      gen_opt.zero_grad()

      fake_noise_2 = get_noise(cur_batch_size, z_dim, device=device)

      fake_2 = gen(fake_noise_2)

      disc_fake_pred = disc(fake_2)

      gen_loss = criterion(disc_fake_pred, torch.ones_like(disc_fake_pred))

      gen_loss.backward()

      gen_opt.step()

      # Keep track of the average generator loss

      mean_generator_loss += gen_loss.item() / display_step

      ## Visualization code ##

      if cur_step % display_step == 0 and cur_step > 0:

          print(f"Step {cur_step}: Generator loss: {mean_generator_loss}, discriminator loss: {mean_discriminator_loss}")

          show_tensor_images(fake)

          show_tensor_images(real)

          mean_generator_loss = 0

          mean_discriminator_loss = 0

      cur_step += 1

训练结果如下：

总结

本文我们介绍了SN-GAN的原理和简单的代码实现，SN-GAN已经被广泛应用于图像生成任务，包括图像合成、风格迁移和超分辨率等领域。它在改善生成模型的性能和稳定性方面取得了显著的成果，所以学习他的代码对我们理解会更有帮助。

作者：DhanushKumar