def initialize(self, opt): BaseModel.initialize(self, opt) self.is_Train = opt.is_Train self.G = Generator(N_p=opt.N_p, N_z=opt.N_z) self.D = Discriminator(N_p=opt.N_p, N_d=opt.N_d) if self.is_Train: self.optimizer_G = optim.Adam(self.G.parameters(), lr=opt.lr_G, betas=(opt.beta1, opt.beta2)) self.optimizer_D = optim.Adam(self.D.parameters(), lr=opt.lr_D, betas=(opt.beta1, opt.beta2)) self.criterion = nn.CrossEntropyLoss() self.L1_criterion = nn.L1Loss() self.w_L1 = opt.w_L1 self.N_z = opt.N_z self.N_p = opt.N_p self.N_d = opt.N_d import torchvision.models as models self.resnet18 = models.resnet18(pretrained=True) if self.gpu_ids: self.resnet18 = self.resnet18.cuda() self.resnet18.fc = torch.nn.LeakyReLU(0.1) for param in self.resnet18.parameters(): param.requires_grad = False self.resnet18.eval() torch.set_num_threads(1)
def initialize(self, opt): BaseModel.initialize(self, opt) self.is_Train = opt.is_Train self.G = Generator(N_p=opt.N_p, N_z=opt.N_z,single = True) self.D = Discriminator(N_p=opt.N_p, N_d=opt.N_d) if self.is_Train: self.optimizer_G = optim.Adam(self.G.parameters(), lr=opt.lr_G, betas=(opt.beta1, opt.beta2)) self.optimizer_D = optim.Adam(self.D.parameters(), lr=opt.lr_D, betas=(opt.beta1, opt.beta2)) self.criterion = nn.CrossEntropyLoss() self.L1_criterion = nn.L1Loss() self.w_L1 = opt.w_L1 self.N_z = opt.N_z self.N_p = opt.N_p self.N_d = opt.N_d
def initialize(self, opt): BaseModel.initialize(self, opt) self.isTrain = opt.isTrain # define tensors # self.Tensor is torch.cuda.Tensor if gpu_ids is defined, otherwise use torch.FloatTensor self.input_A = self.Tensor(opt.batchSize, opt.input_nc, opt.fineSize, opt.fineSize).cuda(device=opt.gpu_ids[0]) self.input_B = self.Tensor(opt.batchSize, opt.output_nc, opt.fineSize, opt.fineSize).cuda(device=opt.gpu_ids[0]) # define networks self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.which_model_netG, opt.norm, opt.use_dropout, self.gpu_ids) if self.isTrain: use_sigmoid = opt.no_lsgan # do not use least square GAN by default self.netD = networks.define_D(opt.input_nc + opt.output_nc, opt.ndf, opt.which_model_netD, opt.n_layers_D, opt.norm, use_sigmoid, self.gpu_ids) # load network if continue training / in test phase if not self.isTrain or opt.continue_train: self.load_network(self.netG, 'G', opt.which_epoch) if self.isTrain: self.load_network(self.netD, 'D', opt.which_epoch) if self.isTrain: self.fake_AB_pool = ImagePool(opt.pool_size) self.old_lr = opt.lr # define loss functions self.criterionGAN = networks.GANLoss(use_lsgan=not opt.no_lsgan, tensor=self.Tensor, gpu_ids=opt.gpu_ids) self.criterionL1 = torch.nn.L1Loss() if opt.use_prcp: self.criterionPrcp = networks.PrcpLoss(opt.weight_path, opt.bias_path, opt.perceptual_level, tensor=self.Tensor, gpu_ids=opt.gpu_ids) # initialize optimizers self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) print('---------- Networks initialized -------------') networks.print_network(self.netG) networks.print_network(self.netD) print('-----------------------------------------------')
def initialize(self, opt): BaseModel.initialize(self, opt) if opt.resize_or_crop != 'none' or not opt.isTrain: # when training at full res this causes OOM torch.backends.cudnn.benchmark = True self.isTrain = opt.isTrain input_nc = opt.label_nc if opt.label_nc != 0 else opt.input_nc ##### define networks # Generator network netG_input_nc = input_nc # Main Generator self.netG = networks.define_G(11, opt.output_nc, opt.ngf, opt.netG, opt.n_downsample_global, opt.n_blocks_global, opt.n_local_enhancers, opt.n_blocks_local, opt.norm, gpu_ids=self.gpu_ids) self.netP = networks.define_P(44, 20, opt.ngf, opt.netG, opt.n_downsample_global, opt.n_blocks_global, opt.n_local_enhancers, opt.n_blocks_local, opt.norm, gpu_ids=self.gpu_ids) self.netP.load_state_dict( torch.load( os.path.dirname(os.path.realpath(__file__)) + "/checkpoints/generate/parse.pth")) # Discriminator network if self.isTrain: use_sigmoid = opt.no_lsgan netD_input_nc = input_nc + opt.output_nc netB_input_nc = opt.output_nc * 2 self.netD = networks.define_D(netD_input_nc, opt.ndf, opt.n_layers_D, opt.norm, use_sigmoid, opt.num_D, not opt.no_ganFeat_loss, gpu_ids=self.gpu_ids) #self.netB = networks.define_B(netB_input_nc, opt.output_nc, 32, 3, 3, opt.norm, gpu_ids=self.gpu_ids) if self.opt.verbose: print('---------- Networks initialized -------------') # load networks if not self.isTrain or opt.continue_train or opt.load_pretrain: pretrained_path = '' if not self.isTrain else opt.load_pretrain self.load_network(self.netG, 'G', opt.which_epoch, pretrained_path) if self.isTrain: self.load_network(self.netD, 'D', opt.which_epoch, pretrained_path) # set loss functions and optimizers if self.isTrain: if opt.pool_size > 0 and (len(self.gpu_ids)) > 1: raise NotImplementedError( "Fake Pool Not Implemented for MultiGPU") self.fake_pool = ImagePool(opt.pool_size) self.old_lr = opt.lr # define loss functions self.loss_filter = self.init_loss_filter(not opt.no_ganFeat_loss, not opt.no_vgg_loss) self.criterionGAN = networks.GANLoss(use_lsgan=not opt.no_lsgan, tensor=self.Tensor) self.criterionFeat = torch.nn.L1Loss() if not opt.no_vgg_loss: self.criterionVGG = networks.VGGLoss(self.gpu_ids) self.criterionStyle = networks.StyleLoss(self.gpu_ids) # Names so we can breakout loss self.loss_names = self.loss_filter('G_GAN', 'G_GAN_Feat', 'G_VGG', 'D_real', 'D_fake') # initialize optimizers # optimizer G if opt.niter_fix_global > 0: import sys if sys.version_info >= (3, 0): finetune_list = set() else: from sets import Set finetune_list = Set() params_dict = dict(self.netG.named_parameters()) params = [] for key, value in params_dict.items(): if key.startswith('model' + str(opt.n_local_enhancers)): params += [value] finetune_list.add(key.split('.')[0]) print( '------------- Only training the local enhancer network (for %d epochs) ------------' % opt.niter_fix_global) print('The layers that are finetuned are ', sorted(finetune_list)) else: params = list(self.netG.parameters())+list(self.netimage.parameters())+list(self.netcolor.parameters())\ +list(self.netlabel.parameters())+list(self.netsketch.parameters())+list(self.classfier.parameters()) # params.extend(list(self.netimage.parameters())) self.optimizer_G = torch.optim.Adam(params, lr=opt.lr, betas=(opt.beta1, 0.999)) # optimizer D params = list(self.netD.parameters()) self.optimizer_D = torch.optim.Adam(params, lr=opt.lr, betas=(opt.beta1, 0.999))
def initialize(self, opt): BaseModel.initialize(self, opt) self.model = opt.model if 'EFG' in self.model: self.which_model = 'EFG' elif 'NFG' in self.model: self.which_model = 'NFG' else: raise ValueError("model %s is not supported." % opt.model) self.input_nc = opt.input_nc self.output_nc = opt.output_nc self.nfg = opt.nfg self.batch_size = opt.batch_size if self.nfg == 128: self.num_downs = 7 elif self.nfg == 64: self.num_downs = 6 else: raise ValueError("Only support nfg = 128 or 64. Got %d" % self.nfg) # configuration of NFG network if opt.isTrain: self.dropout = opt.dropout self.use_sigmoid = False self.norm = functools.partial(nn.BatchNorm2d, affine=True) self.lr_adam = opt.learning_rate_adam self.lr_rmsprop = opt.learning_rate_rmsprop self.lam_cyc = opt.lam_cyc self.lam_l1 = opt.lam_l1 self.lam_idt = opt.lam_idt self.beta1 = opt.beta1 self.beta2 = opt.beta2 self.criterionGAN = nn.MSELoss() self.criterionL1 = nn.L1Loss() # setup input self.input_A = self.Tensor(opt.batch_size, opt.input_nc, opt.img_size, opt.img_size) self.input_B = self.Tensor(opt.batch_size, opt.input_nc, opt.img_size, opt.img_size) if 'EFG' in self.model: self.expression_label = self.Tensor(opt.batch_size, 3, 8, 8) # build up network self.net_G_AtoB = Unet_G2(self.input_nc, self.output_nc, self.which_model, self.nfg, norm_layer=self.norm, use_dropout=self.dropout) self.net_G_BtoA = Unet_G2(self.input_nc, self.output_nc, self.which_model, self.nfg, norm_layer=self.norm, use_dropout=self.dropout) self.net_D_A = NLayerDiscriminator(self.input_nc, norm_layer=self.norm, use_sigmoid=self.use_sigmoid) self.net_D_B = NLayerDiscriminator(self.input_nc, norm_layer=self.norm, use_sigmoid=self.use_sigmoid) if torch.cuda.device_count() > 1: self.net_G_AtoB = nn.DataParallel(self.net_G_AtoB) self.net_G_BtoA = nn.DataParallel(self.net_G_BtoA) self.net_D_A = nn.DataParallel(self.net_D_A) self.net_D_B = nn.DataParallel(self.net_D_B) if torch.cuda.is_available(): print("Using %d GPUS." % torch.cuda.device_count()) self.net_G_AtoB.cuda() self.net_G_BtoA.cuda() self.net_D_A.cuda() self.net_D_B.cuda() # set up optimizer if 'LSGAN' in self.model: self.optimizer_G = torch.optim.Adam( list(self.net_G_AtoB.parameters()) + list(self.net_G_BtoA.parameters()), lr=self.lr_adam, betas=(self.beta1, self.beta2)) self.optimizer_D_A = torch.optim.Adam(self.net_D_A.parameters(), lr=self.lr_adam, betas=(self.beta1, self.beta2)) self.optimizer_D_B = torch.optim.Adam(self.net_D_B.parameters(), lr=self.lr_adam, betas=(self.beta1, self.beta2)) elif 'WGAN' in self.model: self.optimizer_G = torch.optim.RMSprop( list(self.net_G_AtoB.parameters()) + list(self.net_G_BtoA.parameters()), lr=self.lr_rmsprop) self.optimizer_D_A = torch.optim.RMSprop(self.net_D_A.parameters(), lr=self.lr_rmsprop) self.optimizer_D_B = torch.optim.RMSprop(self.net_D_B.parameters(), lr=self.lr_rmsprop) else: raise ValueError('%s is not supported.' % self.model) # save generated images self.out_dir = opt.out_dir + self.model + '/images/' if not os.path.exists(self.out_dir): os.makedirs(self.out_dir) self.out_loss = opt.out_dir + self.model + '/losses/' if not os.path.exists(self.out_loss): os.makedirs(self.out_loss) # initialize loss lists self.loss_G_AGANs = [] self.loss_G_BGANs = [] self.loss_cyc_As = [] self.loss_cyc_Bs = [] self.loss_D_As = [] self.loss_D_Bs = [] print( "initializing completed:\n model name: %s\n input_nc: %s\n use_sigmoid: %s\n" % (self.model, self.input_nc, self.use_sigmoid))
def initialize(self, opt): BaseModel.initialize(self, opt) self.isTrain = opt.isTrain # define tensors self.sparse_input_A = self.Tensor(opt.batchSize, opt.input_nc, opt.sparseSize, opt.sparseSize) self.mask_input_A = self.Tensor(opt.batchSize, 1, opt.fineSize, opt.fineSize) self.input_A = self.Tensor(opt.batchSize, opt.input_nc, opt.fineSize, opt.fineSize) self.input_B = self.Tensor(opt.batchSize, opt.output_nc, opt.fineSize, opt.fineSize) self.label = self.Tensor(opt.batchSize,1) if opt.nz>0: self.noise=self.Tensor(opt.batchSize,opt.nz) self.test_noise= self.get_z_random(opt.num_interpolate,opt.nz) self.test_noise.normal_(0,0.2) # load/define networks opt.which_model_netG = 'GAN_stability_Generator' self.netG = networks_sparse.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.which_model_netG, opt.norm, not opt.no_dropout, opt.init_type, self.gpu_ids,opt) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") if self.isTrain: use_sigmoid = opt.no_lsgan opt.which_model_netD = 'GAN_stability_Discriminator' self.netD = networks_sparse.define_D(opt.input_nc + opt.output_nc, opt.ndf, opt.which_model_netD, opt.n_layers_D, opt.norm, use_sigmoid, opt.init_type, self.gpu_ids,opt) if self.isTrain: self.netD = nn.DataParallel(self.netD) self.netD.to(device) else: self.netD.cuda() if self.isTrain: self.netG = nn.DataParallel(self.netG) self.netG.to(device) else: self.netG.cuda() if not self.isTrain or opt.continue_train: self.load_network(self.netG, 'G', opt.which_epoch) if self.isTrain: self.load_network(self.netD, 'D', opt.which_epoch) if self.isTrain: self.fake_AB_pool = ImagePool(opt.pool_size) self.old_lr = opt.lr # define loss functions self.criterionGAN = WGANLoss(tensor=self.Tensor) self.criterionL1 = torch.nn.L1Loss() # initialize optimizers self.schedulers = [] self.optimizers = [] self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr_g, betas=(opt.beta1, 0.999)) self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr_d, betas=(opt.beta1, 0.999)) self.optimizers.append(self.optimizer_G) self.optimizers.append(self.optimizer_D) for optimizer in self.optimizers: self.schedulers.append(get_scheduler(optimizer, opt)) print('---------- Networks initialized -------------') print_network(self.netG) if self.isTrain: print_network(self.netD) print('-----------------------------------------------')
def initialize(self, opt): BaseModel.initialize(self, opt) self.isTrain = opt.isTrain self.input_A = self.Tensor(opt.batchSize, opt.input_nc, opt.fineSize, opt.fineSize).cuda(device=opt.gpu_ids[0]) self.input_B = self.Tensor(opt.batchSize, opt.output_nc, opt.fineSize, opt.fineSize).cuda(device=opt.gpu_ids[0]) # load/define networks # The naming conversion is different from those used in the paper # Code (paper): G_A (G), G_B (F), D_A (D_Y), D_B (D_X) self.netG_A = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.which_model_netG, opt.norm, opt.use_dropout, self.gpu_ids) self.netG_B = networks.define_G(opt.output_nc, opt.input_nc, opt.ngf, opt.which_model_netG, opt.norm, opt.use_dropout, self.gpu_ids) # If this is training phase if self.isTrain: use_sigmoid = opt.no_lsgan # do not use least square GAN by default self.netD_A = networks.define_D(opt.output_nc, opt.ndf, opt.which_model_netD, opt.n_layers_D, opt.norm, use_sigmoid, self.gpu_ids) self.netD_B = networks.define_D(opt.input_nc, opt.ndf, opt.which_model_netD, opt.n_layers_D, opt.norm, use_sigmoid, self.gpu_ids) # If this is non-training phase/continue training phase if not self.isTrain or opt.continue_train: which_epoch = opt.which_epoch self.load_network(self.netG_A, 'G_A', which_epoch) self.load_network(self.netG_B, 'G_B', which_epoch) if self.isTrain: self.load_network(self.netD_A, 'D_A', which_epoch) self.load_network(self.netD_B, 'D_B', which_epoch) if self.isTrain: # build up so called history pool self.fake_A_pool = ImagePool(opt.pool_size) self.fake_B_pool = ImagePool(opt.pool_size) self.old_lr = opt.lr # define loss functions self.criterionGAN = networks.GANLoss(use_lsgan=not opt.no_lsgan, tensor=self.Tensor, gpu_ids=opt.gpu_ids) self.criterionCycle = torch.nn.L1Loss() self.criterionIdt = torch.nn.L1Loss() if opt.use_prcp: self.criterionPrcp = networks.PrcpLoss(opt.weight_path, opt.bias_path, opt.perceptual_level, tensor=self.Tensor, gpu_ids=opt.gpu_ids) # initialize optimizers self.optimizer_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters()), lr=opt.lr, betas=(opt.beta1, 0.999)) self.optimizer_D_A = torch.optim.Adam(self.netD_A.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) self.optimizer_D_B = torch.optim.Adam(self.netD_B.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) print('---------- Networks initialized -------------') networks.print_network(self.netG_A) networks.print_network(self.netG_B) networks.print_network(self.netD_A) networks.print_network(self.netD_B) print('-----------------------------------------------')