CycleGAN论文解读及代码实现

paper: https://arxiv.org/pdf/1703.10593.pdf
github: https://github.com/aitorzip/PyTorch-CycleGAN

1 cycleGAN 小结

网络：
生成器2个：G_A，G_B
判别器两个： D_A，D_B
损失函数8个
6个生成器损失函数
2个判别器损失函数

1.1 数据

fake_B
原始A，经过生成器G_A，生成fake_B
A->G_A = fake_B
rec_A
原始A，经过生成器G_A，生成fake_B，再经过生成器G_B，生成重构数据rec_A
A->G_A ->G_B = rec_A
fake_A
B->G_B = fake_A
原始B，经过生成器G_B，生成fake_A
rec_B
B->G_B ->G_A = rec_B
原始B，经过生成器G_B，生成fake_A，再经过生成器G_A，生成重构数据rec_B

1.2 损失函数

6个生成器损失，2个判别器损失
1）6个生成器损失：

生成器一致损失 2个
数据B经过生成器G_A，后生成的B,与原始B距离最小。A同理
① B-> G_A->B’ : 使得B 与B’距离最小
② A-> F_B->A’ : 使得A 与A’距离最小
生成器损失 2个
生成器生成的数据，让判别器都判别为真
③ MSELoss(D_A(fake_B), True)
④ MSELoss(D_B(fake_A), True)
循环一致损失 2个
⑤ 原始A，经过生成器G_A，生成fake_B，再经过生成器G_B，生成重构数据rec_A
A->G_A ->G_B = rec_A
⑥原始B，经过生成器G_B，生成fake_A，再经过生成器G_A，生成重构数据rec_B
B->G_B ->G_A = rec_B

2） 2个判别器损失

判别器损失 2个
使真实图片为判别为真，假图片判别为假
① D_A
pred_real = D_A(real); pred_fake= D_A(fake)
MSELoss(pred_real, True)+MSELoss(pred_fake, False)
②D_B
pred_real = D_B(real); pred_fake= D_B(fake)
MSELoss(pred_real, True)+MSELoss(pred_fake, False)

2 模型架构

两个生成网络：
G: X——> Y ，输入X生成Y
F: Y——> X :输入Y生成X
两个判别网络：
D_A: 用于区分真实A和 F(B)生成的假A.
D_B:用于区分真实B和 G(A)生成的假B.

在这里插入图片描述

3 损失函数

3.1 Adversarial Loss

对抗损失：

对于生成器 G: X——> Y
生成器G_X：最小化以下目标函数
对于判别器D_Y：最大化以下目标函数
对于生成器 F: Y——> X，损失函数同上
生成器F_Y,使判别器D_X判断为真
对于判别器D_X：是真实X判断为真，F_Y生成的X,判断为假。
$L_{GAN}(F,D_X,Y,X)$

3.2 Cycle Consistency Loss

循环一致损失，即 X 经过生成器G_x后得到Y，Y再过F_Y生成X,使得前后生成的X距离最小。
1）前向一致损失
即从x 经过网络后还原为x的过程
$X - > G (x) - > F (G (x)) = X$

2）反向一致损失
即y从经过网络后还原为y的过程
$Y - > F (y) - > G (F (y)) = Y$

在这里插入图片描述

3.3 Full Objective

在这里插入图片描述

4 代码实现

4.1网络结构

1 生成器A ：
netG_A：可以选用resnet,或者unet网络
输入数据A，生成数据B

self.netG_A = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.norm,
                                        not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)

2 生成器B：
netG_B：与netG_A网络一样
输入数据B，生成数据A

 self.netG_B = networks.define_G(opt.output_nc, opt.input_nc, opt.ngf, opt.netG, opt.norm,
                                        not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)

3 判别器A

self.netD_A = networks.define_D(opt.output_nc, opt.ndf, opt.netD,
                                            opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)

4 判别器B

 self.netD_B = networks.define_D(opt.input_nc, opt.ndf, opt.netD,
                                            opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)

5 损失

5.1 前向传播数据

self.fake_B
原始A，经过生成器G_A，生成fake_B
A->G_A = fake_B
self.rec_A
原始A，经过生成器G_A，生成fake_B，再经过生成器G_B，生成重构数据rec_A
A->G_A ->G_B = rec_A
self.fake_A
B->G_B = fake_A
原始B，经过生成器G_B，生成fake_A
self.rec_B
B->G_B ->G_A = rec_B
原始B，经过生成器G_B，生成fake_A，再经过生成器G_A，生成重构数据rec_B

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))

5.2 生成器一致损失

数据B经过生成器G_A，后生成的B,与原始B距离最小。
B-> G_A->B’ : 使得B 与B’距离最小
A-> F_B->A’ : 使得A 与A’距离最小

self.idt_A = self.netG_A(self.real_B)
self.loss_idt_A= self.L1Loss(self.idt_A, self.real_B)

self.idt_B = self.netG_B(self.real_A)
self.loss_idt_B = self.L1Loss(self.idt_B, self.real_A)

5.2 生成器损失

生成器生成的数据，让判别器都判别为真

（备注：判别器输出不是一个值，而是一个矩阵，需要使判别器输出矩阵每一个值都接近1）

# GAN loss D_A(G_A(A))
self.loss_G_A = self.MSELoss(self.netD_A(self.fake_B), True)
# GAN loss D_B(G_B(B))
self.loss_G_B = self.criterioMSELossGAN(self.netD_B(self.fake_A), True)

5.3 循环一致损失

使得重构的A与原始A距离最近，使用L1Loss

self.rec_A
原始A，经过生成器G_A，生成fake_B，再经过生成器G_B，生成重构数据rec_A
A->G_A ->G_B = rec_A
self.rec_B
B->G_B ->G_A = rec_B
原始B，经过生成器G_B，生成fake_A，再经过生成器G_A，生成重构数据rec_B

# Forward cycle loss || G_B(G_A(A)) - A||
self.loss_cycle_A = self.L1Loss(self.rec_A, self.real_A) 
# Backward cycle loss || G_A(G_B(B)) - B||
self.loss_cycle_B = self.L1Loss(self.rec_B, self.real_B)

5.4 生成器总loss

上面6个生成器损失求和即为总的生成损失函数

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

5.5 判别器损失

判别器：使真实图片为判别为真，假图片判别为假

pred_real = netD(real)
loss_D_real = self.MSELoss(pred_real, True)
# Fake
pred_fake = netD(fake.detach())
loss_D_fake = self.MSELoss(pred_fake, False)
# Combined loss and calculate gradients
loss_D = (loss_D_real + loss_D_fake) * 0.5

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/65903.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！