cycleGAN算法解读

本文参考:https://blog.csdn.net/Mr_health/article/details/112545671

1 CycleGAN概述 

CycleGAN:循环生成对抗神经网络,是一种非监督学习模型。

Pix2pix方法适用于成对数据的风格迁移,而大多数情况下对于A风格的图像,并没有与之相对应的B风格图像。获取严格意义上的成对数据是非常困难的,所以不依赖成对数据的算法具有非常重要的实际意义。我们所拥有的是一群处于风格A(源域)的图像和一群处于风格B(目标域)的图像,这样pix2pix方法就不管用了。

cycleGAN算法解读_第1张图片

CycleGAN的创新点在于能够在源域和目标域之间,无须建立训练数据间一对一的映射,就可以实现这种迁移。

2 CycleGAN基本架构

(1)输入

X:源域,风格A的图像

Y:目标域,风格B的图像

(2)两个生成器:

G:用于将风格A的图像x转换为风格B的图像

F:用于将风格B的图像y转换为风格A的图像

(3)Cycle解释

通过G将风格A的图像x转换为风格B的图像Y‘,之后再将Y’通过F后仍然能够转换回风格A,并能保证图像中的内容一致。

通过F将风格B的图像y转换为风格A的图像X‘,之后再将X’通过G后仍然能够转换回风格B,并能保证图像中的内容一致。

也就是训练好G和F就可以自由地完成风格A、B的转换了。

cycleGAN算法解读_第2张图片

3 损失函数

在训练中引入两个判别器:

Dy:区分真实的风格B的图像与通过G转换而来的假的风格B的图像

Dx:区分真实的风格A的图像与通过G转换而来的假的风格A的图像

损失函数主要由以下几个部分构成:

(1)Dy处的GAN损失:

 (2)Dx处的GAN损失:

(3)循环一致性损失,即cycle解释那块逻辑

 

(4)Identity loss

这个loss的含义是:生成器G用来生成y风格的图像,那么把y送入G应该仍然生成y,只有这样才能证明G具有生成y风格的能力。因此G(y)和y应该尽可能接近。根据论文中的解释,如果不加入该loss,那么生成器可能会自主地修改图像的色调,使得整体的颜色发生变化。

4 CycleGAN网络结构解读

GAN由生成网络(Generator)和辨别(Discriminator)网络两部分组成

Generator网络有2个,分别支持A->B和B->A的转化,其输入输出不会改变维度信息,如下图所示:

cycleGAN算法解读_第3张图片

Discriminator网络也有2个:

D_A:G_A(A) vs B

D_B:G_B(B) vs A

输入后会改变维度大小,输出channel从3变为1,特征为30*30。如果为真,则与30*30的1进行比较;如果为假,则与30*30的0进行比较。如下图所示:

cycleGAN算法解读_第4张图片

Generator和Discriminator网络结构如下:

cycleGAN算法解读_第5张图片

Loss组成:

由Generator的loss和Discriminator的loss两部分组成。

Generator部分的loss:

Loss_G_A = D_A(G_A(A)), #从G的角度生成的B要让D尽量判断为1

Loss_G_B = D_B(G_B(B)), #从G的角度生成的A要让D尽量判断为1

Loss_cycle_A = || G_B(G_A(A)) - A||

Loss_cycle_B = || G_A(G_B(B)) - B||

Loss_idt_A = ||G_A(B) - B||

Loss_idt_B = ||G_B(A) - A||

Loss_G = Loss_G_A + Loss_G_B + Loss_cycle_A + Loss_cycle_B + Loss_idt_A + Loss_idt_B

Discriminator部分的loss:

Loss_D = criterionGAN (netD(real), true) + criterionGAN(netD(fake), false)

从D的角度,G生成的要尽量判断为0,真实的要尽量判断为1。

 5 代码解读

(1)前向传播部分:

NetG_A就是G,完成A->B的风格转换(源域到目标域)

NetG_B就是F,完成B->A的风格转换(目标域到源域)   

 def forward(self):

        """Run forward pass; called by both functions  and ."""

        self.fake_B = self.netG_A(self.real_A)  # G_A(A)

        self.rec_A = self.netG_B(self.fake_B)   # G_B(G_A(A))

        self.fake_A = self.netG_B(self.real_B)  # G_B(B)

        self.rec_B = self.netG_A(self.fake_A)   # G_A(G_B(B))

(2)更新G

在if lambda_idt > 0:这个分支内,实现的就是identity loss。

后面就是GAN损失(loss_G_A、 loss_G_B)以及循环一致性损失(loss_cycle_A、loss_cycle_B)

代码里面的判别器netD_A判断的是真实B风格和生成B风格的真假,相当于论文中的Dy。

同理netD_B判断的是真实A风格和生成A风格的真假,相当于论文中的Dx。   

 def backward_G(self):

        """Calculate the loss for generators G_A and G_B"""

        lambda_idt = self.opt.lambda_identity

        lambda_A = self.opt.lambda_A

        lambda_B = self.opt.lambda_B

        # Identity loss

        if lambda_idt > 0:

            # G_A should be identity if real_B is fed: ||G_A(B) - B||

            self.idt_A = self.netG_A(self.real_B)  #将真实的B送入netG_A(A->B风格生成器)生成的应该还是B风格

            self.loss_idt_A = self.criterionIdt(self.idt_A, self.real_B) * lambda_B * lambda_idt

            # G_B should be identity if real_A is fed: ||G_B(A) - A||

            self.idt_B = self.netG_B(self.real_A) #将真实的A送入netG_B(B->A风格生成器)生成的应该还是A风格

            self.loss_idt_B = self.criterionIdt(self.idt_B, self.real_A) * lambda_A * lambda_idt

        else:

            self.loss_idt_A = 0

            self.loss_idt_B = 0



        # GAN loss D_A(G_A(A))

        self.loss_G_A = self.criterionGAN(self.netD_A(self.fake_B), True)

        # GAN loss D_B(G_B(B))

        self.loss_G_B = self.criterionGAN(self.netD_B(self.fake_A), True)

        # Forward cycle loss || G_B(G_A(A)) - A||

        self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * lambda_A

        # Backward cycle loss || G_A(G_B(B)) - B||

        self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * lambda_B

        # combined loss and calculate gradients

        self.loss_G = self.loss_G_A + self.loss_G_B + self.loss_cycle_A + self.loss_cycle_B + self.loss_idt_A + self.loss_idt_B

        self.loss_G.backward()

(3)更新D:

  

  def backward_D_A(self):

        """Calculate GAN loss for discriminator D_A"""

        fake_B = self.fake_B_pool.query(self.fake_B)

        self.loss_D_A = self.backward_D_basic(self.netD_A, self.real_B, fake_B)



    def backward_D_B(self):

        """Calculate GAN loss for discriminator D_B"""

        fake_A = self.fake_A_pool.query(self.fake_A)

        self.loss_D_B = self.backward_D_basic(self.netD_B, self.real_A, fake_A)

(4)生成器结构

cycleGAN算法解读_第6张图片

一共由3个卷积层 + 5个残差块 + 3个卷积层构成。

这里没有用到池化等操作,在开始卷积层中(第二层、第三层)进行了下采样,在最后的3个卷积层中进行了上采样,这样最直接的就是减少了计算复杂度。另外还有一个好处是感受野增大,卷积下采样会增大有效区域。

5个残差块都是使用相同个数的(128)滤镜核,每个残差块中都有2个卷积层(3*3核),这里的卷积层中没有标准的0填充(padding),因为使用0填充会使生成出的图像的边界出现严重伪影。为了保证输入输出图像大小不改变,在图像初始输入部分加入了反射填充。

这里的残差网络不是使用何凯明的残差网络,卷积之后没有Relu,而是使用了Gross and Wilber的残差网络,后面这种方法验证在图像分类算法上面效果比较好。

你可能感兴趣的:(神经网络,计算机视觉,人工智能)