def test_with_open_reid(args): # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.num_instances, args.workers, args.combine_trainval) # Create model model = models.create(args.arch, num_features=1024, dropout=args.dropout, num_classes=args.features) model = nn.DataParallel(model).cuda() print('Test with best model:') # checkpoint = load_checkpoint(osp.join(args.logs_dir, 'checkpoint.pth.tar')) checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main_worker(args): cudnn.benchmark = True log_dir = osp.dirname(args.resume) sys.stdout = Logger(osp.join(log_dir, 'log_test.txt')) # Create data loaders dataset_target, test_loader_target = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers) # Create model model = models.create(args.arch, num_features=args.features, num_classes=0) model.cuda() model = nn.DataParallel(model) # Load from checkpoint checkpoint = load_checkpoint(args.resume) copy_state_dict(checkpoint, model) # Evaluator evaluator = Evaluator(model) print("Testing...") evaluator.evaluate(test_loader_target, dataset_target.query, dataset_target.gallery, cmc_flag=True, args=args, rerank=args.rerank) return
def evaluate(self, query, gallery): # 得到测试数据 test_loader = self.get_dataloader(list(set(query) | set(gallery)), training=False) evaluator = Evaluator(self.model) # 评估器 rank1, mAP = evaluator.evaluate(test_loader, query, gallery) # 得到rank1准确率和mAP return rank1, mAP
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Not sure about this one metric = DistanceMetric(algorithm='euclidean') for test_set in args.test_sets: dataset, _, loader = load_dataset(args.architecture, dataset=test_set) cmcs = {} for batch_id in args.batch_ids: benchmark_dir = os.path.join(working_dir, 'benchmarks', batch_id, args.loss, args.architecture) _, num_classes, _ = load_dataset(args.architecture, dataset='synthetic', batch_id=batch_id) model = setup_model(args.loss, args.architecture, num_classes) model = nn.DataParallel(model).cuda() checkpoint = load_checkpoint( os.path.join(benchmark_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) evaluator = Evaluator(model) cmcs[batch_id] = evaluator.test(loader, dataset.query, dataset.gallery, metric) plot(args, os.path.join(working_dir, 'plots'), cmcs, test_set)
def main_worker(args): cudnn.benchmark = True log_dir = osp.dirname(args.resume) sys.stdout = Logger(osp.join(log_dir, 'log_test.txt')) print("==========\nArgs:{}\n==========".format(args)) # Create data loaders dataset_target, test_loader_target = \ get_data(args.dataset_target, args.data_dir, args.height, args.width, args.batch_size, args.workers) # Create model model = models.create(args.arch, pretrained=False, cut_at_pooling=args.cut_at_pooling, num_features=args.features, dropout=args.dropout, num_classes=0) model.cuda() model = nn.DataParallel(model) # Load from checkpoint checkpoint = load_checkpoint(args.resume) copy_state_dict(checkpoint['state_dict'], model) # start_epoch = checkpoint['epoch'] # best_mAP = checkpoint['best_mAP'] # print("=> Checkpoint of epoch {} best mAP {:.1%}".format(start_epoch, best_mAP)) # Evaluator evaluator = Evaluator(model) print("Test on the target domain of {}:".format(args.dataset_target)) evaluator.evaluate(test_loader_target, dataset_target.query, dataset_target.gallery, cmc_flag=True, rerank=args.rerank) return
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = "0" #device_ids = [0, 1, 2, 3] np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, query_loader, gallery_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers, ) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes, cut_at_pooling=False, FCN=True) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model_dict = model.state_dict() checkpoint_load = { k: v for k, v in (checkpoint['state_dict']).items() if k in model_dict } model_dict.update(checkpoint_load) model.load_state_dict(model_dict) # model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format( start_epoch, best_top1)) #model = nn.DataParallel(model) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model) # Final test print('Test with best model:') checkpoint = load_checkpoint('checkpoint.pth.tar') model.module.load_state_dict(checkpoint['state_dict']) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery)
def evaluate(self, query, gallery): test_loader = self.get_dataloader(list(set(query) | set(gallery)), training = False) param = self.model.state_dict() del self.model model = models.create(self.model_name, dropout=self.dropout, num_classes=self.num_classes, is_output_feature = True) self.model = nn.DataParallel(model).cuda() self.model.load_state_dict(param) evaluator = Evaluator(self.model) evaluator.evaluate(test_loader, query, gallery)
def evaluate(model, dataset, params, metric=None): query, gallery = dataset.query, dataset.gallery dataloader = dp.get_dataloader( list(set(dataset.query) | set(dataset.gallery)), dataset.images_dir, **params) metric = DistanceMetric(algorithm='euclidean') metric.train(model, dataloader) evaluator = Evaluator(model) evaluator.evaluate(dataloader, query, gallery, metric)
def evaluate(self, query, gallery, step): _load_path = osp.join( self.load_path, 'features_{}_step{}.pickle'.format(self.name, step)) test_loader = self.get_dataloader(list(set(query) | set(gallery)), training=False) evaluator = Evaluator(self.model) rank1, mAP = evaluator.evaluate(test_loader, _load_path, query, gallery) return rank1, mAP
def iter_trainer(model, dataset, train_loader, eug_dataloader, test_loader, optimizer, criterion, epochs, logs_dir, print_freq, lr): # Trainer best_top1 = 0 # trainer = Trainer(model, criterion) if eug_dataloader is None: trainer = FinedTrainer2(model, criterion) evaluator = Evaluator(model, print_freq=print_freq) # Start training for epoch in range(0, epochs): adjust_lr(lr, epoch, optimizer) trainer.train(epoch, train_loader, optimizer) else: trainer = JointTrainer2(model, criterion) evaluator = Evaluator(model, print_freq=print_freq) # Start training for epoch in range(0, epochs): adjust_lr(lr, epoch, optimizer) trainer.train(epoch, train_loader, eug_dataloader, optimizer) #evaluate top1 = evaluator.evaluate(test_loader, dataset.query, dataset.gallery) return top1
def evaluate(model, dataset, config): config.set_training(False) query, gallery = dataset.query, dataset.gallery dataloader = dp.get_dataloader( list(set(dataset.query) | set(dataset.gallery)), dataset.images_dir, config) metric = DistanceMetric(algorithm=config.dist_metric) metric.train(model, dataloader) evaluator = Evaluator(model) evaluator.evaluate(dataloader, query, gallery, metric, print_freq=config.batch_size)
def iter_trainer(model, dataset, train_loader_list, test_loader, optimizer, criterion, epochs, logs_dir, print_freq): # Trainer best_top1 = 0 # trainer = Trainer(model, criterion) trainer = FinedTrainer2(model, criterion) evaluator = Evaluator(model, print_freq=print_freq) # Start training for epoch in range(0, epochs): # trainer.train(epoch, train_loader, optimizer) trainer.train(epoch, train_loader_list, optimizer) #evaluate top1 = evaluator.evaluate(test_loader, dataset.query, dataset.gallery) return top1
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.combine_trainval) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes) start_epoch = best_top1 = 0 model = nn.DataParallel(model).cuda() if args.resume: #checkpoint = load_checkpoint(args.resume) #state_dict = get_state_dict(checkpoint['state_dict'],model.state_dict()) #model.load_state_dict(state_dict) #start_epoch = checkpoint['epoch'] #best_top1 = checkpoint['best_top1'] #print("=> Start epoch {} best top1 {:.1%}" # .format(start_epoch, best_top1)) state_dict = torch.load(args.resume) state_dict = get_state_dict(state_dict, model.state_dict()) model.load_state_dict(state_dict) # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main(argv): #parser parser = argparse.ArgumentParser(description='test part bilinear network') parser.add_argument('--exp-dir', type=str, default='logs/market1501/exp1') parser.add_argument('--target-epoch', type=int, default=750) parser.add_argument('--gpus', type=str, default='0') args = parser.parse_args(argv) # Settings exp_dir = args.exp_dir target_epoch = args.target_epoch batch_size = 50 gpu_ids = args.gpus set_paths('paths') os.environ['CUDA_VISIBLE_DEVICES'] = gpu_ids args = json.load(open(osp.join(exp_dir, "args.json"), "r")) # Load data t = T.Compose([ T.RectScale(args['height'], args['width']), T.CenterCrop((args['crop_height'], args['crop_width'])), T.ToTensor(), T.RGB_to_BGR(), T.NormalizeBy(255), ]) dataset = datasets.create(args['dataset'], 'data/{}'.format(args['dataset'])) dataset_ = Preprocessor(list(set(dataset.query) | set(dataset.gallery)), root=dataset.images_dir, transform=t) dataloader = DataLoader(dataset_, batch_size=batch_size, shuffle=False) # Load model model = models.create(args['arch'], dilation=args['dilation'], use_relu=args['use_relu'], initialize=False).cuda() weight_file = osp.join(exp_dir, 'epoch_{}.pth.tar'.format(target_epoch)) model.load(load_checkpoint(weight_file)) model.eval() # Evaluate evaluator = Evaluator(model) evaluator.evaluate(dataloader, dataset.query, dataset.gallery)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) np.random.seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file name = f'{args.dataset}-{args.arch}' logs_dir = f'logs/softmax-loss/{name}' # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.combine_trainval) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, cos_output=args.cos_output) # Load from checkpoint start_epoch = best_top1 = 0 checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict'], strict=False) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format(start_epoch, best_top1)) model = model.cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model, normalize_features=True) # args.cos_output) metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def evaluate(args): # Settings exp_dir = './logs/{}/{}'.format(args.dataset, args.exp) target_epoch = args.epoch batch_size = args.batchsize gpu_ids = args.gpus set_paths('paths') os.environ['CUDA_VISIBLE_DEVICES'] = gpu_ids args = json.load(open(osp.join(exp_dir, "args.json"), "r")) # Load data t = T.Compose([ T.RectScale(args['height'], args['width']), T.CenterCrop((args['crop_height'], args['crop_width'])), T.ToTensor(), T.RGB_to_BGR(), T.NormalizeBy(255), ]) dataset = datasets.create(args['dataset'], 'data/{}'.format(args['dataset'])) dataset_ = Preprocessor(list(set(dataset.query) | set(dataset.gallery)), root=dataset.images_dir, transform=t) dataloader = DataLoader(dataset_, batch_size=batch_size, shuffle=False) # Load model model = models.create(args['arch'], dilation=args['dilation'], use_relu=args['use_relu'], initialize=False).cuda() weight_file = osp.join(exp_dir, 'epoch_{}.pth.tar'.format(target_epoch)) model.load(load_checkpoint(weight_file)) model.eval() # Evaluate evaluator = Evaluator(model) evaluator.evaluate(dataloader, dataset.query, dataset.gallery)
def main(args): cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders dataset, num_classes, train_loader, query_loader, gallery_loader, camstyle_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.camstyle, args.re, 0 if args.debug else args.workers, camstyle_path = args.camstyle_path) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes) # Load from checkpoint start_epoch = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] print("=> Start epoch {} ".format(start_epoch)) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model, args.logs_dir) if args.evaluate: print("Test:") evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, args.output_feature, args.rerank) return # Criterion criterion = nn.CrossEntropyLoss().cuda() # Optimizer base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [{ 'params': model.module.base.parameters(), 'lr_mult': 0.1 }, { 'params': new_params, 'lr_mult': 1.0 }] optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer if args.camstyle == 0: trainer = Trainer(model, criterion) else: trainer = CamStyleTrainer(model, criterion, camstyle_loader) # Schedule learning rate def adjust_lr(epoch): step_size = 40 lr = args.lr * (0.1**(epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) save_checkpoint( { 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, }, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} \n'.format(epoch)) # Final test print('Test with best model:') evaluator = Evaluator(model, args.logs_dir) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, args.output_feature, args.rerank)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) # get source data src_dataset, src_extfeat_loader = \ get_source_data(args.src_dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers) # get target data tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \ get_data(args.tgt_dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers) # Create model # Hacking here to let the classifier be the number of source ids if args.src_dataset == 'dukemtmc': model = models.create(args.arch, num_classes=632, pretrained=False) elif args.src_dataset == 'market1501': model = models.create(args.arch, num_classes=676, pretrained=False) else: raise RuntimeError('Please specify the number of classes (ids) of the network.') # Load from checkpoint if args.resume: print('Resuming checkpoints from finetuned model on another dataset...\n') checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict'], strict=False) else: raise RuntimeWarning('Not using a pre-trained model.') model = nn.DataParallel(model).cuda() # evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery) # if args.evaluate: return # Criterion criterion = [ # TripletLoss(args.margin, args.num_instances, isAvg=True, use_semi=True).cuda(), SortedTripletLoss(args.margin, isAvg=True).cuda(), # HoughTripletLoss(args.margin, args.num_instances, isAvg=True, use_semi=True).cuda(), # None, None, None, None ] # Optimizer optimizer = torch.optim.Adam( model.parameters(), lr=args.lr ) # training stage transformer on input images normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transformer = T.Compose([ T.Resize((args.height,args.width)), T.RandomHorizontalFlip(), T.ToTensor(), normalizer, T.RandomErasing(probability=0.5, sh=0.2, r1=0.3) ]) evaluator = Evaluator(model, print_freq=args.print_freq) evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery) st_model = ST_Model(tgt_dataset.meta['num_cameras']) same = None # train_loader2 = None best_mAP = 0 # # Start training for iter_n in range(args.iteration): if args.lambda_value == 0: source_features = 0 else: # get source datas' feature source_features, _ = extract_features(model, src_extfeat_loader, print_freq=args.print_freq) # synchronization feature order with src_dataset.train source_features = torch.cat([source_features[f].unsqueeze(0) for f, _, _, _ in src_dataset.train], 0) # extract training images' features print('Iteration {}: Extracting Target Dataset Features...'.format(iter_n+1)) target_features, tarNames = extract_features(model, tgt_extfeat_loader, print_freq=args.print_freq) # synchronization feature order with dataset.train target_features = torch.cat([target_features[f].unsqueeze(0) for f, _, _, _ in tgt_dataset.trainval], 0) # target_real_label = np.asarray([tarNames[f].unsqueeze(0) for f, _, _, _ in tgt_dataset.trainval]) target_features = target_features.numpy() rerank_dist = re_ranking(source_features, target_features, lambda_value=args.lambda_value) ranking = np.argsort(rerank_dist)[:, 1:] if iter_n != 0: st_dist = np.zeros(rerank_dist.shape) for i, (_, _, c1, t1) in enumerate(tgt_dataset.trainval): for j, (_, _, c2, t2) in enumerate(tgt_dataset.trainval): if not same.in_peak(c1, c2, t1, t2, 0.25): st_dist[i, j] = 1 rerank_dist = rerank_dist + st_dist * 10 # if iter_n > 0: # rerank_dist = st_model.apply(rerank_dist, tgt_dataset.trainval, tgt_dataset.trainval) cluster = HDBSCAN(metric='precomputed', min_samples=10) # select & cluster images as training set of this epochs clusterRes = cluster.fit(rerank_dist.astype(np.float64)) labels, label_num = clusterRes.labels_, clusterRes.labels_.max() + 1 centers = np.zeros((label_num, target_features.shape[1])) nums = [0] * target_features.shape[1] print('clusters num =', label_num) # generate new dataset new_dataset = [] index = -1 for (fname, _, cam, timestamp), label in zip(tgt_dataset.trainval, labels): index += 1 if label == -1: continue # dont need to change codes in trainer.py _parsing_input function and sampler function after add 0 new_dataset.append((fname, label, cam, timestamp)) centers[label] += target_features[index] nums[label] += 1 print('Iteration {} have {} training images'.format(iter_n+1, len(new_dataset))) # learn ST model # if iter_n % 2 == 0: # if iter_n == 0: # cluster = HDBSCAN(metric='precomputed', min_samples=10) # # select & cluster images as training set of this epochs # clusterRes = cluster.fit(rerank_dist.astype(np.float64)) # labels, label_num = clusterRes.labels_, clusterRes.labels_.max() + 1 # centers = np.zeros((label_num, target_features.shape[1])) # nums = [0] * target_features.shape[1] # print('clusters num =', label_num) # # # generate new dataset # new_dataset = [] # index = -1 # for (fname, _, cam, timestamp), label in zip(tgt_dataset.trainval, labels): # index += 1 # if label == -1: continue # # dont need to change codes in trainer.py _parsing_input function and sampler function after add 0 # new_dataset.append((fname, label, cam, timestamp)) # centers[label] += target_features[index] # nums[label] += 1 # print('Iteration {} have {} training images'.format(iter_n + 1, len(new_dataset))) # same, _ = st_model.fit(new_dataset) # st_model.fit(tgt_dataset.trainval) same, _ = st_model.fit(new_dataset) train_loader = DataLoader( Preprocessor(new_dataset, root=tgt_dataset.images_dir, transform=train_transformer), batch_size=args.batch_size, num_workers=4, sampler=RandomIdentitySampler(new_dataset, args.num_instances), pin_memory=True, drop_last=True ) def filter(i, j): _, _, c1, t1 = tgt_dataset.trainval[i] _, _, c2, t2 = tgt_dataset.trainval[j] return st_model.val(c1, c2, t1, t2) > 0.01 # if iter_n == 0: # ranking = np.argsort(rerank_dist)[:, 1:] # dukemtmc # cluster_size = 23.535612535612536 # market1501 cluster_size = 17.22503328894807 must_conn = int(cluster_size / 2) might_conn = int(cluster_size * 2) length = len(tgt_dataset.trainval) pos = [[] for _ in range(length)] neg = [[] for _ in range(length)] for i in range(length): for j_ in range(might_conn): j = ranking[i][j_] if j_ < must_conn and i in ranking[j][:must_conn]: pos[i].append(j) elif i in ranking[j][:might_conn] and filter(i, j): pos[i].append(j) else: neg[i].append(j) # pos[i] = pos[i][-1:] # neg[i] = neg[i][:1] SP, SF, DP, DF = 0, 0, 0, 0 for i in range(length): for j in pos[i]: if tgt_dataset.trainval[i][1] == tgt_dataset.trainval[j][1]: SP += 1 else: SF += 1 for j in neg[i]: if tgt_dataset.trainval[i][1] == tgt_dataset.trainval[j][1]: DP += 1 else: DF += 1 print('stat: %.1f %.1f %.3f, %.3f' % ((SP + SF) / length, (DP + DF) / length, SP / (SP + SF), DF / (DP + DF))) train_loader2 = DataLoader( Preprocessor(tgt_dataset.trainval, root=tgt_dataset.images_dir, transform=train_transformer), batch_size=args.batch_size, num_workers=4, # sampler=RandomIdentitySampler(new_dataset, args.num_instances), # shuffle=True, sampler=TripletSampler(tgt_dataset.trainval, pos, neg), pin_memory=True, drop_last=True ) # learn visual model for i in range(label_num): centers[i] /= nums[i] criterion[3] = ClassificationLoss(normalize(centers, axis=1)).cuda() classOptimizer = torch.optim.Adam([ {'params': model.parameters()}, {'params': criterion[3].classifier.parameters(), 'lr': 1e-3} ], lr=args.lr) # trainer = HoughTrainer(model, st_model, train_loader, criterion, classOptimizer) trainer = ClassificationTrainer(model, train_loader, criterion, classOptimizer) trainer2 = Trainer(model, train_loader2, criterion, optimizer) for epoch in range(args.epochs): trainer.train(epoch) if epoch % 8 == 0: trainer2.train(epoch) # evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery) rank_score = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery) if rank_score.map > best_mAP: best_mAP = rank_score.map save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': rank_score.market1501[0], }, True, fpath=osp.join(args.logs_dir, 'adapted.pth.tar')) # Evaluate rank_score = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery) save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': rank_score.market1501[0], }, False, fpath=osp.join(args.logs_dir, 'adapted.pth.tar')) return (rank_score.map, rank_score.market1501[0])
def main_worker(args): global start_epoch, best_mAP cudnn.benchmark = True if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) else: log_dir = osp.dirname(args.resume) sys.stdout = Logger(osp.join(log_dir, 'log_test.txt')) print("==========\nArgs:{}\n==========".format(args)) # Create data loaders iters = args.iters if (args.iters>0) else None dataset_source, num_classes, train_loader_source, test_loader_source = \ get_data(args.dataset_source, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.num_instances, iters) dataset_target, _, train_loader_target, test_loader_target = \ get_data(args.dataset_target, args.data_dir, args.height, args.width, args.batch_size, args.workers, 0, iters) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes) model.cuda() model = nn.DataParallel(model) # Load from checkpoint if args.resume: checkpoint = load_checkpoint(args.resume) copy_state_dict(checkpoint['state_dict'], model) start_epoch = checkpoint['epoch'] best_mAP = checkpoint['best_mAP'] print("=> Start epoch {} best mAP {:.1%}" .format(start_epoch, best_mAP)) # Evaluator evaluator = Evaluator(model) if args.evaluate: print("Test on source domain:") evaluator.evaluate(test_loader_source, dataset_source.query, dataset_source.gallery, cmc_flag=True, rerank=args.rerank) print("Test on target domain:") evaluator.evaluate(test_loader_target, dataset_target.query, dataset_target.gallery, cmc_flag=True, rerank=args.rerank) return params = [] for key, value in model.named_parameters(): if not value.requires_grad: continue params += [{"params": [value], "lr": args.lr, "weight_decay": args.weight_decay}] optimizer = torch.optim.Adam(params) lr_scheduler = WarmupMultiStepLR(optimizer, args.milestones, gamma=0.1, warmup_factor=0.01, warmup_iters=args.warmup_step) # Trainer trainer = PreTrainer(model, num_classes, margin=args.margin) # Start training for epoch in range(start_epoch, args.epochs): lr_scheduler.step() train_loader_source.new_epoch() train_loader_target.new_epoch() trainer.train(epoch, train_loader_source, train_loader_target, optimizer, train_iters=len(train_loader_source), print_freq=args.print_freq) if ((epoch+1)%args.eval_step==0 or (epoch==args.epochs-1)): _, mAP = evaluator.evaluate(test_loader_source, dataset_source.query, dataset_source.gallery, cmc_flag=True) is_best = mAP > best_mAP best_mAP = max(mAP, best_mAP) save_checkpoint({ 'state_dict': model.state_dict(), 'epoch': epoch + 1, 'best_mAP': best_mAP, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} source mAP: {:5.1%} best: {:5.1%}{}\n'. format(epoch, mAP, best_mAP, ' *' if is_best else '')) print("Test on target domain:") evaluator.evaluate(test_loader_target, dataset_target.query, dataset_target.gallery, cmc_flag=True, rerank=args.rerank)
def main(args): os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) ## get_source_data src_dataset, src_extfeat_loader = \ get_source_data(args.src_dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers) # get_target_data tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \ get_data(args.tgt_dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers) # Create model # Hacking here to let the classifier be the last feature embedding layer # Net structure: avgpool -> FC(2048) -> FC(args.features) num_class = 0 if args.src_dataset == 'dukemtmc': model = models.create(args.arch, num_classes=num_class, num_split=args.num_split, cluster=args.dce_loss) #duke elif args.src_dataset == 'market1501': model = models.create(args.arch, num_classes=num_class, num_split=args.num_split, cluster=args.dce_loss) else: raise RuntimeError('Please specify the number of classes (ids) of the network.') # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: print('Resuming checkpoints from finetuned model on another dataset...\n') checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint, strict=False) else: raise RuntimeWarning('Not using a pre-trained model') model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model, print_freq=args.print_freq) print("Test with the original model trained on source domain:") best_top1 = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery) if args.evaluate: return # Criterion criterion = [] criterion.append(TripletLoss(margin=args.margin,num_instances=args.num_instances).cuda()) criterion.append(TripletLoss(margin=args.margin,num_instances=args.num_instances).cuda()) #multi lr base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [ {'params': model.module.base.parameters(), 'lr_mult': 1.0}, {'params': new_params, 'lr_mult': 1.0}] # Optimizer optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=0.9, weight_decay=args.weight_decay) ##### adjust lr def adjust_lr(epoch): if epoch <= 7: lr = args.lr elif epoch <=14: lr = 0.3 * args.lr else: lr = 0.1 * args.lr for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) ##### training stage transformer on input images normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transformer = T.Compose([ Resize((args.height,args.width)), T.RandomHorizontalFlip(), T.ToTensor(), normalizer, T.RandomErasing(probability=0.5, sh=0.2, r1=0.3) ]) # Start training iter_nums = args.iteration start_epoch = args.start_epoch cluster_list = [] top_percent = args.rho EF = 100 // iter_nums + 1 eug = None for iter_n in range(start_epoch, iter_nums): #### get source datas' feature if args.load_dist and iter_n == 0: dist = pickle.load(open('dist' + str(args.num_split) + '.pkl', 'rb')) euclidean_dist_list = dist['euclidean'] rerank_dist_list = dist['rerank'] else: source_features, _ = extract_features(model, src_extfeat_loader, for_eval=False) if isinstance(source_features[src_dataset.trainval[0][0]], list): len_f = len(source_features[src_dataset.trainval[0][0]]) source_features = [torch.cat([source_features[f][i].unsqueeze(0) for f, _, _ in src_dataset.trainval], 0) for i in range(len_f)] else: source_features = torch.cat([source_features[f].unsqueeze(0) for f, _, _ in src_dataset.trainval], 0) # synchronization feature order with s_dataset.trainval #### extract training images' features print('Iteration {}: Extracting Target Dataset Features...'.format(iter_n+1)) target_features, _ = extract_features(model, tgt_extfeat_loader, for_eval=False) if isinstance(target_features[tgt_dataset.trainval[0][0]], list): len_f = len(target_features[tgt_dataset.trainval[0][0]]) target_features = [torch.cat([target_features[f][i].unsqueeze(0) for f, _, _ in tgt_dataset.trainval], 0) for i in range(len_f)] else: target_features = torch.cat([target_features[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval], 0) # synchronization feature order with dataset.trainval #### calculate distance and rerank result print('Calculating feature distances...') # target_features = target_features.numpy() euclidean_dist_list, rerank_dist_list = compute_dist( source_features, target_features, lambda_value=args.lambda_value, no_rerank=args.no_rerank, num_split=args.num_split) # lambda=1 means only source dist del target_features del source_features labels_list, cluster_list = generate_selflabel( euclidean_dist_list, rerank_dist_list, iter_n, args, cluster_list) #### generate new dataset train_loader = generate_dataloader(tgt_dataset, labels_list, train_transformer, iter_n, args) if iter_n == 5: u_data, l_data = updata_lable(tgt_dataset, labels_list[0], args.tgt_dataset, sample=args.sample) eug = EUG(model_name=args.arch, batch_size=args.batch_size, mode=args.mode, num_classes=num_class, data_dir=args.data_dir, l_data=l_data, u_data=u_data, print_freq=args.print_freq, save_path=args.logs_dir, pretrained_model=model, rerank=True) eug.model = model if eug is not None: nums_to_select = int(min((iter_n + 1) * int(len(u_data) // (iter_nums)), len(u_data))) pred_y, pred_score = eug.estimate_label() print('This is running {} with EF= {}%, step {}:\t Nums_to_be_select {}, \t Logs-dir {}'.format( args.mode, EF, iter_n+1, nums_to_select, args.logs_dir )) selected_idx = eug.select_top_data(pred_score, nums_to_select) new_train_data = eug.generate_new_train_data(selected_idx, pred_y) eug_dataloader = eug.get_dataloader(new_train_data, training=True) top1 = iter_trainer(model, tgt_dataset, train_loader, eug_dataloader, test_loader, optimizer, criterion, args.epochs, args.logs_dir, args.print_freq, args.lr) eug.model = model del train_loader # del eug_dataloader else: top1 = iter_trainer(model, tgt_dataset, train_loader, None, test_loader, optimizer, criterion, args.epochs, args.logs_dir, args.print_freq, args.lr) del train_loader is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': iter_n + 1, 'best_top1': best_top1, # 'num_ids': num_ids, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(iter_n+1, top1, best_top1, ' *' if is_best else ''))
def evaluate(self, query, gallery): test_loader = self.get_dataloader(list(set(query) | set(gallery)), training = False) evaluator = Evaluator(self.model) evaluator.evaluate(test_loader, query, gallery)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(os.path.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.combine_trainval) # Create model model = InceptionNet(num_channels=8, num_features=args.features, dropout=args.dropout, num_classes=num_classes) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format( start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion criterion = nn.CrossEntropyLoss().cuda() # Optimizer if hasattr(model.module, 'base'): base_param_ids = set(map(id, model.module.base.parameters())) new_params = [ p for p in model.parameters() if id(p) not in base_param_ids ] param_groups = [{ 'params': model.module.base.parameters(), 'lr_mult': 0.1 }, { 'params': new_params, 'lr_mult': 1.0 }] else: param_groups = model.parameters() optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): step_size = 60 if args.arch == 'inception' else 40 lr = args.lr * (0.1**(epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) if epoch < args.start_save: continue top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint( { 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=os.path.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint( os.path.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, train_loader) evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) features, _ = extract_features(evaluator.model, test_loader) distmat = pairwise_distance(features, dataset.query, dataset.gallery, metric=metric) evaluate_all(distmat, query=dataset.query, gallery=dataset.gallery, cmc_topk=(1, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50)) torch.save(model, os.path.join(args.logs_dir, 'model.pt'))
def main(args): cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders dataset, num_classes, train_loader, query_loader, gallery_loader, camstyle_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.camstyle, args.re, args.workers) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes) # Load from checkpoint start_epoch = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] print("=> Start epoch {} ".format(start_epoch)) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model) if args.evaluate: print("Test:") evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, args.output_feature, args.rerank) return # Criterion #criterion = nn.CrossEntropyLoss().cuda() class LSROloss(nn.Module): def __init__(self): # change target to range(0,750) super(LSROloss, self).__init__() #input means the prediction score(torch Variable) 32*752,target means the corresponding label, def forward( self, input, target, flg ): # while flg means the flag(=0 for true data and 1 for generated data) batchsize*1 # print(type(input)) if input.dim( ) > 2: # N defines the number of images, C defines channels, K class in total input = input.view(input.size(0), input.size(1), -1) # N,C,H,W => N,C,H*W input = input.transpose(1, 2) # N,C,H*W => N,H*W,C input = input.contiguous().view( -1, input.size(2)) # N,H*W,C => N*H*W,C # normalize input maxRow, _ = torch.max( input.data, 1 ) # outputs.data return the index of the biggest value in each row maxRow = maxRow.unsqueeze(1) input.data = input.data - maxRow target = target.view(-1, 1) # batchsize*1 flg = flg.view(-1, 1) #len=flg.size()[0] flos = F.log_softmax(input) # N*K? batchsize*751 flos = torch.sum(flos, 1) / flos.size( 1) # N*1 get average gan loss logpt = F.log_softmax(input) # size: batchsize*751 #print("logpt",logpt.size()) #print("taarget", target.size()) logpt = logpt.gather(1, target) # here is a problem logpt = logpt.view(-1) # N*1 original loss flg = flg.view(-1) flg = flg.type(torch.cuda.FloatTensor) #print("logpt",logpt.size()) #print("flg", flg.size()) #print("flos", flos.size()) loss = -1 * logpt * (1 - flg) - flos * flg return loss.mean() criterion = LSROloss() # Optimizer base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [{ 'params': model.module.base.parameters(), 'lr_mult': 0.1 }, { 'params': new_params, 'lr_mult': 1.0 }] optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer if args.camstyle == 0: trainer = Trainer(model, criterion) else: trainer = CamStyleTrainer(model, criterion, camstyle_loader) # Schedule learning rate def adjust_lr(epoch): step_size = 40 lr = args.lr * (0.1**(epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) save_checkpoint( { 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, }, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} \n'.format(epoch)) # Final test print('Test with best model:') evaluator = Evaluator(model) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, args.output_feature, args.rerank)
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = "0" #device_ids = [0, 1, 2, 3] np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, query_loader, gallery_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers, ) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes,cut_at_pooling=False, FCN=True) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model_dict = model.state_dict() checkpoint_load = {k: v for k, v in (checkpoint['state_dict']).items() if k in model_dict} model_dict.update(checkpoint_load) model.load_state_dict(model_dict) # model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) #model = nn.DataParallel(model) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model) if args.evaluate: print("Test:") evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery) return # Criterion #criterion = nn.CrossEntropyLoss().cuda() criterion = nn.CrossEntropyLoss().cuda() # Optimizer if hasattr(model.module, 'base'): base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [ {'params': model.module.base.parameters(), 'lr_mult': 0.1}, {'params': new_params, 'lr_mult': 1.0}] else: param_groups = model.parameters() optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer trainer = Trainer(model, criterion, 0, 0, SMLoss_mode=0) # Schedule learning rate def adjust_lr(epoch): step_size = 60 if args.arch == 'inception' else args.step_size lr = args.lr * (0.1 ** (epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1)#if lr_mult do not find,return defualt value 1 # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) is_best = True save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'checkpoint.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery)
def main(args): # For fast training. cudnn.benchmark = True device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) print('log_dir=', args.logs_dir) # Print logs print(args) # Create data loaders dataset, num_classes, source_train_loader, target_train_loader, \ query_loader, gallery_loader = get_data(args.data_dir, args.source, args.target, args.height, args.width, args.batch_size, args.re, args.workers) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes) # Invariance learning model num_tgt = len(dataset.target_train) model_inv = InvNet(args.features, num_tgt, beta=args.inv_beta, knn=args.knn, alpha=args.inv_alpha) # Load from checkpoint start_epoch = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) model_inv.load_state_dict(checkpoint['state_dict_inv']) start_epoch = checkpoint['epoch'] print("=> Start epoch {} " .format(start_epoch)) # Set model model = nn.DataParallel(model).to(device) model_inv = model_inv.to(device) # Evaluator evaluator = Evaluator(model) if args.evaluate: print("Test:") evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, args.output_feature) return # 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 = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer trainer = Trainer(model, model_inv, lmd=args.lmd, include_mmd=args.include_mmd) # Schedule learning rate def adjust_lr(epoch): step_size = args.epochs_decay lr = args.lr * (0.1 ** (epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, source_train_loader, target_train_loader, optimizer) save_checkpoint({ 'state_dict': model.module.state_dict(), 'state_dict_inv': model_inv.state_dict(), 'epoch': epoch + 1, }, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} \n'. format(epoch)) # Final test print('Test with best model:') evaluator = Evaluator(model) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery, args.output_feature)
model.load_state_dict(checkpoint) except: allNames = list(checkpoint.keys()) for name in allNames: if name.count('classifier') != 0: del checkpoint[name] model.load_state_dict(checkpoint, strict=False) model.eval() if torch.cuda.is_available(): model = model.cuda() if torch.cuda.device_count() > 1: model = nn.DataParallel(model) evaSrc = Evaluator(model, args.print_freq) ##define advColor_noise recoloradv_threat = ap.ThreatModel(pt.ReColorAdv, { 'xform_class': ct.FullSpatial, 'cspace': cs.RGBColorSpace(), # controls the color space used 'lp_style': 'inf', 'lp_bound': [8 / 255, 8 / 255, 8 / 255], # [epsilon_1, epsilon_2, epsilon_3] 'xform_params': { 'resolution_x': 25, # R_1 'resolution_y': 25, # R_2 'resolution_z': 25, # R_3 }, 'use_smooth_loss': False, }) additive_threat = ap.ThreatModel(ap.DeltaAddition, {
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.loss == 'triplet': assert args.num_instances > 1, 'TripletLoss requires num_instances > 1' assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.batch_size, args.workers, args.num_instances, combine_trainval=args.combine_trainval) # Create model if args.loss == 'xentropy': model = InceptionNet(num_classes=num_classes, num_features=args.features, dropout=args.dropout) elif args.loss == 'oim': model = InceptionNet(num_features=args.features, norm=True, dropout=args.dropout) elif args.loss == 'triplet': model = InceptionNet(num_features=args.features, dropout=args.dropout) else: raise ValueError("Cannot recognize loss type:", args.loss) model = torch.nn.DataParallel(model).cuda() # Load from checkpoint if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) args.start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> start epoch {} best top1 {:.1%}".format( args.start_epoch, best_top1)) else: best_top1 = 0 # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion if args.loss == 'xentropy': criterion = torch.nn.CrossEntropyLoss() elif args.loss == 'oim': criterion = OIMLoss(model.module.num_features, num_classes, scalar=args.oim_scalar, momentum=args.oim_momentum) elif args.loss == 'triplet': criterion = TripletLoss(margin=args.triplet_margin) else: raise ValueError("Cannot recognize loss type:", args.loss) criterion.cuda() # Optimizer if args.optimizer == 'sgd': optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) elif args.optimizer == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) else: raise ValueError("Cannot recognize optimizer type:", args.optimizer) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): if args.optimizer == 'sgd': lr = args.lr * (0.1**(epoch // 60)) elif args.optimizer == 'adam': lr = args.lr if epoch <= 100 else \ args.lr * (0.001 ** (epoch - 100) / 50) else: raise ValueError("Cannot recognize optimizer type:", args.optimizer) for g in optimizer.param_groups: g['lr'] = lr # Start training for epoch in range(args.start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint( { 'state_dict': model.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.load_state_dict(checkpoint['state_dict']) metric.train(model, train_loader) evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main(args): args.step_size = args.step_size.split(',') args.step_size = [int(x) for x in args.step_size] # seed if args.seed is not None: np.random.seed(args.seed) torch.manual_seed(args.seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False else: torch.backends.cudnn.benchmark = True if args.logs_dir is None: args.logs_dir = osp.join(f'logs/zju/{args.dataset}', datetime.datetime.today().strftime('%Y-%m-%d_%H-%M-%S')) else: args.logs_dir = osp.join(f'logs/zju/{args.dataset}', args.logs_dir) if args.train: os.makedirs(args.logs_dir, exist_ok=True) copy_tree('./reid', args.logs_dir + '/scripts/reid') for script in os.listdir('.'): if script.split('.')[-1] == 'py': dst_file = os.path.join(args.logs_dir, 'scripts', os.path.basename(script)) shutil.copyfile(script, dst_file) sys.stdout = Logger(os.path.join(args.logs_dir, 'log.txt'), ) print('Settings:') print(vars(args)) print('\n') # Create data loaders dataset, num_classes, train_loader, query_loader, gallery_loader, camstyle_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.num_workers, args.combine_trainval, args.crop, args.tracking_icams, args.tracking_fps, args.re, args.num_instances, camstyle=0, zju=1, colorjitter=args.colorjitter) # Create model model = models.create('ide', feature_dim=args.feature_dim, norm=args.norm, num_classes=num_classes, last_stride=args.last_stride, arch=args.arch) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: resume_fname = osp.join(f'logs/zju/{args.dataset}', args.resume, 'model_best.pth.tar') model, start_epoch, best_top1 = checkpoint_loader(model, resume_fname) print("=> Last epoch {} best top1 {:.1%}".format(start_epoch, best_top1)) start_epoch += 1 model = nn.DataParallel(model).cuda() # Criterion criterion = [LSR_loss().cuda() if args.LSR else nn.CrossEntropyLoss().cuda(), TripletLoss(margin=None if args.softmargin else args.margin).cuda()] # Optimizer if 'aic' in args.dataset: # Optimizer if hasattr(model.module, 'base'): # low learning_rate the base network (aka. DenseNet-121) base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [{'params': model.module.base.parameters(), 'lr_mult': 1}, {'params': new_params, 'lr_mult': 2}] else: param_groups = model.parameters() optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) else: optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, ) # Trainer trainer = Trainer(model, criterion) # Evaluator evaluator = Evaluator(model) if args.train: # Schedule learning rate def adjust_lr(epoch): if epoch <= args.warmup: alpha = epoch / args.warmup warmup_factor = 0.01 * (1 - alpha) + alpha else: warmup_factor = 1 lr = args.lr * warmup_factor * (0.1 ** bisect_right(args.step_size, epoch)) print('Current learning rate: {}'.format(lr)) for g in optimizer.param_groups: if 'aic' in args.dataset: g['lr'] = lr * g.get('lr_mult', 1) else: g['lr'] = lr # Draw Curve epoch_s = [] loss_s = [] prec_s = [] eval_epoch_s = [] eval_top1_s = [] # Start training for epoch in range(start_epoch + 1, args.epochs + 1): t0 = time.time() adjust_lr(epoch) # train_loss, train_prec = 0, 0 train_loss, train_prec = trainer.train(epoch, train_loader, optimizer, fix_bn=args.fix_bn, print_freq=10) if epoch < args.start_save: continue if epoch % 10 == 0: top1 = evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery) eval_epoch_s.append(epoch) eval_top1_s.append(top1) else: top1 = 0 is_best = top1 >= best_top1 best_top1 = max(top1, best_top1) save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) epoch_s.append(epoch) loss_s.append(train_loss) prec_s.append(train_prec) draw_curve(os.path.join(args.logs_dir, 'train_curve.jpg'), epoch_s, loss_s, prec_s, eval_epoch_s, None, eval_top1_s) t1 = time.time() t_epoch = t1 - t0 print('\n * Finished epoch {:3d} top1: {:5.1%} best_eval: {:5.1%} {}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) print('*************** Epoch takes time: {:^10.2f} *********************\n'.format(t_epoch)) pass # Final test print('Test with best model:') model, start_epoch, best_top1 = checkpoint_loader(model, osp.join(args.logs_dir, 'model_best.pth.tar')) print("=> Start epoch {} best top1 {:.1%}".format(start_epoch, best_top1)) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery) else: print("Test:") evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery) pass
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.num_instances, args.workers, args.combine_trainval, args.batch_id) # Create model # Hacking here to let the classifier be the last feature embedding layer # Net structure: avgpool -> FC(1024) -> FC(args.features) model = models.create(args.arch, num_features=1024, dropout=args.dropout, num_classes=args.features) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format( start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion criterion = TripletLoss(margin=args.margin).cuda() # Optimizer optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): lr = args.lr if epoch <= 100 else \ args.lr * (0.001 ** ((epoch - 100) / 50.0)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) if epoch < args.start_save: continue top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint( { 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, train_loader) evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main(): opt = Options().parse() dataset, train_loader, test_loader = get_data(opt.dataset, opt.dataroot, opt.height, opt.width, opt.batch_size, opt.workers, opt.pose_aug) dataset_size = len(dataset.trainval) * 4 print('#training images = %d' % dataset_size) model = MYGANModel(opt) # print(model.size) visualizer = Visualizer(opt) evaluator = Evaluator(model.net_E) if opt.stage != 1: print('Test with baseline model:') top1, mAP = evaluator.evaluate(test_loader, test_loader, dataset.query, dataset.gallery, dataset=opt.dataset) message = '\n Test with baseline model: mAP: {:5.1%} top1: {:5.1%}\n'.format( mAP, top1) visualizer.print_reid_results(message) total_steps = 0 best_mAP = 0 ttt = 0 accumulation_steps = 8 if (opt.eval): print('Test done!') else: for epoch in range(1, opt.niter + opt.niter_decay + 1): epoch_start_time = time.time() epoch_iter = 0 model.reset_model_status() for i, data in enumerate(train_loader): ttt += 1 iter_start_time = time.time() visualizer.reset() total_steps += opt.batch_size epoch_iter += opt.batch_size model.set_input(data) model.backward_parameters() if ((i + 1) % accumulation_steps) == 0: #batchsize,gradient add model.optimize_parameters() model.optimize_zero() name1 = str(int(data[0]['pid'][0])) name2 = str(int(data[0]['pid'][1])) if total_steps % opt.display_freq == 0: save_result = total_steps % opt.update_html_freq == 0 visualizer.display_current_results( model.get_current_visuals(), epoch, name1, name2, ttt, save_result) #save_result = total_steps % opt.update_html_freq == 0 #visualizer.display_current_results(model.get_current_visuals(), epoch,name1,name2,ttt, save_result) if total_steps % opt.print_freq == 0: errors = model.get_current_errors() t = (time.time() - iter_start_time) / opt.batch_size visualizer.print_current_errors(epoch, epoch_iter, errors, t) if opt.display_id > 0: visualizer.plot_current_errors( epoch, float(epoch_iter) / dataset_size, opt, errors) if epoch % opt.save_step == 0: print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps)) model.save(epoch) if epoch % opt.eval_step == 0 and opt.stage != 1: mAP = evaluator.evaluate(test_loader, test_loader, dataset.query, dataset.gallery, top1=False) #, is_best = mAP > best_mAP best_mAP = max(mAP, best_mAP) if is_best: model.save('best') message = '\n * Finished epoch {:3d} mAP: {:5.1%} best: {:5.1%}{}\n'.format( epoch, mAP, best_mAP, ' *' if is_best else '') visualizer.print_reid_results(message) print('End of epoch %d / %d \t Time Taken: %d sec' % (epoch, opt.niter + opt.niter_decay, time.time() - epoch_start_time)) model.update_learning_rate() # Final test if opt.stage != 1: print('Test with best model:') checkpoint = load_checkpoint( osp.join(opt.checkpoints, opt.name, '%s_net_%s.pth' % ('best', 'E'))) #('best', 'E') model.net_E.load_state_dict(checkpoint) top1, mAP = evaluator.evaluate(test_loader, test_loader, dataset.query, dataset.gallery, dataset=opt.dataset) message = '\n Test with best model: mAP: {:5.1%} top1: {:5.1%}\n'.format( mAP, top1) visualizer.print_reid_results(message)