def __init__(self, conf, inference=False): print(conf) if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter( '/home/zzg/DeepLearning/InsightFace_Pytorch/work_space/log') self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 29000 #100 self.evaluate_every = len(self.loader) // 500 ##10 self.save_every = len(self.loader) // 290 #5 # self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(self.loader.dataset.root.parent) self.agedb_30, self.agedb_30_issame = get_val_data( '/home/zzg/DeepLearning/InsightFace_Pytorch/data/faces_emore') else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) # print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) # print('{}_{} model generated done !'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) # print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) rootdir = os.path.join(args.root_dir, args.rec_path) self.board_loss_every = len(self.loader) // len(self.loader) self.evaluate_every = len(self.loader) // 1 # self.save_every = len(self.loader)//len(self.loader) # 5 print('board loss every: {} -> evaluate_every: {} \n'.format( self.board_loss_every, self.evaluate_every)) print('loader paths of validation dataset {}'.format(rootdir)) self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( rootdir) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): print(conf) print(conf.use_mobilfacenet) input("CONF") if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones # Dataset Loader # ritorna un loader dataset ImageLoader self.loader, self.class_num = get_train_loader(conf) # Classe di tensorboardX per salvare i log # log_path indica il percorso dove sono salvate le statistiche self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') # paras_only_bn contiene i layer con i parametri della batchnorm paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD([ {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, {'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) else: self.optimizer = optim.SGD([ {'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') # Parametri che indicano ogni quanto salvare i modelli e le epoche self.board_loss_every = len(self.loader)//10 self.evaluate_every = len(self.loader)//10 self.save_every = len(self.loader)//5 print("DATASET") print(self.loader.dataset.root) # ritornano gli array e le labels delle diverse cartelle del dataset VALIDATION self.agedb_30 ,self.agedb_30_issame = get_val_data(self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): print(conf) self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) print('loading... finish') if not inference: self.milestones = conf.milestones dataset = Dataset(root=conf.data_path, data_list_file=conf.datalist_path, phase='train', input_shape=(1, 112, 112)) self.loader = data.DataLoader(dataset, conf.batch_size) self.class_num = conf.class_num self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD([ {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, {'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4}, {'params': paras_only_bn} ], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD([ {'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4}, {'params': paras_only_bn} ], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.load_state(conf, '2019-11-10-22-01.pth', True, False) # self.load_state(conf,'111.pth',False,True) print('load save') self.board_loss_every = len(self.loader) // 2 print(len(self.loader)) # self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 2 # self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 2 # self.save_every = len(self.loader) // 5 # self.essex, self.essex_issame = get_val_data( # self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf): print(conf) self.model = ResNet() self.model.cuda() if conf.initial: self.model.load_state_dict(torch.load("models/"+conf.model)) print('Load model_ir_se101.pth') self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.total_class = 16520 self.data_num = 285356 self.writer = SummaryWriter(conf.log_path) self.step = 0 self.paras_only_bn, self.paras_wo_bn = separate_bn_paras(self.model) if conf.meta: self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.total_class) self.head.cuda() if conf.initial: self.head.load_state_dict(torch.load("models/head_op.pth")) print('Load head_op.pth') self.optimizer = RAdam([ {'params': self.paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4}, {'params': self.paras_only_bn} ], lr=conf.lr) self.meta_optimizer = RAdam([ {'params': self.paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4}, {'params': self.paras_only_bn} ], lr=conf.lr) self.head.train() else: self.head = dict() self.optimizer = dict() for race in races: self.head[race] = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num[race]) self.head[race].cuda() if conf.initial: self.head[race].load_state_dict(torch.load("models/head_op_{}.pth".format(race))) print('Load head_op_{}.pth'.format(race)) self.optimizer[race] = RAdam([ {'params': self.paras_wo_bn + [self.head[race].kernel], 'weight_decay': 5e-4}, {'params': self.paras_only_bn} ], lr=conf.lr, betas=(0.5, 0.999)) self.head[race].train() # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) self.board_loss_every = min(len(self.loader[race]) for race in races) // 10 self.evaluate_every = self.data_num // 5 self.save_every = self.data_num // 2 self.eval, self.eval_issame = get_val_data(conf)
def get_opt(self, conf): paras_only_bn = [] paras_wo_bn = [] for model in self.models: paras_only_bn_, paras_wo_bn_ = separate_bn_paras(model) paras_only_bn.append(paras_only_bn_) paras_wo_bn.append(paras_wo_bn_) self.optimizer = optim.SGD([ {'params': paras_wo_bn[model_num], 'weight_decay': 5e-4} for model_num in range(conf.n_models) ] + [ {'params': paras_only_bn[model_num]} for model_num in range(conf.n_models) ], lr=conf.lr, momentum=conf.momentum)
def __init__(self, conf, inference=False): accuracy = 0.0 logger.debug(conf) if conf.use_mobilfacenet: # self.model = MobileFaceNet(conf.embedding_size).to(conf.device) self.model = MobileFaceNet(conf.embedding_size).cuda() logger.debug('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).cuda()#.to(conf.device) logger.debug('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones logger.info('loading data...') self.loader, self.class_num = get_train_loader(conf, 'emore', sample_identity=True) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = CircleLoss(m=0.25, gamma=256.0).cuda() paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD([ {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, {'params': [paras_wo_bn[-1]], 'weight_decay': 4e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) else: self.optimizer = optim.SGD([ {'params': paras_wo_bn, 'weight_decay': 5e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) # self.optimizer = torch.nn.parallel.DistributedDataParallel(optimizer,device_ids=[conf.argsed]) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) if conf.fp16: self.model, self.optimizer = amp.initialize(self.model, self.optimizer, opt_level="O2") self.model = DistributedDataParallel(self.model).cuda() else: self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[conf.argsed]).cuda() #add line for distributed self.board_loss_every = len(self.loader)//100 self.evaluate_every = len(self.loader)//2 self.save_every = len(self.loader)//2 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(Path(self.loader.dataset.root).parent) else: self.threshold = conf.threshold self.loader, self.query_ds, self.gallery_ds = get_test_loader(conf)
def __init__(self, conf, inference=False, transfer=0, ext='final'): pprint.pprint(conf) self.conf = conf if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) tmp_idx = ext.rfind('_') # find the last '_' to replace it by '/' self.ext = '/' + ext[:tmp_idx] + '/' + ext[tmp_idx + 1:] self.writer = SummaryWriter(str(conf.log_path) + self.ext) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) self.optimizer = optim.Adam( list(self.model.parameters()) + list(self.head.parameters()), conf.lr) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.save_freq = len(self.loader) // 5 #//5 # originally, 100 self.evaluate_every = len(self.loader) #//5 # originally, 10 self.save_every = len(self.loader) #//2 # originally, 5 # self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(self.loader.dataset.root.parent) # self.val_112, self.val_112_issame = get_val_pair(self.loader.dataset.root.parent, 'val_112') else: self.threshold = conf.threshold self.train_losses = [] self.train_counter = [] self.test_losses = [] self.test_accuracy = [] self.test_counter = []
def __init__(self, conf, inference=False): print(conf) if conf.use_seesawFaceNet: self.model = seesaw_shuffleFaceNetv3(conf.embedding_size).to(conf.device) print('seesawFaceNetv3 (with slim) model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode)#.to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = LiArcFace(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('using LiArcFace as loss function') print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) self.model = torch.nn.DataParallel(self.model).cuda() cudnn.enabled = True cudnn.benchmark = True if conf.use_seesawFaceNet: print('setting optimizer for seesawFacenet') self.optimizer = optim.SGD([ {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, {'params': [paras_wo_bn[-1]] + [self.head.weight], 'weight_decay': 4e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) else: self.optimizer = optim.SGD([ {'params': paras_wo_bn + [self.head.weight], 'weight_decay': 5e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader)//100 self.evaluate_every = len(self.loader)//10 self.save_every = len(self.loader)//2 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): print(conf) # self.loader, self.class_num = construct_msr_dataset(conf) self.loader, self.class_num = get_train_loader(conf) self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = QAMFace(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) self.focalLoss = FocalLoss() print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 1000 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 2 else: self.threshold = conf.threshold # 多GPU训练 self.model = torch.nn.DataParallel(self.model) self.model.to(conf.device) self.head = torch.nn.DataParallel(self.head) self.head = self.head.to(conf.device)
def get_opt(self, conf): paras_only_bn = [] paras_wo_bn = [] for model in self.models: paras_only_bn_, paras_wo_bn_ = separate_bn_paras(model) paras_only_bn.append(paras_only_bn_) paras_wo_bn.append(paras_wo_bn_) param_list = [{ 'params': paras_wo_bn[model_num], 'weight_decay': 5e-4 } for model_num in range(conf.n_models)] + [{ 'params': paras_only_bn[model_num] } for model_num in range(conf.n_models)] self.optimizer = optim.Adam(param_list, lr=conf.lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=1e-5) #self.scheduler = ReduceLROnPlateau(self.optimizer, factor=0.1, patience=5, mode='min') self.scheduler = StepLR(self.optimizer, step_size=25, gamma=0.2)
def __init__(self, conf): # ----------- define model --------------- # build_model = PreBuildConverter(in_channels=1, out_classes=5, add_soft_max=True) self.models = [] for _ in range(conf.n_models): self.models.append(build_model.get_by_str(conf.net_mode).to(conf.device)) print('{} {} models generated'.format(conf.n_models, conf.net_mode)) # ------------ define params -------------- # self.milestones = conf.milestones if not os.path.exists(conf.log_path): os.mkdir(conf.log_path) os.mkdir(conf.log_path / str(conf.local_rank)) self.writer = SummaryWriter(logdir=conf.log_path / str(conf.local_rank)) self.step = 0 self.epoch = 0 print('two model heads generated') paras_only_bn = [] paras_wo_bn = [] for model in self.models: paras_only_bn_, paras_wo_bn_ = separate_bn_paras(model) paras_only_bn.append(paras_only_bn_) paras_wo_bn.append(paras_wo_bn_) self.optimizer = optim.SGD([ {'params': paras_wo_bn[model_num], 'weight_decay': 5e-4} for model_num in range(conf.n_models) ] + [ {'params': paras_only_bn[model_num]} for model_num in range(conf.n_models) ], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # ------------ define loaders -------------- # self.train_ds = CBIS_PatchDataSet_INMEM(mode='train', nb_abn=conf.n_patch, nb_bkg=conf.n_patch) self.test_ds = CBIS_PatchDataSet_INMEM(mode='test', nb_abn=conf.n_patch, nb_bkg=conf.n_patch) self.train_sampler = DistributedSampler(self.train_ds, num_replicas=4, rank=conf.local_rank) self.test_sampler = DistributedSampler(self.train_ds, num_replicas=4, rank=conf.local_rank) dloader_args = { 'batch_size': conf.batch_size, 'pin_memory': True, 'num_workers': conf.num_workers, 'drop_last': False, } self.train_loader = DataLoader(self.train_ds, sampler=self.train_sampler, **dloader_args) self.test_loader = DataLoader(self.test_ds, sampler=self.test_sampler, **dloader_args) eval_train_sampler = RandomSampler(self.train_ds, replacement=True, num_samples=len(self.train_ds) // 10) eval_test_sampler = RandomSampler(self.test_ds, replacement=True, num_samples=len(self.test_ds) // 2) self.eval_train = DataLoader(self.train_ds, sampler=eval_train_sampler, **dloader_args) self.eval_test = DataLoader(self.test_ds, sampler=eval_test_sampler, **dloader_args) print('optimizers generated') self.board_loss_every = max(len(self.train_loader) // 4, 1) self.evaluate_every = conf.evaluate_every self.save_every = max(conf.epoch_per_save, 1) assert self.save_every >= self.evaluate_every
def __init__(self, conf, inference=False, train_transforms=None, val_transforms=None, train_loader=None): print(conf) if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.milestones = conf.milestones if train_loader is None: self.loader, self.class_num = get_train_loader( conf, train_transforms) else: self.loader = train_loader self.class_num = conf.num_classes if conf.net_mode in ['ir', 'ir_se']: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode, conf.use_gap).to(conf.device) else: import json self.model = MetricNet(model_name=conf.net_mode, pooling=conf.pooling, use_fc=True, fc_dim=conf.embedding_size, dropout=conf.last_fc_dropout, pretrained=conf.pretrained, class_num=self.class_num).to( conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if conf.use_mobilfacenet or conf.net_mode in ['ir', 'ir_se']: self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) else: if conf.loss_module == 'arcface': self.head = ArcMarginProduct(self.model.final_in_features, self.class_num, s=conf.s, m=conf.margin, easy_margin=False, ls_eps=conf.ls_eps).to( conf.device) elif conf.loss_module == 'cosface': self.head = AddMarginProduct(self.model.final_in_features, self.class_num, s=conf.s, m=conf.margin).to(conf.device) elif conf.loss_module == 'adacos': self.head = AdaCos(self.model.final_in_features, self.class_num, m=conf.margin, theta_zero=conf.theta_zero).to( conf.device) else: self.head = nn.Linear(self.model.final_in_features, self.class_num).to(conf.device) print('two model heads generated') if conf.ft_model_path: self.load_ft_model(conf.ft_model_path, not conf.no_strict) elif conf.restore_suffix: self.load_state(conf, conf.restore_suffix, from_save_folder=False, model_only=False) if not inference: self.writer = SummaryWriter(conf.log_path) self.step = 0 paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: params = [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }] wd = 4e-5 else: # if conf.net_mode in ['ir', 'ir_se']: # params = [ # {'params': paras_wo_bn + [self.head.weight], 'weight_decay': 5e-4}, # {'params': paras_only_bn} # ] params = [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }] wd = 5e-4 # else: # params = self.model.parameters() # wd = conf.wd # # params = [ # # {'params': paras_wo_bn + [self.head.weight], 'weight_decay': conf.wd}, # 5e-4}, # # {'params': paras_only_bn} # # ] if conf.optimizer == 'sgd': self.optimizer = optim.SGD( params, lr=conf.lr, momentum=conf.momentum) # , weight_decay=wd) elif conf.optimizer == 'adam': self.optimizer = optim.Adam( params, lr=conf.lr) # , weight_decay=wd) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 5 self.board_loss_every = 20 self.evaluate_every = len(self.loader) self.save_every = len(self.loader) if conf.data_mode == 'common': import json val_img_dir_map = json.loads(conf.val_img_dirs) self.val_dataloaders = {} for val_name in val_img_dir_map: val_img_dir = val_img_dir_map[val_name] val_dataloader, common_val_issame = get_common_val_data( val_img_dir, conf.max_positive_cnt, conf.val_batch_size, conf.val_pin_memory, conf.num_workers, val_transforms=val_transforms, use_pos=not conf.not_use_pos, use_neg=not conf.not_use_neg, val_smapling_type=conf.val_smapling_type, use_keras_model=conf.use_val_left_right_check) self.val_dataloaders[val_name] = [ val_dataloader, common_val_issame ] elif conf.data_mode == 'dacon_landmark': pass else: self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): print(conf) # ----------- define model --------------- # build_model = PreBuildConverter(in_channels=1, out_classes=2, add_soft_max=True) self.models = [] for _ in range(conf.n_models): self.models.append( build_model.get_by_str(conf.net_mode).to(conf.device)) print('{} {} models generated'.format(conf.n_models, conf.net_mode)) # ------------ define loaders -------------- # dloader_args = { 'batch_size': conf.batch_size, 'pin_memory': True, 'num_workers': conf.num_workers, 'drop_last': False, # check that it fits in mem 'shuffle': True } grey_loader = partial(cv2.imread, flags=cv2.IMREAD_GRAYSCALE) file_ext = ('.png', ) im_trans = conf.im_transform self.dataset = DatasetFolder(conf.train_folder, extensions=file_ext, loader=grey_loader, transform=im_trans) self.train_loader = DataLoader(self.dataset, **dloader_args) self.test_ds = DatasetFolder(conf.test_folder, extensions=file_ext, loader=grey_loader, transform=im_trans) self.test_loader = DataLoader(self.test_ds, **dloader_args) if conf.morph_dir: self.morph_ds = DatasetFolder(conf.morph_dir, extensions=file_ext, loader=grey_loader, transform=im_trans) self.morph_loader = DataLoader(self.morph_ds, **dloader_args) else: self.morph_loader = [] # ------------ define params -------------- # self.inference = inference if not inference: self.milestones = conf.milestones self.writer = SummaryWriter(conf.log_path) self.step = 0 print('two model heads generated') paras_only_bn = [] paras_wo_bn = [] for model in self.models: paras_only_bn_, paras_wo_bn_ = separate_bn_paras(model) paras_only_bn.append(paras_only_bn_) paras_wo_bn.append(paras_wo_bn_) self.optimizer = optim.SGD([{ 'params': paras_wo_bn[model_num], 'weight_decay': 5e-4 } for model_num in range(conf.n_models)] + [{ 'params': paras_only_bn[model_num] } for model_num in range(conf.n_models)], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) print('optimizers generated') self.board_loss_every = max(len(self.train_loader) // 5, 1) self.evaluate_every = conf.evaluate_every self.save_every = max(conf.epoch_per_save, 1) assert self.save_every >= self.evaluate_every else: self.threshold = conf.threshold
def __init__(self, conf, inference=False, need_loader=True): print(conf) if conf.use_mobilfacenet: # self.model = MobileFaceNet(conf.embedding_size).to(conf.device) self.model = torch.nn.DataParallel( MobileFaceNet(conf.embedding_size)).cuda() print('MobileFaceNet model generated') else: # self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) self.model = torch.nn.DataParallel( Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode)).cuda() print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones if need_loader: # self.loader, self.class_num = get_train_loader(conf) self.dataset = Dataset2() self.loader = DataLoader(self.dataset, batch_size=conf.batch_size, num_workers=conf.num_workers, shuffle=True, pin_memory=True) # self.loader = Loader2(conf) self.class_num = 85164 print(self.class_num, 'classes, load ok ') else: import copy conf_t = copy.deepcopy(conf) conf_t.data_mode = 'emore' self.loader, self.class_num = get_train_loader(conf_t) print(self.class_num) self.class_num = 85164 lz.mkdir_p(conf.log_path, delete=True) self.writer = SummaryWriter(conf.log_path) self.step = 0 if conf.loss == 'arcface': self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) elif conf.loss == 'softmax': self.head = MySoftmax(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) else: raise ValueError(f'{conf.loss}') print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = 100 # len(self.loader) // 100 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 5 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( self.loader.dataset.root_path) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False, embedding_size=512): conf.embedding_size = embedding_size print(conf) if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).cuda() else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).cuda() print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) parameter_num_cal(self.model) self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.step = 0 self.agedb_30, self.cfp_fp, self.lfw, self.calfw, self.cplfw, self.vgg2_fp, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame, self.calfw_issame, self.cplfw_issame, self.vgg2_fp_issame = get_val_data( self.loader.dataset.root.parent) self.writer = SummaryWriter(conf.log_path) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 if conf.multi_sphere: if conf.arcface_loss: self.head = ArcfaceMultiSphere( embedding_size=conf.embedding_size, classnum=self.class_num, num_shpere=conf.num_sphere, m=conf.m).to(conf.device) elif conf.am_softmax: self.head = MultiAm_softmax( embedding_size=conf.embedding_size, classnum=self.class_num, num_sphere=conf.num_sphere, m=conf.m).to(conf.device) else: self.head = MultiSphereSoftmax( embedding_size=conf.embedding_size, classnum=self.class_num, num_sphere=conf.num_sphere).to(conf.device) else: if conf.arcface_loss: self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to( conf.device) elif conf.am_softmax: self.head = Am_softmax(embedding_size=conf.embedding_size, classnum=self.class_num).to( conf.device) else: self.head = Softmax(embedding_size=conf.embedding_size, classnum=self.class_num).to( conf.device) paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: if conf.multi_sphere: self.optimizer = optim.SGD([{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + self.head.kernel_list, 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: if conf.multi_sphere: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + self.head.kernel_list, 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) self.scheduler = optim.lr_scheduler.ReduceLROnPlateau( self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 5 self.agedb_30, self.cfp_fp, self.lfw, self.calfw, self.cplfw, self.vgg2_fp, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame, self.calfw_issame, self.cplfw_issame, self.vgg2_fp_issame = get_val_data( self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False, transfer=0, ext='final'): pprint.pprint(conf) self.conf = conf if conf.arch == "mobile": self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') elif conf.arch == "ir_se": self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.arch).to(conf.device) print('{}_{} model generated'.format(conf.arch, conf.net_depth)) elif conf.arch == "resnet50": self.model = ResNet(embedding_size=512, arch=conf.arch).to(conf.device) print("resnet model {} generated".format(conf.arch)) else: exit("model not supported yet!") if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) tmp_idx = ext.rfind('_') # find the last '_' to replace it by '/' self.ext = '/' + ext[:tmp_idx] + '/' + ext[tmp_idx + 1:] self.writer = SummaryWriter(str(conf.log_path) + self.ext) self.step = 0 print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if transfer == 3: self.optimizer = optim.Adam( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr) # , momentum = conf.momentum) elif transfer == 2: self.optimizer = optim.Adam( [ { 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 4e-4 }, ], lr=conf.lr) # , momentum = conf.momentum) elif transfer == 1: self.optimizer = optim.Adam( [ { 'params': [self.head.kernel], 'weight_decay': 4e-4 }, ], lr=conf.lr) # , momentum = conf.momentum) else: """ self.optimizer = optim.SGD([ {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, {'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) """ self.optimizer = optim.Adam(list(self.model.parameters()) + list(self.head.parameters()), lr=conf.lr) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.save_freq = len(self.loader) #//5 # originally, 100 self.evaluate_every = len(self.loader) #//5 # originally, 10 self.save_every = len(self.loader) #//2 # originally, 5 # self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(self.loader.dataset.root.parent) # self.val_112, self.val_112_issame = get_val_pair(self.loader.dataset.root.parent, 'val_112') else: self.threshold = conf.threshold self.train_losses = [] self.train_counter = [] self.test_losses = [] self.test_accuracy = [] self.test_counter = []
def __init__(self, conf, inference=False): print(conf) self.lr=conf.lr if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: ############################### ir_se50 ######################################## if conf.struct =='ir_se_50': self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) ############################### resnet101 ###################################### if conf.struct =='ir_se_101': self.model = resnet101().to(conf.device) print('resnet101 model generated') if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 ############################### ir_se50 ######################################## if conf.struct =='ir_se_50': self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) self.head_race = Arcface(embedding_size=conf.embedding_size, classnum=4).to(conf.device) ############################### resnet101 ###################################### if conf.struct =='ir_se_101': self.head = ArcMarginModel(embedding_size=conf.embedding_size,classnum=self.class_num).to(conf.device) self.head_race = ArcMarginModel(embedding_size=conf.embedding_size,classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD([ {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, {'params': [paras_wo_bn[-1]] + [self.head.kernel] + [self.head_race.kernel], 'weight_decay': 4e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) else: self.optimizer = optim.SGD([ {'params': paras_wo_bn + [self.head.kernel] + [self.head_race.kernel], 'weight_decay': 5e-4}, {'params': paras_only_bn} ], lr = conf.lr, momentum = conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') print('len of loader:',len(self.loader)) self.board_loss_every = len(self.loader)//min(len(self.loader),100) self.evaluate_every = len(self.loader)//1 self.save_every = len(self.loader)//1 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(conf.val_folder) else: #self.threshold = conf.threshold pass
def __init__(self, conf, args, inference=False): print(conf) self.local_rank = args.local_rank if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).cuda() print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).cuda() print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) #[self.model, self.head], self.optimizer = amp.initialize([self.model, self.head], self.optimizer, opt_level='O1') [self.model, self.head ], self.optimizer = amp.initialize([self.model, self.head], self.optimizer, opt_level='O3', keep_batchnorm_fp32=True) print(self.optimizer, args.local_rank) self.head = DistributedDataParallel(self.head) self.model = DistributedDataParallel(self.model) #self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[args.local_rank]) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 5 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): print(conf) if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones print('prepare train loader..') self.loader, self.class_num = get_train_loader(conf) current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") self.writer = SummaryWriter(str(conf.log_path / current_time)) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) self.lrscheduler = optim.lr_scheduler.ReduceLROnPlateau( self.optimizer, factor=0.1, patience=20, verbose=True) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') # len(self.loader): number of batches? self.board_loss_every = len(self.loader) // 120 self.evaluate_every = len(self.loader) // 40 self.save_every = len(self.loader) // 40 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( self.loader.dataset.root.parent) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) self.growup = GrowUP().to(conf.device) self.discriminator = Discriminator().to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) if conf.discriminator: self.child_loader, self.adult_loader = get_train_loader_d(conf) os.makedirs(conf.log_path, exist_ok=True) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) # Will not use anymore if conf.use_dp: self.model = nn.DataParallel(self.model) self.head = nn.DataParallel(self.head) print(self.class_num) print(conf) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) if conf.discriminator: self.optimizer_g = optim.Adam(self.growup.parameters(), lr=1e-4, betas=(0.5, 0.999)) self.optimizer_g2 = optim.Adam(self.growup.parameters(), lr=1e-4, betas=(0.5, 0.999)) self.optimizer_d = optim.Adam(self.discriminator.parameters(), lr=1e-4, betas=(0.5, 0.999)) self.optimizer2 = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) if conf.finetune_model_path is not None: self.optimizer = optim.SGD([{ 'params': paras_wo_bn, 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print('optimizers generated') self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 2 self.save_every = len(self.loader) dataset_root = "/home/nas1_userD/yonggyu/Face_dataset/face_emore" self.lfw = np.load( os.path.join(dataset_root, "lfw_align_112_list.npy")).astype(np.float32) self.lfw_issame = np.load( os.path.join(dataset_root, "lfw_align_112_label.npy")) self.fgnetc = np.load( os.path.join(dataset_root, "FGNET_new_align_list.npy")).astype(np.float32) self.fgnetc_issame = np.load( os.path.join(dataset_root, "FGNET_new_align_label.npy")) else: # Will not use anymore # self.model = nn.DataParallel(self.model) self.threshold = conf.threshold
def __init__(self, conf, train=True): make_dir(conf.work_path) make_dir(conf.model_path) make_dir(conf.log_path) if conf.gpu_ids: assert torch.cuda.is_available(), 'GPU is not avalialble!' torch.backends.cudnn.benckmark = True conf.device = torch.device('cuda') else: conf.device = torch.device('cpu') self.gpu_ids = conf.gpu_ids self.model = None self.net_type = '{}_{}'.format(conf.net_mode, conf.net_depth) if conf.net_mode == 'ir' or conf.net_mode == 'ir_se': self.model = IRNet(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) elif conf.net_mode == 'resnet': if conf.net_depth == 18: self.model = ResNet_18().to(conf.device) elif conf.net_depth == 34: self.model = ResNet_34().to(conf.device) elif conf.net_depth == 50: self.model = ResNet_50().to(conf.device) elif conf.net_depth == 101: self.model = ResNet_101().to(conf.device) elif conf.net_depth == 152: self.model = ResNet_152().to(conf.device) else: raise NotImplementedError( "Model {}_{} is not implemented".format( conf.net_mode, conf.net_depth)) elif conf.net_mode == 'lightcnn': if conf.net_depth == 9: self.model = LightCNN_9Layers(drop_ratio=conf.drop_ratio).to( conf.device) elif conf.net_depth == 29: self.model = LightCNN_29Layers(drop_ratio=conf.drop_ratio).to( conf.device) else: raise NotImplementedError( "Model {}_{} is not implemented".format( conf.net_mode, conf.net_depth)) else: NotImplementedError("Model {}_{} is not implemented".format( conf.net_mode, conf.net_depth)) assert self.model is not None, "Model is NONE!!" if train: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_ADAM: self.optimizer = optim.Adam( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, betas=(0.9, 0.999)) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) # if conf.cosine_lr == True: # self.scheduler = CosineAnnealingWarmUpRestarts(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 5 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( conf.data_folder)
def __init__(self, conf, inference=False): print(conf) self.num_splits = int(conf.meta_file.split('_labels.txt')[0][-1]) if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size) print('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if conf.device > 1: gpu_ids = list( range(0, min(torch.cuda.device_count(), conf.device))) self.model = nn.DataParallel(self.model, device_ids=gpu_ids).cuda() else: self.model = self.model.cuda() if not inference: self.milestones = conf.milestones if conf.remove_single is True: conf.meta_file = conf.meta_file.replace('.txt', '_clean.txt') meta_file = open(conf.meta_file, 'r') meta = meta_file.readlines() pseudo_all = [int(item.split('\n')[0]) for item in meta] pseudo_classnum = set(pseudo_all) if -1 in pseudo_classnum: pseudo_classnum = len(pseudo_classnum) - 1 else: pseudo_classnum = len(pseudo_classnum) print('classnum:{}'.format(pseudo_classnum)) pseudo_classes = [ pseudo_all[count[index]:count[index + 1]] for index in range(self.num_splits) ] meta_file.close() train_dataset = [get_train_dataset(conf.emore_folder)] + [ get_pseudo_dataset([conf.pseudo_folder, index + 1], pseudo_classes[index], conf.remove_single) for index in range(self.num_splits) ] self.class_num = [num for _, num in train_dataset] print('Loading dataset done') train_longest_size = [len(item[0]) for item in train_dataset] temp = int(np.floor(conf.batch_size // (self.num_splits + 1))) self.batch_size = [conf.batch_size - temp * self.num_splits ] + [temp] * self.num_splits train_longest_size = max([ int(np.floor(td / bs)) for td, bs in zip(train_longest_size, self.batch_size) ]) train_sampler = [ GivenSizeSampler(td[0], total_size=train_longest_size * bs, rand_seed=None) for td, bs in zip(train_dataset, self.batch_size) ] self.train_loader = [ DataLoader(train_dataset[k][0], batch_size=self.batch_size[k], shuffle=False, pin_memory=conf.pin_memory, num_workers=conf.num_workers, sampler=train_sampler[k]) for k in range(1 + self.num_splits) ] print('Loading loader done') self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = [ Arcface(embedding_size=conf.embedding_size, classnum=self.class_num[0]), Arcface(embedding_size=conf.embedding_size, classnum=pseudo_classnum) ] if conf.device > 1: self.head = [ nn.DataParallel(self.head[0], device_ids=gpu_ids).cuda(), nn.DataParallel(self.head[1], device_ids=gpu_ids).cuda() ] else: self.head = [self.head[0].cuda(), self.head[1].cuda()] print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model.module) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.parameters()], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: params = [a.module.parameters() for a in self.head] params = list(params[0]) + list(params[1]) #from IPython import embed;embed() self.optimizer = optim.SGD([{ 'params': paras_wo_bn + params, 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) print(self.optimizer) if conf.resume is not None: self.start_epoch = self.load_state(conf.resume) else: self.start_epoch = 0 print('optimizers generated') self.board_loss_every = len(self.train_loader[0]) // 10 self.evaluate_every = len(self.train_loader[0]) // 5 self.save_every = len(self.train_loader[0]) // 5 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( conf.eval_path) else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): print(conf) if conf.use_mobilfacenet: self.model = MobileFaceNet(conf.embedding_size).to(conf.device) print('MobileFaceNet model generated') elif conf.use_shufflenetV2: #self.model = ShuffleNetV2().to(conf.device) self.model = model.shufflenet().to(conf.device) print("ShufflenetV2 model generated") else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device) print('{}_{} model generated'.format(conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.writer = SummaryWriter(conf.log_path) self.step = 0 self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num).to(conf.device) print('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) # elif conf.use_shufflenetV2: # self.optimizer = optim.SGD([ # {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5}, # {'params': [paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4}, # {'params': paras_only_bn} # ], lr = conf.lr*10, momentum = conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr * 10, momentum=conf.momentum) print(self.optimizer) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) print('optimizers generated') self.board_loss_every = len(self.loader) // 100 self.evaluate_every = len(self.loader) // 10 self.save_every = len(self.loader) // 5 self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( '/root/NewDisk/daxing2/WW/data/faces_vgg_112x112/' ) #self.loader.dataset.root.parent else: self.threshold = conf.threshold
def __init__(self, conf, inference=False): accuracy = 0.0 logger.debug(conf) if conf.use_mobilfacenet: # self.model = MobileFaceNet(conf.embedding_size).to(conf.device) self.model = MobileFaceNet(conf.embedding_size).cuda() logger.debug('MobileFaceNet model generated') else: self.model = Backbone(conf.net_depth, conf.drop_ratio, conf.net_mode).cuda() #.to(conf.device) logger.debug('{}_{} model generated'.format( conf.net_mode, conf.net_depth)) if not inference: self.milestones = conf.milestones self.writer = SummaryWriter(conf.log_path) self.step = 0 logger.info('loading data...') self.loader_arc, self.class_num_arc = get_train_loader( conf, 'emore', sample_identity=False) # self.loader_tri, self.class_num_tri = get_train_loader(conf, 'glint', sample_identity=True) emore_root = conf.data_path / 'train' / 'faces_emore_16_per_peron' / 'imgs' kc_root = conf.data_path / 'test' / 'kc_employee_dynamic_112' self.loader_tri, self.class_num_tri = get_train_loader_concat( conf, [emore_root, kc_root], sample_identity=True) self.head_arc = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num_arc).cuda() self.head_tri = Triplet().cuda() logger.debug('two model heads generated') paras_only_bn, paras_wo_bn = separate_bn_paras(self.model) if conf.use_mobilfacenet: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn[:-1], 'weight_decay': 4e-5 }, { 'params': [paras_wo_bn[-1]] + [self.head_arc.kernel], 'weight_decay': 4e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) else: self.optimizer = optim.SGD( [{ 'params': paras_wo_bn + [self.head_arc.kernel], 'weight_decay': 5e-4 }, { 'params': paras_only_bn }], lr=conf.lr, momentum=conf.momentum) # self.optimizer = torch.nn.parallel.DistributedDataParallel(optimizer,device_ids=[conf.argsed]) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) # 断点加载训练 if conf.resume: logger.debug('resume...') self.load_state(conf, 'last.pth', from_save_folder=True) if conf.fp16: self.model, self.optimizer = amp.initialize(self.model, self.optimizer, opt_level="O2") self.model = DistributedDataParallel(self.model).cuda() else: self.model = torch.nn.parallel.DistributedDataParallel( self.model, device_ids=[conf.argsed], find_unused_parameters=True).cuda( ) #add line for distributed self.board_loss_every = len(self.loader_arc) // 100 self.evaluate_every = len(self.loader_arc) // 2 self.save_every = len(self.loader_arc) // 2 # self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(Path(self.loader_arc.dataset.root).parent) self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data( conf.emore_folder) else: self.threshold = conf.threshold self.loader, self.query_ds, self.gallery_ds = get_test_loader(conf)