""" continuous_munit_cyclepoint_residual.py This is CoMo-MUNIT *logic*, so how the network is trained. """ import math import torch import itertools from .base_model import BaseModel from .backbones import comomunit as networks import random import munch def ModelOptions(): mo = munch.Munch() # Generator mo.gen_dim = 64 mo.style_dim = 8 mo.gen_activ = 'relu' mo.n_downsample = 2 mo.n_res = 4 mo.gen_pad_type = 'reflect' mo.mlp_dim = 256 # Discriminiator mo.disc_dim = 64 mo.disc_norm = 'none' mo.disc_activ = 'lrelu' mo.disc_n_layer = 4 mo.num_scales = 3 # TODO change for other experiments! mo.disc_pad_type = 'reflect' # Initialization mo.init_type_gen = 'kaiming' mo.init_type_disc = 'normal' mo.init_gain = 0.02 # Weights mo.lambda_gan = 1 mo.lambda_rec_image = 10 mo.lambda_rec_style = 1 mo.lambda_rec_content = 1 mo.lambda_rec_cycle = 10 mo.lambda_vgg = 0.1 mo.lambda_idt = 1 mo.lambda_Phinet_A = 1 # Continuous settings mo.resblocks_cont = 1 mo.lambda_physics = 10 mo.lambda_compare = 10 mo.lambda_physics_compare = 1 return mo class CoMoMUNITModel(BaseModel): def __init__(self, opt): BaseModel.__init__(self, opt) # specify the training losses you want to print out. The training/test scripts will call self.loss_names = ['D_A', 'G_A', 'cycle_A', 'rec_A', 'rec_style_B', 'rec_content_A', 'vgg_A', 'phi_net_A', 'D_B', 'G_B', 'cycle_B', 'rec_B', 'rec_style_A', 'rec_content_B', 'vgg_B', 'idt_B', 'recon_physics', 'phi_net'] # specify the images you want to save/display. The training/test scripts will call visual_names_A = ['x', 'y', 'rec_A_img', 'rec_A_cycle', 'y_M_tilde', 'y_M'] visual_names_B = ['y_tilde', 'fake_A', 'rec_B_img', 'rec_B_cycle', 'idt_B_img'] self.visual_names = visual_names_A + visual_names_B # combine visualizations for A and B # specify the models you want to save to the disk. The training/test scripts will call and . self.model_names = ['G_A', 'D_A', 'G_B', 'D_B', 'DRB', 'Phi_net', 'Phi_net_A'] self.netG_A = networks.define_G_munit(opt.input_nc, opt.output_nc, opt.gen_dim, opt.style_dim, opt.n_downsample, opt.n_res, opt.gen_pad_type, opt.mlp_dim, opt.gen_activ, opt.init_type_gen, opt.init_gain, self.gpu_ids) self.netG_B = networks.define_G_munit(opt.output_nc, opt.input_nc, opt.gen_dim, opt.style_dim, opt.n_downsample, opt.n_res, opt.gen_pad_type, opt.mlp_dim, opt.gen_activ, opt.init_type_gen, opt.init_gain, self.gpu_ids) self.netDRB = networks.define_DRB_munit(opt.resblocks_cont, opt.gen_dim * (2 ** opt.n_downsample), 'instance', opt.gen_activ, opt.gen_pad_type, opt.init_type_gen, opt.init_gain, self.gpu_ids) # define discriminators self.netD_A = networks.define_D_munit(opt.output_nc, opt.disc_dim, opt.disc_norm, opt.disc_activ, opt.disc_n_layer, opt.gan_mode, opt.num_scales, opt.disc_pad_type, opt.init_type_disc, opt.init_gain, self.gpu_ids) self.netD_B = networks.define_D_munit(opt.input_nc, opt.disc_dim, opt.disc_norm, opt.disc_activ, opt.disc_n_layer, opt.gan_mode, opt.num_scales, opt.disc_pad_type, opt.init_type_disc, opt.init_gain, self.gpu_ids) # We use munit style encoder as phinet/phinet_A self.netPhi_net = networks.init_net(networks.StyleEncoder(4, opt.input_nc * 2, opt.gen_dim, 2, norm='instance', activ='lrelu', pad_type=opt.gen_pad_type), init_type=opt.init_type_gen, init_gain = opt.init_gain, gpu_ids = opt.gpu_ids) self.netPhi_net_A = networks.init_net(networks.StyleEncoder(4, opt.input_nc, opt.gen_dim, 1, norm='instance', activ='lrelu', pad_type=opt.gen_pad_type), init_type=opt.init_type_gen, init_gain = opt.init_gain, gpu_ids = opt.gpu_ids) # define loss functions self.reconCriterion = torch.nn.L1Loss() self.criterionPhysics = torch.nn.L1Loss() self.criterionIdt = torch.nn.L1Loss() # initialize optimizers; schedulers will be automatically created by function . if opt.lambda_vgg > 0: self.instance_norm = torch.nn.InstanceNorm2d(512) self.vgg = networks.Vgg16() self.vgg.load_state_dict(torch.load('res/vgg_imagenet.pth')) self.vgg.eval() for param in self.vgg.parameters(): param.requires_grad = False def configure_optimizers(self): opt_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters(), self.netDRB.parameters(), self.netPhi_net.parameters(), self.netPhi_net_A.parameters()), weight_decay=0.0001, lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) opt_D = torch.optim.Adam(itertools.chain(self.netD_A.parameters(), self.netD_B.parameters()), weight_decay=0.0001, lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) scheduler_G = self.get_scheduler(self.opt, opt_G) scheduler_D = self.get_scheduler(self.opt, opt_D) return [opt_D, opt_G], [scheduler_D, scheduler_G] def set_input(self, input): # Input image. everything is mixed so we only have one style self.x = input['A'] # Paths just because maybe they are needed self.image_paths = input['A_paths'] # Desired continuity value which is used to render self.y_M_tilde # Desired continuity value which is used to render self.y_M_tilde self.phi = input['phi'].float() self.cos_phi = input['cos_phi'].float() self.sin_phi = input['sin_phi'].float() # Term used to train SSN self.phi_prime = input['phi_prime'].float() self.cos_phi_prime = input['cos_phi_prime'].float() self.sin_phi_prime = input['sin_phi_prime'].float() # physical model applied to self.x with continuity self.continuity self.y_M_tilde = input['A_cont'] # physical model applied to self.x with continuity self.continuity_compare self.y_M_tilde_prime = input['A_cont_compare'] # Other image, in reality the two will belong to the same domain self.y_tilde = input['B'] def __vgg_preprocess(self, batch): tensortype = type(batch) (r, g, b) = torch.chunk(batch, 3, dim=1) batch = torch.cat((b, g, r), dim=1) # convert RGB to BGR batch = (batch + 1) * 255 * 0.5 # [-1, 1] -> [0, 255] mean = tensortype(batch.data.size()).to(self.device) mean[:, 0, :, :] = 103.939 mean[:, 1, :, :] = 116.779 mean[:, 2, :, :] = 123.680 batch = batch.sub(mean) # subtract mean return batch def __compute_vgg_loss(self, img, target): img_vgg = self.__vgg_preprocess(img) target_vgg = self.__vgg_preprocess(target) img_fea = self.vgg(img_vgg) target_fea = self.vgg(target_vgg) return torch.mean((self.instance_norm(img_fea) - self.instance_norm(target_fea)) ** 2) def forward(self, img, phi = None, style_B_fake = None): """Run forward pass; called by both functions and .""" # Random style sampling if style_B_fake is None: style_B_fake = torch.randn(img.size(0), self.opt.style_dim, 1, 1).to(self.device) if phi is None: phi = torch.zeros(1).fill_(random.random()).to(self.device) * math.pi * 2 self.cos_phi = torch.cos(phi) self.sin_phi = torch.sin(phi) # Encoding self.content_A, self.style_A_real = self.netG_A.encode(img) features_A = self.netG_B.assign_adain(self.content_A, style_B_fake) features_A_real, features_A_physics = self.netDRB(features_A, self.cos_phi, self.sin_phi) fake_B = self.netG_B.decode(features_A_real) return fake_B def training_step_D(self): with torch.no_grad(): # Random style sampling self.style_A_fake = torch.randn(self.x.size(0), self.opt.style_dim, 1, 1).to(self.device) self.style_B_fake = torch.randn(self.y_tilde.size(0), self.opt.style_dim, 1, 1).to(self.device) self.content_A, self.style_A_real = self.netG_A.encode(self.x) features_A = self.netG_B.assign_adain(self.content_A, self.style_B_fake) features_A_real, features_A_physics = self.netDRB(features_A, self.cos_phi, self.sin_phi) self.y = self.netG_B.decode(features_A_real) # Encoding self.content_B, self.style_B_real = self.netG_B.encode(self.y_tilde) features_B = self.netG_A.assign_adain(self.content_B, self.style_A_fake) features_B_real, _ = self.netDRB(features_B, torch.ones(self.cos_phi.size()).to(self.device), torch.zeros(self.sin_phi.size()).to(self.device) ) self.fake_A = self.netG_A.decode(features_B_real) self.loss_D_A = self.netD_A.calc_dis_loss(self.y, self.y_tilde) * self.opt.lambda_gan self.loss_D_B = self.netD_B.calc_dis_loss(self.fake_A, self.x) * self.opt.lambda_gan loss_D = self.loss_D_A + self.loss_D_B return loss_D def phi_loss_fn(self): # the distance between the generated image and the image at the output of the # physical model should be zero input_zerodistance = torch.cat((self.y, self.y_M_tilde), dim = 1) # Distance between generated image and other image of the physical model should be # taken from the ground truth value input_normaldistance = torch.cat((self.y, self.y_M_tilde_prime), dim = 1) # same for this, but this does not depend on a GAN generation so it's used as a regularization term input_regolarize = torch.cat((self.y_M_tilde, self.y_M_tilde_prime), dim = 1) # essentailly, ground truth distance given by the physical model renderings # Cosine distance, we are trying to encode cyclic stuff distance_cos = (torch.cos(self.phi) - torch.cos(self.phi_prime)) / 2 distance_sin = (torch.sin(self.phi) - torch.sin(self.phi_prime)) / 2 # We evaluate the angle distance and we normalize it in -1/1 output_zerodistance = torch.tanh(self.netPhi_net(input_zerodistance))#[0]) output_normaldistance = torch.tanh(self.netPhi_net(input_normaldistance))#[0]) output_regolarize = torch.tanh(self.netPhi_net(input_regolarize))#[0]) loss_cos = torch.pow(output_zerodistance[:, 0] - 0, 2).mean() loss_cos += torch.pow(output_normaldistance[:, 0] - distance_cos, 2).mean() loss_cos += torch.pow(output_regolarize[:, 0] - distance_cos, 2).mean() loss_sin = torch.pow(output_zerodistance[:, 1] - 0, 2).mean() loss_sin += torch.pow(output_normaldistance[:, 1] - distance_sin, 2).mean() loss_sin += torch.pow(output_regolarize[:, 1] - distance_sin, 2).mean() # additional terms on the other image generated by the GAN, i.e. something that should resemble exactly # the image generated by the physical model # This terms follow the same reasoning as before and weighted differently input_physics_zerodistance = torch.cat((self.y_M, self.y_M_tilde), dim = 1) input_physics_regolarize = torch.cat((self.y_M, self.y_M_tilde_prime), dim = 1) output_physics_zerodistance = torch.tanh(self.netPhi_net(input_physics_zerodistance))#[0]) output_physics_regolarize = torch.tanh(self.netPhi_net(input_physics_regolarize))#[0]) loss_cos += torch.pow(output_physics_zerodistance[:, 0] - 0, 2).mean() * self.opt.lambda_physics_compare loss_cos += torch.pow(output_physics_regolarize[:, 0] - distance_cos, 2).mean() * self.opt.lambda_physics_compare loss_sin += torch.pow(output_physics_zerodistance[:, 1] - 0, 2).mean() * self.opt.lambda_physics_compare loss_sin += torch.pow(output_physics_regolarize[:, 1] - distance_sin, 2).mean() * self.opt.lambda_physics_compare # Also distance between the two outputs of the gan should be 0 input_twoheads = torch.cat((self.y_M, self.y), dim = 1) output_twoheads = torch.tanh(self.netPhi_net(input_twoheads))#[0]) loss_cos += torch.pow(output_twoheads[:, 0] - 0, 2).mean() loss_sin += torch.pow(output_twoheads[:, 1] - 0, 2).mean() loss = loss_cos + loss_sin * 0.5 return loss def training_step_G(self): self.style_B_fake = torch.randn(self.y_tilde.size(0), self.opt.style_dim, 1, 1).to(self.device) self.style_A_fake = torch.randn(self.x.size(0), self.opt.style_dim, 1, 1).to(self.device) self.content_A, self.style_A_real = self.netG_A.encode(self.x) self.content_B, self.style_B_real = self.netG_B.encode(self.y_tilde) self.phi_est = torch.sigmoid(self.netPhi_net_A.forward(self.y_tilde).view(self.y_tilde.size(0), -1)).view(self.y_tilde.size(0)) * 2 * math.pi self.estimated_cos_B = torch.cos(self.phi_est) self.estimated_sin_B = torch.sin(self.phi_est) # Reconstruction features_A_reconstruction = self.netG_A.assign_adain(self.content_A, self.style_A_real) features_A_reconstruction, _ = self.netDRB(features_A_reconstruction, torch.ones(self.estimated_cos_B.size()).to(self.device), torch.zeros(self.estimated_sin_B.size()).to(self.device)) self.rec_A_img = self.netG_A.decode(features_A_reconstruction) features_B_reconstruction = self.netG_B.assign_adain(self.content_B, self.style_B_real) features_B_reconstruction, _ = self.netDRB(features_B_reconstruction, self.estimated_cos_B, self.estimated_sin_B) self.rec_B_img = self.netG_B.decode(features_B_reconstruction) # Cross domain features_A = self.netG_B.assign_adain(self.content_A, self.style_B_fake) features_A_real, features_A_physics = self.netDRB(features_A, self.cos_phi, self.sin_phi) self.y_M = self.netG_B.decode(features_A_physics) self.y = self.netG_B.decode(features_A_real) features_B = self.netG_A.assign_adain(self.content_B, self.style_A_fake) features_B_real, _ = self.netDRB(features_B, torch.ones(self.cos_phi.size()).to(self.device), torch.zeros(self.sin_phi.size()).to(self.device)) self.fake_A = self.netG_A.decode(features_B_real) self.rec_content_B, self.rec_style_A = self.netG_A.encode(self.fake_A) self.rec_content_A, self.rec_style_B = self.netG_B.encode(self.y) if self.opt.lambda_rec_cycle > 0: features_A_reconstruction_cycle = self.netG_A.assign_adain(self.rec_content_A, self.style_A_real) features_A_reconstruction_cycle, _ = self.netDRB(features_A_reconstruction_cycle, torch.ones(self.cos_phi.size()).to(self.device), torch.zeros(self.sin_phi.size()).to(self.device)) self.rec_A_cycle = self.netG_A.decode(features_A_reconstruction_cycle) features_B_reconstruction_cycle = self.netG_B.assign_adain(self.rec_content_B, self.style_B_real) features_B_reconstruction_cycle, _ = self.netDRB(features_B_reconstruction_cycle, self.estimated_cos_B, self.estimated_sin_B) self.rec_B_cycle = self.netG_B.decode(features_B_reconstruction_cycle) if self.opt.lambda_idt > 0: features_B_identity = self.netG_B.assign_adain(self.content_A, torch.randn(self.style_B_fake.size()).to(self.device)) features_B_identity, _ = self.netDRB(features_B_identity, torch.ones(self.estimated_cos_B.size()).to(self.device), torch.zeros(self.estimated_sin_B.size()).to(self.device)) self.idt_B_img = self.netG_B.decode(features_B_identity) if self.opt.lambda_idt > 0: self.loss_idt_A = 0 self.loss_idt_B = self.criterionIdt(self.idt_B_img, self.x) * self.opt.lambda_gan * self.opt.lambda_idt else: self.loss_idt_A = 0 self.loss_idt_B = 0 continuity_angle_fake = torch.sigmoid(self.netPhi_net_A.forward(self.y).view(self.y_tilde.size(0), -1)).view(self.y_tilde.size(0)) * 2 * math.pi continuity_cos_fake = 1 - ((torch.cos(continuity_angle_fake) + 1) / 2) continuity_cos_gt = 1 - ((torch.cos(self.phi) + 1) / 2) continuity_sin_fake = 1 - ((torch.sin(continuity_angle_fake) + 1) / 2) continuity_sin_gt = 1 - ((torch.sin(self.phi) + 1) / 2) distance_cos_fake = (continuity_cos_fake - continuity_cos_gt) distance_sin_fake = (continuity_sin_fake - continuity_sin_gt) self.loss_phi_net_A = (distance_cos_fake ** 2) * self.opt.lambda_Phinet_A self.loss_phi_net_A += (distance_sin_fake ** 2) * self.opt.lambda_Phinet_A self.loss_rec_A = self.reconCriterion(self.rec_A_img, self.x) * self.opt.lambda_rec_image self.loss_rec_B = self.reconCriterion(self.rec_B_img, self.y_tilde) * self.opt.lambda_rec_image self.loss_rec_style_B = self.reconCriterion(self.rec_style_B, self.style_B_fake) * self.opt.lambda_rec_style self.loss_rec_style_A = self.reconCriterion(self.rec_style_A, self.style_A_fake) * self.opt.lambda_rec_style self.loss_rec_content_A = self.reconCriterion(self.rec_content_A, self.content_A) * self.opt.lambda_rec_content self.loss_rec_content_B = self.reconCriterion(self.rec_content_B, self.content_B) * self.opt.lambda_rec_content if self.opt.lambda_rec_cycle > 0: self.loss_cycle_A = self.reconCriterion(self.rec_A_cycle, self.x) * self.opt.lambda_rec_cycle self.loss_cycle_B = self.reconCriterion(self.rec_B_cycle, self.y_tilde) * self.opt.lambda_rec_cycle else: self.loss_cycle_A = 0 self.loss_G_A = self.netD_A.calc_gen_loss(self.y) * self.opt.lambda_gan self.loss_G_B = self.netD_B.calc_gen_loss(self.fake_A) * self.opt.lambda_gan self.loss_recon_physics = self.opt.lambda_physics * self.criterionPhysics(self.y_M, self.y_M_tilde) self.loss_phi_net = self.phi_loss_fn() * self.opt.lambda_compare if self.opt.lambda_vgg > 0: self.loss_vgg_A = self.__compute_vgg_loss(self.fake_A, self.y_tilde) * self.opt.lambda_vgg self.loss_vgg_B = self.__compute_vgg_loss(self.y, self.x) * self.opt.lambda_vgg else: self.loss_vgg_A = 0 self.loss_vgg_B = 0 self.loss_G = self.loss_rec_A + self.loss_rec_style_B + self.loss_rec_content_A + \ self.loss_cycle_A + self.loss_G_B + self.loss_vgg_A + \ self.loss_rec_B + self.loss_rec_style_A + self.loss_rec_content_B + \ self.loss_cycle_B + self.loss_G_A + self.loss_vgg_B + \ self.loss_recon_physics + self.loss_phi_net + self.loss_idt_B + self.loss_phi_net_A return self.loss_G def training_step(self, batch, batch_idx, optimizer_idx): self.set_input(batch) if optimizer_idx == 0: self.set_requires_grad([self.netD_A, self.netD_B], True) self.set_requires_grad([self.netG_A, self.netG_B], False) return self.training_step_D() elif optimizer_idx == 1: self.set_requires_grad([self.netD_A, self.netD_B], False) # Ds require no gradients when optimizing Gs self.set_requires_grad([self.netG_A, self.netG_B], True) return self.training_step_G()