def map(wrapper): model = wrapper cfg = get_cfg() # test_loader, num_query = build_reid_test_loader(cfg, dataset_name="TEST", T.Compose([])) test_loader, num_query = build_reid_test_loader(cfg, dataset_name="TEST") feats = [] pids = [] camids = [] for batch in test_loader: for image_path in batch["img_paths"]: t = torch.Tensor(np.array([model.infer(cv2.imread(image_path))])) t.to(torch.device(GPU_ID)) feats.append(t) pids.extend(batch["targets"].numpy()) camids.extend(batch["camids"].numpy()) feats = torch.cat(feats, dim=0) q_feat = feats[:num_query] g_feat = feats[num_query:] q_pids = np.asarray(pids[:num_query]) g_pids = np.asarray(pids[num_query:]) q_camids = np.asarray(camids[:num_query]) g_camids = np.asarray(camids[num_query:]) distmat = 1 - torch.mm(q_feat, g_feat.t()) distmat = distmat.numpy() all_cmc, all_AP, all_INP = eval_market1501(distmat, q_pids, g_pids, q_camids, g_camids, 5) mAP = np.mean(all_AP) print("mAP {}, rank-1 {}".format(mAP, all_cmc[0]))
def build_test_loader(cls, cfg, dataset_name): """ Returns: iterable It now calls :func:`detectron2.data.build_detection_test_loader`. Overwrite it if you'd like a different data loader. """ return build_reid_test_loader(cfg, dataset_name)
def build_test_loader(cls, cfg, dataset_name): """ Returns: iterable It now calls :func:`fastreid.data.build_reid_test_loader`. Overwrite it if you'd like a different data loader. """ mapper = [] if cfg.INPUT.SIZE_TEST[0] > 0: if len(cfg.INPUT.SIZE_TEST) == 1: resize = cfg.INPUT.SIZE_TEST[0] else: resize = cfg.INPUT.SIZE_TEST mapper.append(T.Resize(resize, interpolation=3)) mapper.extend([ T.CenterCrop(size=cfg.INPUT.CROP_SIZE), ToTensor(), ]) return build_reid_test_loader(cfg, dataset_name, mapper=T.Compose(mapper))
for cfg in cfgs: self.predictors.append(DefaultPredictor(cfg)) def run_on_loader(self, data_loader): for batch in data_loader: predictions = [] for predictor in self.predictors: predictions.append(predictor(batch["images"])) yield torch.cat(predictions, dim=-1), batch if __name__ == "__main__": args = get_parser().parse_args() logger = setup_logger() cfgs = [] for config_file in args.config_file: cfg = setup_cfg(config_file, args.opts) cfgs.append(cfg) results = OrderedDict() for dataset_name in cfgs[0].DATASETS.TESTS: test_loader, num_query = build_reid_test_loader(cfgs[0], dataset_name) evaluator = ReidEvaluator(cfgs[0], num_query) feat_extract = FeatureExtraction(cfgs) for (feat, batch) in tqdm.tqdm(feat_extract.run_on_loader(test_loader), total=len(test_loader)): evaluator.process(batch, feat) result = evaluator.evaluate() results[dataset_name] = result print_csv_format(results)
def build_evaluator(cls, cfg, dataset_name, output_dir=None): data_loader, num_query = build_reid_test_loader( cfg, dataset_name=dataset_name) return data_loader, ReidEvaluator(cfg, num_query, output_dir)
default=10, help="maximum number of rank list to be visualized", ) parser.add_argument( "--opts", help="Modify config options using the command-line 'KEY VALUE' pairs", default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == '__main__': args = get_parser().parse_args() cfg = setup_cfg(args) test_loader, num_query = build_reid_test_loader( cfg, dataset_name=args.dataset_name) demo = FeatureExtractionDemo(cfg, parallel=args.parallel) logger.info("Start extracting image features") feats = [] pids = [] camids = [] for (feat, pid, camid) in tqdm.tqdm(demo.run_on_loader(test_loader), total=len(test_loader)): feats.append(feat) pids.extend(pid) camids.extend(camid) feats = torch.cat(feats, dim=0) q_feat = feats[:num_query] g_feat = feats[num_query:]
def eval_ARI_purity(cls, cfg, model, transforms=None, **kwargs): num_devices = comm.get_world_size() logger = logging.getLogger('fastreid') _root = os.getenv("FASTREID_DATASETS", "/root/datasets") evaluator = ARI_Purity_Evaluator(cfg) results = OrderedDict() if transforms is None: transforms = build_transforms(cfg, is_train=False) total_datasets = set(cfg.DATASETS.TESTS) for dataset_name in total_datasets: logger.info(f"Starting evaluating ARI on dataset {dataset_name}") data = DATASET_REGISTRY.get(dataset_name)(root=_root, **kwargs) test_items = data.train test_set = CommDataset(test_items, transforms, relabel=True) data_loader, num_query = build_reid_test_loader(cfg, dataset_name=dataset_name, test_set=test_set) total = len(data_loader) # inference data loader must have a fixed length # print('data_loader len =', total) evaluator.reset() img_nums = len(test_items) num_warmup = min(5, total - 1) start_time = time.perf_counter() total_compute_time = 0 with inference_context(model), torch.no_grad(): for idx, inputs in enumerate(data_loader): # print(inputs) if idx == num_warmup: start_time = time.perf_counter() total_compute_time = 0 start_compute_time = time.perf_counter() outputs = model(inputs) # Flip test if cfg.TEST.FLIP.ENABLED: inputs["images"] = inputs["images"].flip(dims=[3]) flip_outputs = model(inputs) outputs = (outputs + flip_outputs) / 2 if torch.cuda.is_available(): torch.cuda.synchronize() total_compute_time += time.perf_counter() - start_compute_time evaluator.process(inputs, outputs) iters_after_start = idx + 1 - num_warmup * int(idx >= num_warmup) seconds_per_batch = total_compute_time / iters_after_start if idx >= num_warmup * 2 or seconds_per_batch > 30: total_seconds_per_img = (time.perf_counter() - start_time) / iters_after_start eta = datetime.timedelta(seconds=int(total_seconds_per_img * (total - idx - 1))) log_every_n_seconds( logging.INFO, "Inference done {}/{}. {:.4f} s / batch. ETA={}".format( idx + 1, total, seconds_per_batch, str(eta) ), n=30, ) # Measure the time only for this worker (before the synchronization barrier) total_time = time.perf_counter() - start_time total_time_str = str(datetime.timedelta(seconds=total_time)) # NOTE this format is parsed by grep logger.info( "Total inference time: {} ({:.6f} s / batch per device, on {} devices)".format( total_time_str, total_time / (total - num_warmup), num_devices ) ) total_compute_time_str = str(datetime.timedelta(seconds=int(total_compute_time))) logger.info( "Total inference pure compute time: {} ({:.6f} s / batch per device, on {} devices)".format( total_compute_time_str, total_compute_time / (total - num_warmup), num_devices ) ) results_i = evaluator.evaluate() ARI_score, purity = results_i results[f'{dataset_name}/ARI'] = ARI_score results[f'{dataset_name}/purity'] = purity if comm.is_main_process(): assert isinstance( results, dict ), "Evaluator must return a dict on the main process. Got {} instead.".format( results ) logger.info(f"ARI score for {dataset_name} is {ARI_score:.4f}") logger.info(f"Purity for {dataset_name} is {purity:.4f}") return results