def __init__(self, opt): BaseModel.__init__(self, opt) self.loss_names = ['mpjpe'] self.model_names = ['G'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \ else torch.ByteTensor self.net_G = network.define_g(opt, filename='generator', structure_nc=opt.structure_nc, channels=256, layers=4) if len(opt.gpu_ids) > 1: self.net_G = torch.nn.DataParallel(self.net_G, device_ids=self.gpu_ids) self.convert2skeleton = openpose_utils.tensor2skeleton() if self.isTrain: self.L2loss = torch.nn.MSELoss() self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) else: self.L2loss = torch.nn.MSELoss() util.mkdir(os.path.join(self.opt.results_dir)) self.setup(opt)
def __init__(self, opt): BaseModel.__init__(self, opt) self.loss_names = ['correctness','regularization'] self.visual_names = ['input_P1','input_P2', 'warp', 'flow_fields', 'masks'] self.model_names = ['G'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \ else torch.ByteTensor self.net_G = network.define_g(opt, structure_nc=opt.structure_nc, ngf=32, img_f=256, encoder_layer=5, norm='instance', activation='LeakyReLU', attn_layer=self.opt.attn_layer, use_spect=opt.use_spect_g, ) self.L1loss = torch.nn.L1Loss() self.flow2color = util.flow2color() if self.isTrain: self.Correctness = external_function.PerceptualCorrectness().to(opt.device) self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device) self.optimizer_G = torch.optim.Adam(itertools.chain(filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) self.setup(opt)
def __init__(self, opt): """Initial the pluralistic model""" BaseModel.__init__(self, opt) self.loss_names = ['app_gen','correctness_p', 'correctness_r','content_gen','style_gen', 'regularization_p', 'regularization_r', 'ad_gen','dis_img_gen', 'ad_gen_v', 'dis_img_gen_v'] self.visual_names = ['P_reference','BP_reference', 'P_frame_step','BP_frame_step','img_gen', 'flow_fields', 'masks'] self.model_names = ['G','D','D_V'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \ else torch.ByteTensor # define the Animation model self.net_G = network.define_g(opt, image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, img_f=512, layers=opt.layers, num_blocks=2, use_spect=opt.use_spect_g, attn_layer=opt.attn_layer, norm='instance', activation='LeakyReLU', extractor_kz=opt.kernel_size) if len(opt.gpu_ids) > 1: self.net_G = torch.nn.DataParallel(self.net_G, device_ids=self.gpu_ids) self.flow2color = util.flow2color() self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) if len(opt.gpu_ids) > 1: self.net_D = torch.nn.DataParallel(self.net_D, device_ids=self.gpu_ids) input_nc = (opt.frames_D_V-1) * opt.image_nc self.net_D_V = network.define_d(opt, input_nc=input_nc, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) if len(opt.gpu_ids) > 1: self.net_D_V = torch.nn.DataParallel(self.net_D_V, device_ids=self.gpu_ids) if self.isTrain: # define the loss functions self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to(opt.device) self.L1loss = torch.nn.L1Loss() self.L2loss = torch.nn.MSELoss() self.Correctness = external_function.PerceptualCorrectness().to(opt.device) self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device) self.Vggloss = external_function.VGGLoss().to(opt.device) # define the optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) self.optimizer_D = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_D.parameters()), filter(lambda p: p.requires_grad, self.net_D_V.parameters())), lr=opt.lr*opt.ratio_g2d, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_D) else: self.results_dir_base = self.opt.results_dir self.setup(opt)
def __init__(self, opt): BaseModel.__init__(self, opt) self.opt = opt self.keys = ['head', 'body', 'leg'] self.mask_id = { 'head': [1, 2, 4, 13], 'body': [3, 5, 6, 7, 10, 11, 14, 15], 'leg': [8, 9, 12, 16, 17, 18, 19] } self.GPU = torch.device('cuda:0') self.loss_names = ['correctness', 'regularization'] self.visual_names = [ 'input_P1', 'input_P2', 'warp', 'flow_fields', 'masks', 'input_BP1', 'input_BP2' ] self.model_names = ['G'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \ else torch.ByteTensor self.net_G = network.define_g( opt, structure_nc=opt.structure_nc, ngf=32, img_f=256, layers=5, norm='instance', activation='LeakyReLU', attn_layer=self.opt.attn_layer, use_spect=opt.use_spect_g, ) self.flow2color = util.flow2color() if self.isTrain: # define the loss functions self.Correctness = external_function.PerceptualCorrectness().to( opt.device) self.Regularization = external_function.MultiAffineRegularizationLoss( kz_dic=opt.kernel_size).to(opt.device) # define the optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) # load the pretrained model and schedulers self.setup(opt)
def __init__(self, opt): BaseModel.__init__(self, opt) self.loss_names = ['app_gen', 'correctness_gen', 'content_gen', 'style_gen', 'regularization', 'ad_gen', 'dis_img_gen'] self.visual_names = ['input_P1','input_P2', 'img_gen', 'flow_fields', 'masks'] self.model_names = ['G','D'] self.keys = ['head','body','leg'] self.mask_id = {'head':[1,2,4,13],'body':[3,5,6,7,10,11,14,15],'leg':[8,9,12,16,17,18,19]} self.GPU = torch.device('cuda:0') self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor # define the generator self.net_G = network.define_g(opt, image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, img_f=512, layers=opt.layers, num_blocks=2, use_spect=opt.use_spect_g, attn_layer=opt.attn_layer, norm='instance', activation='LeakyReLU', extractor_kz=opt.kernel_size) # define the discriminator if self.opt.dataset_mode == 'fashion': self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) elif self.opt.dataset_mode== 'market': self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=3, use_spect=opt.use_spect_d) self.flow2color = util.flow2color() if self.isTrain: # define the loss functions self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to(opt.device) self.L1loss = torch.nn.L1Loss() self.Correctness = external_function.PerceptualCorrectness().to(opt.device) self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device) self.Vggloss = external_function.VGGLoss().to(opt.device) # define the optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) self.optimizer_D = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_D.parameters())), lr=opt.lr*opt.ratio_g2d, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_D) # load the pre-trained model and schedulers self.setup(opt)
def __init__(self, opt): BaseModel.__init__(self, opt) self.loss_names = [ 'app_gen', 'correctness_gen', 'content_gen', 'style_gen', 'regularization', 'ad_gen', 'dis_img_gen' ] self.visual_names = [ 'input_P1', 'input_P2', 'img_gen', 'flow_fields', 'masks' ] self.model_names = ['G', 'D'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \ else torch.ByteTensor self.net_G = network.define_g(opt, image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, img_f=512, layers=opt.layers, num_blocks=2, use_spect=opt.use_spect_g, attn_layer=opt.attn_layer, norm='instance', activation='LeakyReLU', extractor_kz=opt.kernel_size) self.flow2color = util.flow2color() self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) if self.isTrain: self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to( opt.device) self.L1loss = torch.nn.L1Loss() self.L2loss = torch.nn.MSELoss() self.Correctness = external_function.PerceptualCorrectness().to( opt.device) self.Regularization = external_function.MultiAffineRegularizationLoss( kz_dic=opt.kernel_size).to(opt.device) self.Vggloss = external_function.VGGLoss().to(opt.device) # define the optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) self.optimizer_D = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_D.parameters())), lr=opt.lr * opt.ratio_g2d, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_D) self.setup(opt)
def __init__(self, opt): BaseModel.__init__(self, opt) self.loss_names = [ 'app_gen', 'content_gen', 'style_gen', #'reg_gen', 'ad_gen', 'dis_img_gen', 'par', 'par1' ] self.visual_names = ['input_P1', 'input_P2', 'img_gen'] self.model_names = ['G', 'D'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor # define the generator self.net_G = network.define_g(opt, image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, use_spect=opt.use_spect_g, norm='instance', activation='LeakyReLU') # define the discriminator if self.opt.dataset_mode == 'fashion': self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) trained_list = ['parnet'] for k, v in self.net_G.named_parameters(): flag = False for i in trained_list: if i in k: flag = True if flag: #v.requires_grad = False print(k) if self.isTrain: # define the loss functions self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to( opt.device) self.L1loss = torch.nn.L1Loss() self.Vggloss = external_function.VGGLoss().to(opt.device) self.parLoss = CrossEntropyLoss2d() #torch.nn.BCELoss() # define the optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.9, 0.999)) self.optimizers.append(self.optimizer_G) self.optimizer_D = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_D.parameters())), lr=opt.lr * opt.ratio_g2d, betas=(0.9, 0.999)) self.optimizers.append(self.optimizer_D) # load the pre-trained model and schedulers self.setup(opt)
def __init__(self, opt): BaseModel.__init__(self, opt) self.loss_names = ['app_gen','correctness_p', 'correctness_r', 'content_gen','style_gen', 'regularization_p','regularization_r', 'ad_gen', 'dis_img_gen', 'ad_gen_v', 'dis_img_gen_v'] self.visual_names = ['ref_image', 'ref_skeleton', 'BP_step', 'P_step','img_gen'] self.model_names = ['G', 'D', 'D_V'] self.FloatTensor = torch.cuda.FloatTensor if len(self.gpu_ids)>0 \ else torch.FloatTensor self.ByteTensor = torch.cuda.ByteTensor if len(self.gpu_ids)>0 \ else torch.ByteTensor self.net_G = network.define_g(opt, filename='generator', image_nc=opt.image_nc, structure_nc=opt.structure_nc, ngf=64, img_f=512, layers=opt.layers, num_blocks=2, use_spect=opt.use_spect_g, attn_layer=opt.attn_layer, norm='instance', activation='LeakyReLU', extractor_kz=opt.kernel_size) if len(opt.gpu_ids) > 1: self.net_G = torch.nn.DataParallel(self.net_G, device_ids=self.gpu_ids) self.flow2color = util.flow2color() self.convert2skeleton = openpose_utils.tensor2skeleton(spatial_draw=True) self.net_D = network.define_d(opt, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) if len(opt.gpu_ids) > 1: self.net_D = torch.nn.DataParallel(self.net_D, device_ids=self.gpu_ids) self.net_D_V = network.define_d(opt, name=opt.netD_V, input_length=opt.frames_D_V, ndf=32, img_f=128, layers=4, use_spect=opt.use_spect_d) if len(opt.gpu_ids) > 1: self.net_D_V = torch.nn.DataParallel(self.net_D_V, device_ids=self.gpu_ids) if self.isTrain: self.GANloss = external_function.AdversarialLoss(opt.gan_mode).to(opt.device) self.L1loss = torch.nn.L1Loss() self.Correctness = external_function.PerceptualCorrectness().to(opt.device) self.Regularization = external_function.MultiAffineRegularizationLoss(kz_dic=opt.kernel_size).to(opt.device) self.Vggloss = external_function.VGGLoss().to(opt.device) # define the optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_G.parameters())), lr=opt.lr, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_G) self.optimizer_D = torch.optim.Adam(itertools.chain( filter(lambda p: p.requires_grad, self.net_D.parameters()), filter(lambda p: p.requires_grad, self.net_D_V.parameters())), lr=opt.lr*opt.ratio_g2d, betas=(0.0, 0.999)) self.optimizers.append(self.optimizer_D) if self.opt.use_mask: # use mask to calculate the correctness loss for foreground content self.opt.lambda_correct = 2.0 else: self.results_dir_base = self.opt.results_dir self.esp=1e-6 self.setup(opt)