训练的代码见于train.py，首先定义好网络，两个生成器A2B, B2A和两个判别器A, B，以及对应的优化器(优化器的设置保证了只更新生成器或判别器，不会互相影响)
###### Definition of variables #######Networks
netG_A2B =Generator(opt.input_nc, opt.output_nc)
netG_B2A=Generator(opt.output_nc, opt.input_nc)
netD_A=Discriminator(opt.input_nc)
netD_B= Discriminator(opt.output_nc)
#Optimizers & LR schedulers
optimizer_G =torch.optim.Adam(itertools.chain(netG_A2B.parameters(), netG_B2A.parameters()),
lr=opt.lr, betas=(0.5, 0.999))
optimizer_D_A= torch.optim.Adam(netD_A.parameters(), lr=opt.lr, betas=(0.5, 0.999))
optimizer_D_B= torch.optim.Adam(netD_B.parameters(), lr=opt.lr, betas=(0.5, 0.999))
然后是数据
#Dataset loader
transforms_ = [ transforms.Resize(int(opt.size*1.12), Image.BICUBIC),
transforms.RandomCrop(opt.size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5)) ]
dataloader= DataLoader(ImageDataset(opt.dataroot, transforms_=transforms_, unaligned=True),
batch_size=opt.batchSize, shuffle=True, num_workers=opt.n_cpu)
接着就可以求取损失，反传梯度，更新网络，更新网络的时候首先更新生成器，然后分别更新两个判别器
生成器：损失函数=身份损失+对抗损失+循环一致损失
###### Generators A2B and B2A ######
optimizer_G.zero_grad()#Identity loss
#G_A2B(B) should equal B if real B is fed
same_B =netG_A2B(real_B)
loss_identity_B= criterion_identity(same_B, real_B)*5.0
#G_B2A(A) should equal A if real A is fed
same_A =netG_B2A(real_A)
loss_identity_A= criterion_identity(same_A, real_A)*5.0
#GAN loss
fake_B =netG_A2B(real_A)
pred_fake=netD_B(fake_B)
loss_GAN_A2B=criterion_GAN(pred_fake, target_real)
fake_A=netG_B2A(real_B)
pred_fake=netD_A(fake_A)
loss_GAN_B2A=criterion_GAN(pred_fake, target_real)#Cycle loss
recovered_A =netG_B2A(fake_B)
loss_cycle_ABA= criterion_cycle(recovered_A, real_A)*10.0recovered_B=netG_A2B(fake_A)
loss_cycle_BAB= criterion_cycle(recovered_B, real_B)*10.0
#Total loss
loss_G = loss_identity_A + loss_identity_B + loss_GAN_A2B + loss_GAN_B2A + loss_cycle_ABA +loss_cycle_BAB
loss_G.backward()
optimizer_G.step()
判别器A 损失函数= 真实样本分类损失 + 虚假样本分类损失
###### Discriminator A ######
optimizer_D_A.zero_grad()#Real loss
pred_real =netD_A(real_A)
loss_D_real=criterion_GAN(pred_real, target_real)#Fake loss
fake_A =fake_A_buffer.push_and_pop(fake_A)
pred_fake=netD_A(fake_A.detach())
loss_D_fake=criterion_GAN(pred_fake, target_fake)#Total loss
loss_D_A = (loss_D_real + loss_D_fake)*0.5loss_D_A.backward()
optimizer_D_A.step()###################################
判别器B损失函数= 真实样本分类损失 + 虚假样本分类损失
###### Discriminator B ######
optimizer_D_B.zero_grad()#Real loss
pred_real =netD_B(real_B)
loss_D_real=criterion_GAN(pred_real, target_real)#Fake loss
fake_B =fake_B_buffer.push_and_pop(fake_B)
pred_fake=netD_B(fake_B.detach())
loss_D_fake=criterion_GAN(pred_fake, target_fake)#Total loss
loss_D_B = (loss_D_real + loss_D_fake)*0.5loss_D_B.backward()
optimizer_D_B.step()###################################
可以注意到，判别器损失中，虚假样本fake_A，fake_B都采用detach()操作，脱离计算图，这样判别器的损失进行反向传播不会对整个网络计算梯度，避免了不必要的计算
)
