def main(project_name): logger = Logger('_02_valid_model_{}'.format(project_name)) logger.info('=' * 50) model_path = '_model/embedding_model_{}.pt'.format(project_name) logger.info('load model from {}'.format(model_path)) model = torch.load(model_path) evaluator = Evaluator() evaluator.evaluate(model)
def main(): args = parse_args() update_config(args.cfg_file) if args.gpus: config.GPUS = args.gpus else: config.CUDA = False if args.workers: config.WORKERS = args.workers print('Using config:') pprint.pprint(config) torch.backends.cudnn.benchmark = config.CUDNN.BENCHMARK torch.backends.cudnn.deterministic = config.CUDNN.DETERMINISTIC torch.backends.cudnn.enabled = config.CUDNN.ENABLED if config.CUDA: os.environ["CUDA_VISIBLE_DEVICES"] = config.GPUS device = torch.device('cuda' if config.CUDA else 'cpu') # Redirect print to both console and log file sys.stdout = Logger(osp.join(config.OUTPUT_DIR, 'log-eval.txt')) # Create data loaders dataset = DataSet(config.DATASET.ROOT, config.DATASET.DATASET) normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transformer = T.Compose([ T.Resize(config.MODEL.IMAGE_SIZE, interpolation=3), T.ToTensor(), normalizer, ]) query_loader = DataLoader( Preprocessor(dataset.query, root=osp.join(dataset.images_dir, dataset.query_path), transform=transformer), batch_size=config.TEST.BATCH_SIZE, num_workers=config.WORKERS, shuffle=False, pin_memory=True) gallery_loader = DataLoader( Preprocessor(dataset.gallery, root=osp.join(dataset.images_dir, dataset.gallery_path), transform=transformer), batch_size=config.TEST.BATCH_SIZE, num_workers=config.WORKERS, shuffle=False, pin_memory=True) # Create model model = models.create(config.MODEL.NAME) # Load from checkpoint checkpoint = load_checkpoint(config.TEST.MODEL_FILE) print('best model at epoch: {}'.format(checkpoint['epoch'])) model.load_state_dict(checkpoint['state_dict'], strict=False) # Set model model = nn.DataParallel(model).to(device) print('Test with best model:') evaluator = Evaluator(model) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, config.TEST.OUTPUT_FEATURES)
def train(model, project_name): sampler = Sampler() loader = ImgLoader('../../input_large_delf/train') evaluator = Evaluator() dir_model = '_model' os.makedirs(dir_model, exist_ok=True) # for training batch_size = 240 group_size = 12 iter_outside = 10 iter_inside = 500 optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4) for param_group in optimizer.param_groups: logger.info('start lerning rate with: {:.6f}'.format( param_group['lr'])) for ep in range(1, iter_outside + 1): logger.info('-' * 30) logger.info('epoch: {:d}'.format(ep)) model.train() if ep > 1: set_batch_norm_eval(model) train_loss1 = 0 train_loss3 = 0 count_sample = 0 ave_good_index = 0 for _ in tqdm(range(iter_inside)): batch = torch.FloatTensor(batch_size * group_size, 40, 1000).zero_() ids = sampler.get_sample(batch_size, group_size) for i in range(batch_size * group_size): batch[i] = loader.load_image('{}.delf'.format(ids[i])) batch_cuda = batch.cuda() # forward with requires_grad=False v_batch_no_bp = Variable(batch_cuda, volatile=True) optimizer.zero_grad() out = model.forward(v_batch_no_bp) batch_indeces, num_good_index = get_apn_index( out, batch_size, group_size) # forward with requires_grad=True v_batch = Variable(batch_cuda[batch_indeces, :, :]) optimizer.zero_grad() out = model.forward(v_batch) out_anchor = out[:batch_size] hard_positive = out[batch_size:batch_size * 2] hard_negative = out[batch_size * 2:batch_size * 3] # calc loss loss1 = smooth_pairwise_loss(out_anchor, hard_positive) * 0.1 loss3 = hard_negative_triplet_loss(out_anchor, hard_positive, hard_negative) loss = loss3 loss.backward() optimizer.step() train_loss1 += float(loss1.data.cpu().numpy()) * batch_size train_loss3 += float(loss3.data.cpu().numpy()) * batch_size ave_good_index += num_good_index * batch_size count_sample += batch_size logger.info('train loss (pair-pos): {:.6f}'.format(train_loss1 / count_sample)) logger.info('train loss (triplet) : {:.6f}'.format(train_loss3 / count_sample)) logger.info('average number of far negative: {:.2f} / {:d}'.format( ave_good_index / count_sample, batch_size)) evaluator.evaluate(model) if ep % 4 == 0 and ep != iter_outside: model_name = 'embedding_model_{}_ep{}.pt'.format(project_name, ep) logger.info('save model: {}'.format(model_name)) torch.save(model, os.path.join(dir_model, model_name)) if ep % 8 == 0: for param_group in optimizer.param_groups: param_group['lr'] *= 0.1 logger.info('change learning rate into: {:.6f}'.format( param_group['lr'])) model_name = 'embedding_model_{}.pt'.format(project_name) logger.info('save model: {}'.format(model_name)) torch.save(model, os.path.join(dir_model, model_name))
def train(model, project_name): sampler = SubSampler() list_train_imgs = sampler.get_train_imgs() dataset = LandmarkDataset('../../input_large_delf/train', list_train_imgs) evaluator = Evaluator() dir_model = '_model' os.makedirs(dir_model, exist_ok=True) # for training batch_size = 240 group_size = 12 iter_outside = 10 iter_inside = 600 optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3) scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=iter_outside * iter_inside) for param_group in optimizer.param_groups: logger.info('start lerning rate with: {:.6f}'.format(param_group['lr'])) for ep in range(1, iter_outside + 1): logger.info('-' * 30) logger.info('epoch: {:d}'.format(ep)) for param_group in optimizer.param_groups: logger.info('current lerning rate with: {:.8f}'.format(param_group['lr'])) model.train() if ep > 1: set_batch_norm_eval(model) train_loss1 = 0 train_loss3 = 0 count_sample = 0 ave_good_index = 0 pt_sampler = PyTorchSampler(sampler, batch_size, group_size, iter_inside) dataloader = DataLoader(dataset, batch_sampler=pt_sampler, num_workers=8) for batch in tqdm(dataloader): batch_cuda = batch.cuda() # forward with requires_grad=False with torch.no_grad(): v_batch_no_bp = batch_cuda optimizer.zero_grad() out = model.forward(v_batch_no_bp) batch_indeses, num_good_index = get_apn_index(out, batch_size, group_size) # forward with requires_grad=True v_batch = batch_cuda[batch_indeses, ...] optimizer.zero_grad() out = model.forward(v_batch) out_anchor = out[:batch_size] hard_positive = out[batch_size:batch_size*2] hard_negative = out[batch_size*2:batch_size*3] # calc loss loss1 = smooth_pairwise_loss(out_anchor, hard_positive) * 0.1 loss3 = hard_negative_triplet_loss(out_anchor, hard_positive, hard_negative) loss = loss3 loss.backward() optimizer.step() scheduler.step() train_loss1 += float(loss1.data.cpu().numpy()) * batch_size train_loss3 += float(loss3.data.cpu().numpy()) * batch_size ave_good_index += num_good_index * batch_size count_sample += batch_size logger.info('train loss (pair-pos): {:.6f}'.format(train_loss1 / count_sample)) logger.info('train loss (triplet) : {:.6f}'.format(train_loss3 / count_sample)) logger.info('average number of far negative: {:.2f} / {:d}'.format(ave_good_index / count_sample, batch_size)) evaluator.evaluate(model) if ep % 4 == 0 and ep != iter_outside: model_name = 'embedding_model_{}_ep{}.pt'.format(project_name, ep) logger.info('save model: {}'.format(model_name)) torch.save(model, os.path.join(dir_model, model_name)) model_name = 'embedding_model_{}.pt'.format(project_name) logger.info('save model: {}'.format(model_name)) torch.save(model, os.path.join(dir_model, model_name))
def main(): args = parse_args() update_config(args.cfg_file) if args.gpus: config.GPUS = args.gpus else: config.CUDA = False if args.workers: config.WORKERS = args.workers print('Using config:') pprint.pprint(config) if args.manualSeed is None: args.manualSeed = random.randint(1, 10000) random.seed(args.manualSeed) np.random.seed(args.manualSeed) torch.manual_seed(args.manualSeed) if config.CUDA: torch.cuda.manual_seed_all(args.manualSeed) torch.backends.cudnn.benchmark = config.CUDNN.BENCHMARK torch.backends.cudnn.deterministic = config.CUDNN.DETERMINISTIC torch.backends.cudnn.enabled = config.CUDNN.ENABLED if config.CUDA: os.environ["CUDA_VISIBLE_DEVICES"] = config.GPUS device = torch.device('cuda' if config.CUDA else 'cpu') # Redirect print to both console and log file sys.stdout = Logger(osp.join(config.OUTPUT_DIR, 'log.txt')) # Create data loaders dataset = DataSet(config.DATASET.ROOT, config.DATASET.DATASET) normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transformer = T.Compose([ T.RandomSizedRectCrop(*config.MODEL.IMAGE_SIZE), T.RandomHorizontalFlip(), T.RandomRotation(10), T.ColorJitter(0.2, 0.2, 0.2), T.ToTensor(), normalizer, T.RandomErasing(EPSILON=config.DATASET.RE), ]) test_transformer = T.Compose([ T.Resize(config.MODEL.IMAGE_SIZE, interpolation=3), T.ToTensor(), normalizer, ]) train_loader = DataLoader(UnsupervisedCamStylePreprocessor( dataset.train, root=osp.join(dataset.images_dir, dataset.train_path), camstyle_root=osp.join(dataset.images_dir, dataset.train_camstyle_path), num_cam=dataset.num_cam, use_gan=True, transform=train_transformer), batch_size=config.TRAIN.BATCH_SIZE, num_workers=config.WORKERS, shuffle=config.TRAIN.SHUFFLE, pin_memory=True, drop_last=False) query_loader = DataLoader(Preprocessor(dataset.query, root=osp.join( dataset.images_dir, dataset.query_path), transform=test_transformer), batch_size=config.TEST.BATCH_SIZE, num_workers=config.WORKERS, shuffle=False, pin_memory=True) gallery_loader = DataLoader(Preprocessor(dataset.gallery, root=osp.join( dataset.images_dir, dataset.gallery_path), transform=test_transformer), batch_size=config.TEST.BATCH_SIZE, num_workers=config.WORKERS, shuffle=False, pin_memory=True) # Create model model = models.create(config.MODEL.NAME, pretrained=config.MODEL.PRETRAINED, num_classes=dataset.num_train_ids) # Memory Network num_tgt = len(dataset.train) memory = models.create('memory', config.MODEL.FEATURES, num_tgt) # Load from checkpoint if config.TRAIN.RESUME: checkpoint = load_checkpoint(config.TRAIN.CHECKPOINT) model.load_state_dict(checkpoint['state_dict'], strict=False) memory.load_state_dict(checkpoint['state_dict_memory'], strict=False) print("=> Start epoch {} ".format(checkpoint['epoch'])) # Set model model = nn.DataParallel(model).to(device) memory = memory.to(device) # Optimizer base_param_ids = set(map(id, model.module.base.parameters())) base_params_need_for_grad = filter(lambda p: p.requires_grad, model.module.base.parameters()) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [{ 'params': base_params_need_for_grad, 'lr_mult': 0.1 }, { 'params': new_params, 'lr_mult': 1.0 }] optimizer = get_optimizer(config, param_groups) # Trainer trainer = Trainer(config, model, memory) def adjust_lr(epoch): step_size = config.TRAIN.LR_STEP lr = config.TRAIN.LR * (config.TRAIN.LR_FACTOR**(epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) best_r1 = 0.0 # Start training for epoch in range(config.TRAIN.BEGIN_EPOCH, config.TRAIN.END_EPOCH): # lr_scheduler.step() adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) print('Test with latest model:') evaluator = Evaluator(model) r1 = evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, config.TEST.OUTPUT_FEATURES) if r1 > best_r1: best_r1 = r1 save_checkpoint( { 'state_dict': model.module.state_dict(), 'state_dict_memory': memory.state_dict(), 'epoch': epoch + 1, }, fpath=osp.join(config.OUTPUT_DIR, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} \n'.format(epoch)) # Final test print('Test with best model:') evaluator = Evaluator(model) checkpoint = load_checkpoint( osp.join(config.OUTPUT_DIR, 'checkpoint.pth.tar')) print('best model at epoch: {}'.format(checkpoint['epoch'])) model.module.load_state_dict(checkpoint['state_dict']) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, config.TEST.OUTPUT_FEATURES)