def __init__(self, opt): super(SRSolver, self).__init__(opt) self.train_opt = opt['solver'] self.LR = self.Tensor() self.HR = self.Tensor() self.SR = None self.records = {'train_loss': [], 'val_loss': [], 'psnr': [], 'ssim': [], 'lr': []} self.model = create_model(opt) self.print_network() if self.is_train: self.model.train() # set cl_loss if self.use_cl: self.cl_weights = self.opt['solver']['cl_weights'] assert self.cl_weights, "[Error] 'cl_weights' is not be declared when 'use_cl' is true" # set loss loss_type = self.train_opt['loss_type'] if loss_type == 'l1': self.criterion_pix = nn.L1Loss() elif loss_type == 'l2': self.criterion_pix = nn.MSELoss() else: raise NotImplementedError('Loss type [%s] is not implemented!'%loss_type) if self.use_gpu: self.criterion_pix = self.criterion_pix.cuda() # set optimizer weight_decay = self.train_opt['weight_decay'] if self.train_opt['weight_decay'] else 0 optim_type = self.train_opt['type'].upper() if optim_type == "ADAM": self.optimizer = optim.Adam(self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=weight_decay) else: raise NotImplementedError('Loss type [%s] is not implemented!' % optim_type) # set lr_scheduler if self.train_opt['lr_scheme'].lower() == 'multisteplr': self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer, self.train_opt['lr_steps'], self.train_opt['lr_gamma']) else: raise NotImplementedError('Only MultiStepLR scheme is supported!') self.load() print('===> Solver Initialized : [%s] || Use CL : [%s] || Use GPU : [%s]'%(self.__class__.__name__, self.use_cl, self.use_gpu)) if self.is_train: print("optimizer: ", self.optimizer) print("lr_scheduler milestones: %s gamma: %f"%(self.scheduler.milestones, self.scheduler.gamma))
def __init__(self, opt): super(SRSolver, self).__init__(opt) self.train_opt = opt['solver'] self.LR = self.Tensor() self.HR = self.Tensor() self.SR = None self.records = { 'client_idx': [], 'client_loss': [], 'agg_loss': [], 'val_loss': [], 'psnr': [], 'ssim': [] } self.model = create_model(opt) self.print_network() if self.is_train: self.model.train() # set cl_loss if self.use_cl: self.cl_weights = self.opt['solver']['cl_weights'] assert self.cl_weights, "[Error] 'cl_weights' is not be declared when 'use_cl' is true" # set loss loss_type = self.train_opt['loss_type'] if loss_type == 'l1': self.criterion_pix = nn.L1Loss() elif loss_type == 'l2': self.criterion_pix = nn.MSELoss() else: raise NotImplementedError( 'Loss type [%s] is not implemented!' % loss_type) if self.use_gpu: self.criterion_pix = self.criterion_pix.cuda() # set optimizer weight_decay = self.train_opt['weight_decay'] if self.train_opt[ 'weight_decay'] else 0 optim_type = self.train_opt['type'].upper() if optim_type == "ADAM": self.optimizer = optim.Adam(self.model.parameters(), lr=self.train_opt['learning_rate'], betas=(0.9, 0.999), eps=1e-8, weight_decay=weight_decay) ######################################################################### ### add AdamW elif optim_type == 'ADAMW': self.optimizer = optim.AdamW( self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=0.01) ######################################################################### ### add SGD elif optim_type == 'SGD': self.optimizer = optim.SGD(self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=1e-5) ######################################################################### else: raise NotImplementedError( 'Loss type [%s] is not implemented!' % optim_type) # set lr_scheduler if self.train_opt['lr_scheme'].lower() == 'multisteplr': self.scheduler = optim.lr_scheduler.MultiStepLR( self.optimizer, self.train_opt['lr_steps'], self.train_opt['lr_gamma']) ######################################################################### ### add cosine_lr elif self.train_opt['lr_scheme'].lower() == 'cosinelr': self.scheduler = CosineLRScheduler( self.optimizer, self.train_opt['num_epochs']) ######################################################################### else: raise NotImplementedError( 'Only MultiStepLR scheme is supported!') if not self.is_train: self.load() print( '===> Solver Initialized : [%s] || Use CL : [%s] || Use GPU : [%s]' % (self.__class__.__name__, self.use_cl, self.use_gpu)) if self.is_train: print("optimizer: ", self.optimizer)
def __init__(self, opt): super(SRSolver, self).__init__(opt) self.train_opt = opt['solver'] self.LR = self.Tensor() self.HR = self.Tensor() # self.patch_size = opt['datasets']['train']['LR_size'] self.SR = None self.records = { 'train_loss': [], 'val_loss': [], 'psnr': [], 'ssim': [], 'lr': [] } self.model = create_model(opt) self.print_network() if self.is_train: self.model.train() # set loss loss_type = self.train_opt['loss_type'] if loss_type == 'l1': self.criterion_pix = nn.L1Loss() elif loss_type == 'l2': self.criterion_pix = nn.MSELoss() elif loss_type == 'myloss': import importlib network = importlib.import_module( 'networks.' + opt['networks']['which_model']) self.criterion_pix = network.myloss() else: raise NotImplementedError( 'Loss type [%s] is not implemented!' % loss_type) if self.use_gpu: self.criterion_pix = self.criterion_pix.cuda() # set optimizer weight_decay = self.train_opt['weight_decay'] if self.train_opt[ 'weight_decay'] else 0 optim_type = self.train_opt['type'].upper() if optim_type == "ADAM": self.optimizer = optim.Adam(self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=weight_decay) else: raise NotImplementedError( 'Loss type [%s] is not implemented!' % optim_type) # set lr_scheduler if self.train_opt['lr_scheme'].lower() == 'multisteplr': self.scheduler = optim.lr_scheduler.MultiStepLR( self.optimizer, self.train_opt['lr_steps'], self.train_opt['lr_gamma']) else: raise NotImplementedError( 'Only MultiStepLR scheme is supported!') self.load() # self.optimizer.param_groups[0]['lr'] = 0.00005 # if optim_type == "ADAM": # self.optimizer = optim.Adam(self.model.parameters(), # lr=self.train_opt['learning_rate'], weight_decay=weight_decay) print( '===> Solver Initialized : [%s] || Use CL : [%s] || Use GPU : [%s]' % (self.__class__.__name__, self.use_cl, self.use_gpu)) if self.is_train: print("optimizer: ", self.optimizer) print("lr_scheduler milestones: %s gamma: %f" % (self.scheduler.milestones, self.scheduler.gamma))
'seresnet34' -> SE-ResNet-34 21,461,952 21,446,720 15,232 'seresnet50' -> SE-ResNet-50 26,087,360 26,041,920 45,440 'seresnet101' -> SE-ResNet-101 47,988,672 47,887,936 100,736 'seresnet154' -> SE-ResNet-154 64,884,672 64,740,928 143,744 'seresnetsaul' -> SE-ResNet-Saul 22,072,768 22,055,744 17,024 'seinceptionv3' -> SE-Inception-v3 23,480,365 23,445,933 34,432 'seinceptionresnetv2' -> SE-Inception-ResNet-v2 64,094,445 64,033,901 60,544 'seresnext' -> SE-ResNeXt 97,869,632 97,869,632 100,480 'mobilenet' -> MobileNet 3,242,189 3,220,301 21,888 'densenet121' -> DenseNet-121 7,050,829 6,967,181 83,648 'densenet169' -> DenseNet-169 12,664,525 12,506,125 158,400 'densenet201' -> DenseNet-201 18,346,957 18,117,901 229,056 other -> Custom model ''' aux_model = networks.create_model(network=ARCHITECTURE, input_shape=input_shape) aux_model.layers.pop() # remove the last layer of the model weight_decay = 1e-4 x = [None]*OUTPUTS if OUTPUTS == 1: x[0] = Dense(13, use_bias=False, kernel_regularizer=l2(weight_decay), activation='softmax', name='categories')(aux_model.layers[-1].output) elif OUTPUTS == 5: x[0] = Dense(4, use_bias=False, kernel_regularizer=l2(weight_decay), activation='softmax', name='flavour')(aux_model.layers[-1].output) x[1] = Dense(4, use_bias=False, kernel_regularizer=l2(weight_decay), activation='softmax', name='protons')(aux_model.layers[-1].output) x[2] = Dense(4, use_bias=False, kernel_regularizer=l2(weight_decay),
def __init__(self, opt): super(SRLandmarkSolver, self).__init__(opt) self.train_opt = opt['solver'] self.LR = self.Tensor() self.HR = self.Tensor() self.gt_heatmap = self.Tensor() self.SR = None self.hg_require_grad = True self.unnorm = Normalize( (-0.509 * opt['rgb_range'], -0.424 * opt['rgb_range'], -0.378 * opt['rgb_range']), (1.0, 1.0, 1.0)) self.records = { 'val_loss_pix': [], 'val_loss_total': [], 'psnr': [], 'ssim': [], 'lr': [] } self.model = create_model(opt) if self.is_train: self.model.train() # set loss self.loss_dict = {} for k, v in self.train_opt['loss'].items(): self.loss_dict[k] = {} loss_type = v['loss_type'] if loss_type == 'l1': self.loss_dict[k]['criterion'] = nn.L1Loss() elif loss_type == 'l2': self.loss_dict[k]['criterion'] = nn.MSELoss() else: raise NotImplementedError( '%d loss type [%s] is not implemented!' % (k, loss_type)) self.loss_dict[k]['weight'] = v['weight'] if self.use_gpu: for k in self.loss_dict.keys(): self.loss_dict[k]['criterion'] = self.loss_dict[k][ 'criterion'].cuda() # set optimizer weight_decay = self.train_opt['weight_decay'] if self.train_opt[ 'weight_decay'] else 0 optim_type = self.train_opt['type'].upper() if optim_type == "ADAM": self.optimizer = optim.Adam(self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=weight_decay) else: raise NotImplementedError( 'Loss type [%s] is not implemented!' % optim_type) # set lr_scheduler if self.train_opt['lr_scheme'].lower() == 'multisteplr': self.scheduler = optim.lr_scheduler.MultiStepLR( self.optimizer, self.train_opt['lr_steps'], self.train_opt['lr_gamma']) else: raise NotImplementedError( 'Only MultiStepLR scheme is supported!') self.print_network() self.load() print('===> Solver Initialized : [%s] || Use GPU : [%s]' % (self.__class__.__name__, self.use_gpu)) if self.is_train: print("optimizer: ", self.optimizer) print("lr_scheduler milestones: %s gamma: %f" % (self.scheduler.milestones, self.scheduler.gamma))
test = self.transform(img) test_embedding = self.model(test) l2_dist = self.l2_dist(self.anchor_emdedding, test_embedding) print(l2_dist.detach().item()) if l2_dist < 10: print("correct") else: print("wrong") print("=" * 55) if __name__ == "__main__": cfg = get_configuration() model = create_model(cfg) valload = create_dataset(cfg, "train", transform=ToTensor()) restore_path = "./checkpoints/facenet/checkpoint_1000.pth" # dataloader = create_dataset(cfg, 'test', transform=ToTensor()) inference_engie = InferenceEngine(cfg, model, valload) inference_engie.setup(restore_path) text = "=" * 80 print("\033[33m{}\033[0m".format(text)) # test single image # img_path = input("Enter the picture you want to save:") # inference_engie.save_code_base(img_path) # while True: # test_path = input("Enter the picture you want to test:") # if test_path == "q": # break # inference_engie.calculate_similarity(test_path)
def __init__(self, opt): super(SRSolver, self).__init__(opt) self.train_opt = opt['solver'] self.LR = self.Tensor() self.HR = self.Tensor() self.SR = None self.records = {'train_loss': [], 'val_loss': [], 'psnr': [], 'ssim': [], 'lr': []} self.which_model = opt['networks']['which_model'].upper() if self.which_model.find('WSR') >= 0: self.wavelet_num = int(np.log2(opt['scale']) + 1) self.model = create_model(opt) if self.is_train: self.model.train() if self.which_model.find('WSR') >= 0: self.xfm = DWTForward(J=self.wavelet_num - 1, wave='db1', mode='symmetric') if torch.cuda.is_available(): self.xfm = nn.DataParallel(self.xfm).cuda() self.xfm.eval() # set wl_loss self.wl_weights = self.opt['solver']['wl_weights'] assert self.wl_weights, "[Error] 'wl_weights' is not be declared" assert len( self.wl_weights) == self.wavelet_num, "[Error] The number of 'wl_weights' does not match the scale factor" # set cl_loss if self.use_cl: self.cl_weights = self.opt['solver']['cl_weights'] assert self.cl_weights, "[Error] 'cl_weights' is not be declared when 'use_cl' is true" # set loss loss_type = self.train_opt['loss_type'] if loss_type == 'l1': self.criterion_pix = nn.L1Loss() elif loss_type == 'l2': self.criterion_pix = nn.MSELoss() else: raise NotImplementedError('Loss type [%s] is not implemented!' % loss_type) if self.use_gpu: self.criterion_pix = self.criterion_pix.cuda() # set optimizer weight_decay = self.train_opt['weight_decay'] if self.train_opt['weight_decay'] else 0 optim_type = self.train_opt['type'].upper() if optim_type == "ADAM": self.optimizer = optim.Adam(self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=weight_decay) else: raise NotImplementedError('Loss type [%s] is not implemented!' % optim_type) # set lr_scheduler if self.train_opt['lr_scheme'].lower() == 'multisteplr': self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer, self.train_opt['lr_steps'], self.train_opt['lr_gamma']) else: raise NotImplementedError('Only MultiStepLR scheme is supported!') self.load() self.print_network() print('===> Solver Initialized : [%s] || Use CL : [%s] || Use GPU : [%s]' % (self.__class__.__name__, self.use_cl, self.use_gpu)) if self.is_train: print("optimizer: ", self.optimizer) print("lr_scheduler milestones: %s gamma: %f" % (self.scheduler.milestones, self.scheduler.gamma))
def __init__(self, opt): super(SRSolver, self).__init__(opt) self.train_opt = opt['solver'] self.LR = self.Tensor() self.HR = self.Tensor() self.SR = None self.loss_func = myloss_func(opt) self.records = {'train_loss': [], 'val_loss': [], 'psnr': [], 'ssim': [], 'lr': []} self.model = create_model(opt).to(self.device) if self.is_train: self.model.train() self.discriminator = define_D(opt) self.discriminator.train() # set loss loss_type = self.train_opt['loss_type'] if loss_type == 'l1': self.criterion_pix = nn.L1Loss() elif loss_type == 'l2': self.criterion_pix = nn.MSELoss() else: raise NotImplementedError('Loss type [%s] is not implemented!'%loss_type) if self.use_gpu: self.criterion_pix = self.criterion_pix.cuda() # set optimizer weight_decay = self.train_opt['weight_decay'] if self.train_opt['weight_decay'] else 0 optim_type = self.train_opt['type'].upper() if optim_type == "ADAM": wd_D = self.train_opt['weight_decay_D'] if self.train_opt['weight_decay_D'] else 0 self.optimizer_D = torch.optim.Adam(self.discriminator.parameters(), lr=self.train_opt['lr_D'], \ weight_decay=wd_D, betas=(self.train_opt['beta1_D'], 0.999)) self.optimizer = optim.Adam(self.model.parameters(), lr=self.train_opt['learning_rate'], weight_decay=weight_decay) else: raise NotImplementedError('Loss type [%s] is not implemented!' % optim_type) # D_update_ratio and D_init_iters are for WGAN self.D_update_ratio = self.train_opt['D_update_ratio'] if self.train_opt['D_update_ratio'] else 1 self.D_init_iters = self.train_opt['D_init_iters'] if self.train_opt['D_init_iters'] else 0 # set lr_scheduler if self.train_opt['lr_scheme'].lower() == 'multisteplr': self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer, self.train_opt['lr_steps'], self.train_opt['lr_gamma']) else: raise NotImplementedError('Only MultiStepLR scheme is supported!') self.load() self.print_network() print('===> Solver Initialized : [%s] || Use CL : [%s] || Use GPU : [%s]'%(self.__class__.__name__, self.use_cl, self.use_gpu)) if self.is_train: print("optimizer: ", self.optimizer) print("lr_scheduler milestones: %s gamma: %f"%(self.scheduler.milestones, self.scheduler.gamma))