AI入门：神经网络实战----WGAN

ゝ一纸荒年。 2022-12-30 12:55 192阅读 0赞

前言  
在大数据时代，数据的质量和数量是最重要的。监督学习中的样本需要我们人工进行标注，而人工标注这个工作本身是非常枯燥乏味，且工作量巨大的事情。如果我们的神经网络使用非监督学习，那就可以避免标注工作，节约很多成本，同时获得更多的数据。因此非监督学习是未来的一个重要发展方向。上一节我们学的GAN就是一种非监督学习的神经网络，因此学习和改进GAN是非常重要的。

在上一节中，我们提到了GAN的一些缺点：  
1、GAN要求G和D相互匹配。这一点在实际编程中是比较困难的。  
2、GAN的训练比较缓慢。  
3、准确率以及损失值都是不能正确估量模型的真实情况。

其中最困难的是要求G和D在训练过程中一直保持匹配。如果不匹配，则该神经网络就容易崩溃。  
什么是WGAN？  
WGAN由两篇论文提出，主要是数学方面的推导。我们跳过数学推导的内容，直接看结论。WGAN没有改变GAN的框架，只是对GAN进行四方面的改进：  
1、判别器最后一层去掉sigmoid。  
2、生成器和判别器的loss不取log。  
3、每次更新判别器的参数之后把它们的绝对值截断到不超过一个固定常数c。后来又改为一个梯度惩罚项，相当于一个正则。  
4、不要用基于动量的优化算法 (包括momentum和Adam)，推荐RMSProp，SGD也行。

有了上面感性的认识之后，我们就开始实现WGAN：  
Generative Network的实现：  
WGAN的生成器的代码与GAN的生成器代码完全一致：就是输入一个随机噪音数据z\_prior，然后经过3层全连接层，得到28 \* 28 = 784维的一张图片。这张图片如果经过变形，就可以变成(28, 28)的图片，尺寸与MNIST数据集中的图片有一样的尺寸。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70]

Discriminator Network的实现：  
相比于GAN，WGAN的判别器的最后一层少了Sigmoid()函数：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70 1]

WGAN的训练：  
WGAN也是先训练判别器。为了训练判别器，我们必须先生成生成器的实例G和判别器的实例D。然后定义D的损失函数和优化器。这里的优化器要使用不带动量的函数，推荐使用RMSprop()。

![在这里插入图片描述][20201225142030114.png]

下面要对判别器进行训练。这里跟GAN区别较大，GAN直接使用BCELoss()作为损失函数，但这里要自己计算损失。我们从MNIST数据集中获取到一个batch的真实图片img。把图片转化成一维数据后转化成Tensor对象。接着用判别器对这些真实图片进行预测，得到计算结果。

![在这里插入图片描述][20201225142042916.png]

接着用噪音z生成假的图片，然后计算判别器对假图片的预测结果。与GAN中一样，这个过程中的生成器要用detach()处理。

![在这里插入图片描述][20201225142055440.png]

这里要出现第三个改进：梯度惩罚项，也就是一个正则gp (在源代码中看gp的计算方法)。得到真假图片的预测值、梯度惩罚项之后，就可以计算总的损失了。注意，这里使用了Wasserstein距离这一个概念。也就是计算真假图片的预测值的差。系数0.5是可以自由调节的。

![在这里插入图片描述][20201225142108697.png]

有了损失值之后，就可以从判别器的损失值开始进行反向传播，参数优化了。值得注意的是，由于WGAN网络不需要考虑G和D的匹配问题，所以我们可以先让判别器多训练几次，这样一个比较好的判别器可以让G更快的成长。

![在这里插入图片描述][20201225142121400.png]

训练了判别器之后，就可以训练生成器了。训练生成器的过程：先获得噪音z，然后用G生成假图片。这里要训练G，所以这里不能用detach()处理。接下去是求判别器的计算结果。由于我们希望生成器的损失值变小，所以要对判别器的计算结果求负值。在得到损失值之后，就可以进行反向传播和参数优化了。至此，终于完成生成器和判别器的训练了。

![在这里插入图片描述][20201225142132726.png]

总结：  
与GAN相比，WGAN生成的图片的效果并没有太大的改进。WGAN最大的优势在于从理论上解决了GAN中G和D必须匹配，否则模型就容易崩溃的问题。从而使我们不再需要小心的设计网络，让我们可以在GAN中放心的使用VGG16、ResNet等成熟的模型，最终生成效果更好的图片。

在WGAN之后，还有BigGAN和StyleGAN等GAN的改进形式。BigGAN生成的图片的多样性好，画质非常的清晰、细腻；StyleGAN还能够控制所生成图像的高层级属性(high-level attributes)，如发型、雀斑等。这些内容，我们将在后续课程中进行解释和实现。

from WGAN.WGAN_Discriminator import *
    from WGAN.WGAN_Generator import *
    from WGAN import WGAN_Resource
    
    import torch
    from torch import optim
    from torch.autograd import Variable
    from torch import autograd
    from torchvision import datasets, models, transforms
    import torchvision
    from torchvision.utils import save_image
    
    #加载torchvision包内内置的MNIST数据集 
    #这里涉及到transform:将图片转化成torchtensor
    train_dataset = datasets.MNIST(root='../', #保存/读取数据集的路径
                                   train=True, #是否用于训练
                                   transform=transforms.ToTensor(),
                                   download=False) #是否要下载
    
    #train_loader和test_loader用于加载小批次数据，
    #即将MNIST数据集中的data分成每组batch_size的小块，
    train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                   batch_size=WGAN_Resource.batch_size,
                                   shuffle=True)#是否随机读取
    
    
    def to_img(x):
        out = 0.5 * (x + 1)
        out = out.clamp(0, 1)
        out = out.reshape(-1, 1, 28, 28)
        return out
    
    def gradient_penalty(D, xr, xf):
        t = torch.rand(WGAN_Resource.batch_size, 1)
        
        if t.shape[0] > xr.shape[0]:
            return 0
        #print(t.shape, xr.shape)
        t = t.expand_as(xr)
        mid = t * xr + (1 - t) * xf
        mid.requires_grad_()
        
        pred = D(mid)
        grads = autograd.grad(outputs = pred, inputs = mid,
                              grad_outputs = torch.ones_like(pred),
                              create_graph=True, retain_graph=True, only_inputs=True)[0]
        
        gp = torch.pow(grads.norm(2, dim=1) - 1, 2).mean()
        return gp
    
    #训练
    D = GAN_Discriminator()#判别器的实例
    G = GAN_Generator()#生成器的实例
    
    #改进4、两个优化器都采用RMSprop()，不使用带动量的优化函数，例如Adam()
    d_optimizer = optim.RMSprop(D.parameters(), lr=0.0003)
    g_optimizer = optim.RMSprop(G.parameters(), lr=0.0003)
    
    num_epoch = 5000 #训练的总次数
    
    # 开始训练
    for epoch in range(num_epoch):
        for i, (img, _) in enumerate(train_loader):
            for n in range(5):
                num_img = img.size(0)
                # 训练判别器
                img = img.reshape(num_img, -1)
                real_img = Variable(img)
                d_loss_real = D(real_img)# 真实图片的损失要小，
         
                # 计算假图片的损失
                z = Variable(torch.randn(num_img, WGAN_Resource.z_size)) #生成噪音
                
                #生成器只是提供假图片，没必要对G进行训练，所以要把G进行detach()处理
                fake_img = G(z).detach() #生成假图片
                d_loss_fake = D(fake_img) #计算假图片的损失值，假图片的损失值要大
                
                gp = gradient_penalty(D, real_img, fake_img)#梯度惩罚项
                
                #改进2、优化损失函数。生成器和判决器的loss不取log
                # 判别器的总的损失值的平均值。真实图片的损失值为什么要取负数？
                # Wasserstein距离是要最大化 real_loss - fake_loss
                # 这里加上一个负号，loss下降就相当于最大化Wasserstein距离
                d_loss = (d_loss_fake - d_loss_real + 0.5 * gp).mean() #改进3、gp是惩罚项，相当于正则
                d_optimizer.zero_grad()
                d_loss.backward()
                d_optimizer.step()
     
            # 训练生成器
            z = Variable(torch.randn(num_img, WGAN_Resource.z_size)) #生成噪音
            fake_img = G(z) #生成假图片
            g_loss = torch.mean(-D(fake_img)) #计算生成器的损失值，为什么要取负值？
     
            # bp and optimize
            g_optimizer.zero_grad()
            g_loss.backward()
            g_optimizer.step()
     
            if (i + 1) % 100 == 0:
                print('Epoch [{}/{}], d_loss: {:.6f}, g_loss: {:.6f} '
                      .format(
                          epoch, num_epoch, d_loss.item(), g_loss.item()))
        if epoch == 0:
            real_images = to_img(real_img.cpu().data)
            save_image(real_images, './img/real_images.png')
     
        fake_images = to_img(fake_img.cpu().data)
        save_image(fake_images, './img/fake_images-{}.png'.format(epoch + 1))
     
    torch.save(G.state_dict(), './generator.pth')
    torch.save(D.state_dict(), './discriminator.pth')
            
    print("完成")

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70]: /images/20221120/2c0e299dce40448aac6619128d69a609.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201225142016747.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc=,size_16,color_FFFFFF,t_70
[20201225142030114.png]: https://img-blog.csdnimg.cn/20201225142030114.png
[20201225142042916.png]: https://img-blog.csdnimg.cn/20201225142042916.png
[20201225142055440.png]: https://img-blog.csdnimg.cn/20201225142055440.png
[20201225142108697.png]: https://img-blog.csdnimg.cn/20201225142108697.png
[20201225142121400.png]: https://img-blog.csdnimg.cn/20201225142121400.png
[20201225142132726.png]: https://img-blog.csdnimg.cn/20201225142132726.png