对抗生成网络GAN系列——GANomaly原理及源码解析-灵析社区

GANomaly原理解析

【阅读此部分前建议对GAN的原理及GAN在缺陷检测上的应用有所了解，详情点击写在前面中的链接查看，本篇文章我不会再介绍GAN的一些先验知识。】

GANomaly结构

这部分为大家介绍GANomaly的原理，其实我们一起来看下图就足够了：

图1 GANomaly结构图

我们还是先来对上图中的结构做一些解释。从直观的颜色上来看，我们可以分成两类，一类是红色的Encoder结构，一类是蓝色的Decoder结构。Encoder主要就是降维的作用啦，如将一张张图片数据压缩成一个个潜在向量；相反，Decoder就是升维的作用，如将一个个潜在向量重建成一张张图片。按照论文描述的结构来分，可以分成三个子结构，分别为生成器网络G，编码器网络E和判别器网络D。下面分别来介绍介绍这三个子结构：

生成器网络G

思来想去我还是想在这里给大家抛出一个问题，我们传统的GAN是怎么通过生成器来构建假图像的呢？和GANomaly有区别吗？其实这个问题的答案很简单，大家都稍稍思考一下，我就不给答案了，不明白的评论区见吧！！！🥂🥂🥂

编码器网络E

判别器网络D

GANomaly的损失函数分为两部分，第一部分是生成器损失，第二部分为判别器损失，下面我们分别来进行介绍：

生成器损失函数

判别器损失函数

判别器的损失函数就和原始GAN一样，如下：

这部分我直接先放上代码吧，不多，也很容易理解，如下：

.l_bce = nn.BCELoss()
al - Fake Loss
.err_d_real = self.l_bce(self.pred_real, self.real_label)
.err_d_fake = self.l_bce(self.pred_fake, self.fake_label)

tD Loss & Backward-Pass
.err_d = (self.err_d_real + self.err_d_fake) * 0.

GANomaly测试阶段

# latent_i表示G_E(x)，latent_o表示E(G(x))。torch.pow(m,2)=m^2 
error = torch.mean(torch.pow((latent_i-latent_o), 2), dim=1)

GANomaly源码解析

这里直接使用论文中提供的源码地址：GANomaly源码🌱🌱🌱

GANomaly模型搭建

其实通过我前文的讲解，不知道大家能否感受到GANomaly模型其实是不复杂的。需要注意的是在介绍GANomaly结构时我们将模型分为了三个子结构，分别为生成器网络G、编码器网络E、判别器网络D。但是在代码中我们将生成器网络G和编码器网络E合并在一块儿了，也称为生成器网络G。

下面我给出这部分的代码，大家注意一下这里面的超参数比较多，为了方便大家阅读，我把这里用到超参数的整理出来，如下图所示:

""" Network architectures.
"""
# pylint: disable=W0221,W0622,C0103,R0913

##
import torch
import torch.nn as nn
import torch.nn.parallel
from options import Options

##
def weights_init(mod):
    """
    Custom weights initialization called on netG, netD and netE
    :param m:
    :return:
    """
    classname = mod.__class__.__name__
    if classname.find('Conv') != -1:
        mod.weight.data.normal_(0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        mod.weight.data.normal_(1.0, 0.02)
        mod.bias.data.fill_(0)

###
class Encoder(nn.Module):
    """
    DCGAN ENCODER NETWORK
    """

    def __init__(self, isize, nz, nc, ndf, ngpu, n_extra_layers=0, add_final_conv=True):
        super(Encoder, self).__init__()
        self.ngpu = ngpu
        assert isize % 16 == 0, "isize has to be a multiple of 16"

        main = nn.Sequential()
        # input is nc x isize x isize
        main.add_module('initial-conv-{0}-{1}'.format(nc, ndf),
                        nn.Conv2d(nc, ndf, 4, 2, 1, bias=False))
        main.add_module('initial-relu-{0}'.format(ndf),
                        nn.LeakyReLU(0.2, inplace=True))
        csize, cndf = isize / 2, ndf     # csize=16,cndf=64

        # Extra layers
        for t in range(n_extra_layers):
            main.add_module('extra-layers-{0}-{1}-conv'.format(t, cndf),
                            nn.Conv2d(cndf, cndf, 3, 1, 1, bias=False))
            main.add_module('extra-layers-{0}-{1}-batchnorm'.format(t, cndf),
                            nn.BatchNorm2d(cndf))
            main.add_module('extra-layers-{0}-{1}-relu'.format(t, cndf),
                            nn.LeakyReLU(0.2, inplace=True))

        while csize > 4:
            in_feat = cndf
            out_feat = cndf * 2
            main.add_module('pyramid-{0}-{1}-conv'.format(in_feat, out_feat),
                            nn.Conv2d(in_feat, out_feat, 4, 2, 1, bias=False))
            main.add_module('pyramid-{0}-batchnorm'.format(out_feat),
                            nn.BatchNorm2d(out_feat))
            main.add_module('pyramid-{0}-relu'.format(out_feat),
                            nn.LeakyReLU(0.2, inplace=True))
            cndf = cndf * 2
            csize = csize / 2

        # state size. K x 4 x 4
        if add_final_conv:
            main.add_module('final-{0}-{1}-conv'.format(cndf, 1),
                            nn.Conv2d(cndf, nz, 4, 1, 0, bias=False))

        self.main = main

    def forward(self, input):
        if self.ngpu > 1:
            output = nn.parallel.data_parallel(self.main, input, range(self.ngpu))
        else:
            output = self.main(input)

        return output

##
class Decoder(nn.Module):
    """
    DCGAN DECODER NETWORK
    """
    def __init__(self, isize, nz, nc, ngf, ngpu, n_extra_layers=0):
        super(Decoder, self).__init__()
        self.ngpu = ngpu
        assert isize % 16 == 0, "isize has to be a multiple of 16"

        cngf, tisize = ngf // 2, 4    #cngf=32 ,tisize=4
        while tisize != isize:
            cngf = cngf * 2
            tisize = tisize * 2

        main = nn.Sequential()
        # input is Z, going into a convolution
        main.add_module('initial-{0}-{1}-convt'.format(nz, cngf),
                        nn.ConvTranspose2d(nz, cngf, 4, 1, 0, bias=False))
        main.add_module('initial-{0}-batchnorm'.format(cngf),
                        nn.BatchNorm2d(cngf))
        main.add_module('initial-{0}-relu'.format(cngf),
                        nn.ReLU(True))

        csize, _ = 4, cngf
        while csize < isize // 2:
            main.add_module('pyramid-{0}-{1}-convt'.format(cngf, cngf // 2),
                            nn.ConvTranspose2d(cngf, cngf // 2, 4, 2, 1, bias=False))
            main.add_module('pyramid-{0}-batchnorm'.format(cngf // 2),
                            nn.BatchNorm2d(cngf // 2))
            main.add_module('pyramid-{0}-relu'.format(cngf // 2),
                            nn.ReLU(True))
            cngf = cngf // 2
            csize = csize * 2

        # Extra layers
        for t in range(n_extra_layers):
            main.add_module('extra-layers-{0}-{1}-conv'.format(t, cngf),
                            nn.Conv2d(cngf, cngf, 3, 1, 1, bias=False))
            main.add_module('extra-layers-{0}-{1}-batchnorm'.format(t, cngf),
                            nn.BatchNorm2d(cngf))
            main.add_module('extra-layers-{0}-{1}-relu'.format(t, cngf),
                            nn.ReLU(True))

        main.add_module('final-{0}-{1}-convt'.format(cngf, nc),
                        nn.ConvTranspose2d(cngf, nc, 4, 2, 1, bias=False))
        main.add_module('final-{0}-tanh'.format(nc),
                        nn.Tanh())
        self.main = main

    def forward(self, input):
        if self.ngpu > 1:
            output = nn.parallel.data_parallel(self.main, input, range(self.ngpu))
        else:
            output = self.main(input)
        return output


## 判别器网络结构
class NetD(nn.Module):
    """
    DISCRIMINATOR NETWORK
    """

    def __init__(self, opt):
        super(NetD, self).__init__()
        model = Encoder(opt.isize, 1, opt.nc, opt.ngf, opt.ngpu, opt.extralayers)
        layers = list(model.main.children())

        self.features = nn.Sequential(*layers[:-1])
        self.classifier = nn.Sequential(layers[-1])
        self.classifier.add_module('Sigmoid', nn.Sigmoid())

    def forward(self, x):
        features = self.features(x)
        features = features
        classifier = self.classifier(features)
        classifier = classifier.view(-1, 1).squeeze(1)

        return classifier, features

## 生成器网络结构
class NetG(nn.Module):
    """
    GENERATOR NETWORK
    """

    def __init__(self, opt):
        super(NetG, self).__init__()
        
        self.encoder1 = Encoder(opt.isize, opt.nz, opt.nc, opt.ngf, opt.ngpu, opt.extralayers)
        self.decoder = Decoder(opt.isize, opt.nz, opt.nc, opt.ngf, opt.ngpu, opt.extralayers)
        self.encoder2 = Encoder(opt.isize, opt.nz, opt.nc, opt.ngf, opt.ngpu, opt.extralayers)

    def forward(self, x):
        latent_i = self.encoder1(x)
        gen_imag = self.decoder(latent_i)
        latent_o = self.encoder2(gen_imag)
        return gen_imag, latent_i, latent_o

GANomaly损失函数

我们在理论部分已经介绍了GANomaly的损失函数，那么在代码上它们都是一一对应的，实现起来也很简单，如下：

## 定义L1 Loss
def l1_loss(input, target):
    return torch.mean(torch.abs(input - target))

## 定义L2 Loss
def l2_loss(input, target, size_average=True):
    if size_average:
        return torch.mean(torch.pow((input-target), 2))
    else:
        return torch.pow((input-target), 2)


self.l_adv = l2_loss
self.l_con = nn.L1Loss()
self.l_enc = l2_loss

self.err_g_adv = self.l_adv(self.netd(self.input)[1], self.netd(self.fake)[1])
self.err_g_con = self.l_con(self.fake, self.input)
self.err_g_enc = self.l_enc(self.latent_o, self.latent_i)
self.err_g = self.err_g_adv * self.opt.w_adv + \
             self.err_g_con * self.opt.w_con + \
             self.err_g_enc * self.opt.w_enc

上述代码为GANomaly生成器损失函数代码，判别器的损失函数代码已经在理论部分为大家介绍了，这里就不在赘述了。🍄🍄🍄

小结

这里我并没有很详细的为大家解读代码，但是把一些关键的部分都给大家介绍了。会了这些其实你完全可以自己实现一个GANomaly网络，或者对我之前在Anogan中的代码稍加改造也可以达到一样的效果。论文中提供的源码感兴趣的大家可以自己去调试一下，代码量也不算多，但有的地方理解起来也有一定的困难，总之大家加油吧！！！🌼🌼🌼

阅读量：308

点赞量：0

收藏量:0