def main(): global args args = parse_args() cfg = mmcv.Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) if args.out is None or not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') if osp.exists(args.out): outputs = mmcv.load(args.out) else: if args.launcher == 'none': raise NotImplementedError( "By default, we use distributed testing, so that launcher should be pytorch" ) else: distributed = True init_dist(args.launcher, **cfg.dist_params) model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) data_loader = build_dataloader(dataset, imgs_per_gpu=1, workers_per_gpu=1, dist=distributed, shuffle=False) load_checkpoint(model, args.checkpoint, map_location='cpu') find_unused_parameters = cfg.get('find_unused_parameters', False) model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False, find_unused_parameters=find_unused_parameters) outputs = multiple_test(model, data_loader) rank, _ = get_dist_info() if rank == 0: print('writing results to {}'.format(args.out)) mmcv.dump(outputs, args.out) eval_type = args.eval if eval_type: print('Starting evaluate {}'.format(eval_type)) result_file = osp.join(args.out + '.csv') results2csv(dataset, outputs, result_file) ava_eval(result_file, eval_type, args.label_file, args.ann_file, args.exclude_file)
def main(): args = parse_args() cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True # update configs according to CLI args if args.work_dir is not None: cfg.work_dir = args.work_dir if args.resume_from is not None: cfg.resume_from = args.resume_from cfg.gpus = args.gpus if cfg.checkpoint_config is not None: # save mmaction version in checkpoints as meta data cfg.checkpoint_config.meta = dict(mmact_version=__version__, config=cfg.text) # init distributed env first, since logger depends on the dist info. if args.launcher == 'none': distributed = False else: distributed = True init_dist(args.launcher, **cfg.dist_params) # init logger before other steps logger = get_root_logger(cfg.log_level) logger.info('Distributed training: {}'.format(distributed)) # set random seeds if args.seed is not None: logger.info('Set random seed to {}'.format(args.seed)) set_random_seed(args.seed) model = build_recognizer(cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg) train_dataset = get_trimmed_dataset(cfg.data.train) val_dataset = get_trimmed_dataset(cfg.data.val) datasets = [] for flow in cfg.workflow: assert flow[0] in ['train', 'val'] if flow[0] == 'train': datasets.append(train_dataset) else: datasets.append(val_dataset) train_network(model, datasets, cfg, distributed=distributed, validate=args.validate, logger=logger)
def main(): args = parse_args() if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = mmcv.Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True # pass arg of fcn testing if args.fcn_testing: cfg.model.update({'fcn_testing': True}) cfg.model['cls_head'].update({'fcn_testing': True}) # for regular testing if cfg.data.test.oversample == 'three_crop': cfg.model.spatial_temporal_module.spatial_size = 8 dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) if args.launcher == 'none': raise NotImplementedError("By default, we use distributed testing, so that launcher should be pytorch") else: distributed = True init_dist(args.launcher, **cfg.dist_params) model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) data_loader = build_dataloader( dataset, imgs_per_gpu=1, workers_per_gpu=1, dist=distributed, shuffle=False) load_checkpoint(model, args.checkpoint, map_location='cpu') model = MMDistributedDataParallel(model.cuda()) outputs = multi_test(model, data_loader) rank, _ = get_dist_info() if args.out and rank == 0: print('writing results to {}'.format(args.out)) mmcv.dump(outputs, args.out) gt_labels = [] for i in range(len(dataset)): ann = dataset.get_ann_info(i) gt_labels.append(ann['label']) if args.use_softmax: print("Averaging score over {} clips with softmax".format(outputs[0].shape[0])) results = [softmax(res, dim=1).mean(axis=0) for res in outputs] else: print("Averaging score over {} clips without softmax (ie, raw)".format(outputs[0].shape[0])) results = [res.mean(axis=0) for res in outputs] top1, top5 = top_k_accuracy(results, gt_labels, k=(1,5)) mean_acc = mean_class_accuracy(results, gt_labels) print("Mean Class Accuracy = {:.02f}".format(mean_acc * 100)) print("Top-1 Accuracy = {:.02f}".format(top1 * 100)) print("Top-5 Accuracy = {:.02f}".format(top5 * 100))
def main(): args = parse_args() cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True # update configs according to CLI args if args.work_dir is not None: cfg.work_dir = args.work_dir if is_valid(args.resume_from): cfg.resume_from = args.resume_from if is_valid(args.load_from): cfg.load_from = args.load_from if is_valid(args.load2d_from): cfg.model.backbone.pretrained = args.load2d_from cfg.model.backbone.pretrained2d = True if args.num_videos is not None: assert args.num_videos > 0 cfg.data.videos_per_gpu = args.num_videos if cfg.checkpoint_config is not None: cfg.checkpoint_config.meta = dict(mmact_version=__version__, config=cfg.text) if args.data_dir is not None: cfg = update_data_paths(cfg, args.data_dir) if hasattr( cfg.model, 'masked_num' ) and cfg.model.masked_num is not None and cfg.model.masked_num > 0: assert cfg.data.videos_per_gpu > cfg.model.masked_num cfg.data.videos_per_gpu -= cfg.model.masked_num # init distributed env first, since logger depends on the dist info. if args.launcher == 'none': distributed = False else: distributed = True init_dist(args.launcher, **cfg.dist_params) # init logger before other steps logger = get_root_logger(cfg.log_level) logger.info('Distributed training: {}'.format(distributed)) # set random seeds if args.seed is not None: logger.info('Set random seed to {}'.format(args.seed)) set_random_seed(args.seed) train_dataset = get_trimmed_dataset(cfg.data.train) ignores = ['num_batches_tracked'] if args.ignores is not None and len(args.ignores) > 0: ignores += args.ignores model = build_recognizer(cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg) if args.sync_bn: logger.info('Enabled SyncBatchNorm') model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) train_network(model, train_dataset, cfg, distributed=distributed, validate=args.validate, logger=logger, ignores=tuple(ignores))
def main(): global args args = parse_args() if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = mmcv.Config.fromfile(args.config) # must use fcn testing cfg.model.update({'fcn_testing': True}) cfg.model['cls_head'].update({'fcn_testing': True}) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True if args.testfile != '': cfg.data.test.ann_file = args.testfile dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) if args.launcher == 'none': distributed = False else: distributed = True init_dist(args.launcher, **cfg.dist_params) assert distributed, "We only support distributed testing" model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) data_loader = build_dataloader( dataset, imgs_per_gpu=1, workers_per_gpu=1, dist=distributed, shuffle=False) load_checkpoint(model, args.checkpoint, map_location='cpu') find_unused_parameters = cfg.get('find_unused_parameters', False) model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False, find_unused_parameters=find_unused_parameters) outputs = multi_test(model, data_loader) rank, _ = get_dist_info() if args.out and rank == 0: print('writing results to {}'.format(args.out)) mmcv.dump(outputs, args.out) gt_labels = [] for i in range(len(dataset)): ann = dataset.get_ann_info(i) gt_labels.append(ann['label']) if args.use_softmax: print("Averaging score over {} clips with softmax".format(outputs[0].shape[0])) results = [softmax(res, dim=1).mean(axis=0) for res in outputs] else: print("Averaging score over {} clips without softmax (ie, raw)".format(outputs[0].shape[0])) results = [res.mean(axis=0) for res in outputs] top1, top5 = top_k_accuracy(results, gt_labels, k=(1, 5)) mean_acc = mean_class_accuracy(results, gt_labels) print("Mean Class Accuracy = {:.02f}".format(mean_acc * 100)) print("Top-1 Accuracy = {:.02f}".format(top1 * 100)) print("Top-5 Accuracy = {:.02f}".format(top5 * 100))
def main(): args = parse_args() assert args.out, ('Please specify the output path for results') if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = mmcv.Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True if args.launcher == 'none': distributed = False else: distributed = True init_dist(args.launcher, **cfg.dist_params) if cfg.model.get('necks', None) is not None: cfg.model.necks.aux_head_config = None if cfg.data.test.oversample == 'three_crop': cfg.model.spatial_temporal_module.spatial_size = 8 if args.fcn_testing: cfg.model['cls_head'].update({'fcn_testing': True}) cfg.model.update({'fcn_testing': True}) if args.flip: cfg.model.update({'flip': True}) dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) if args.ignore_cache and args.out is not None: if not distributed: if args.gpus == 1: model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) load_checkpoint(model, args.checkpoint, strict=True, map_location='cpu') model = MMDataParallel(model, device_ids=[0]) data_loader = build_dataloader( dataset, imgs_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, num_gpus=1, dist=False, shuffle=False) outputs = single_test(model, data_loader) else: model_args = cfg.model.copy() model_args.update(train_cfg=None, test_cfg=cfg.test_cfg) model_type = getattr(recognizers, model_args.pop('type')) outputs = parallel_test(model_type, model_args, args.checkpoint, dataset, _data_func, range(args.gpus), workers_per_gpu=args.proc_per_gpu) else: data_loader = build_dataloader( dataset, imgs_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, dist=distributed, shuffle=False) model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) load_checkpoint(model, args.checkpoint, strict=True, map_location='cpu') model = MMDistributedDataParallel(model.cuda()) outputs = multi_gpu_test(model, data_loader, args.tmpdir) else: try: if distributed: rank, _ = get_dist_info() if rank == 0: outputs = mmcv.load(args.out) else: outputs = mmcv.load(args.out) except: raise FileNotFoundError rank, _ = get_dist_info() if args.out: if rank == 0: print('writing results to {}'.format(args.out)) mmcv.dump(outputs, args.out) gt_labels = [] for i in range(len(dataset)): ann = dataset.get_ann_info(i) gt_labels.append(ann['label']) results = [] for res in outputs: res_list = [res[i] for i in range(res.shape[0])] results += res_list results = results[:len(gt_labels)] print('results_length', len(results)) top1, top5 = top_k_accuracy(results, gt_labels, k=(1, 5)) mean_acc = mean_class_accuracy(results, gt_labels) non_mean_acc = non_mean_class_accuracy(results, gt_labels) if args.log: f = open(args.log, 'w') f.write(f'Testing ckpt from {args.checkpoint}\n') f.write(f'Testing config from {args.config}\n') f.write("Mean Class Accuracy = {:.04f}\n".format(mean_acc * 100)) f.write("Top-1 Accuracy = {:.04f}\n".format(top1 * 100)) f.write("Top-5 Accuracy = {:.04f}\n".format(top5 * 100)) f.close() else: print("Mean Class Accuracy = {:.02f}".format(mean_acc * 100)) print("Top-1 Accuracy = {:.02f}".format(top1 * 100)) print("Top-5 Accuracy = {:.02f}".format(top5 * 100)) print("Non mean Class Accuracy", non_mean_acc) print('saving non_mean acc')
def main(): global args args = parse_args() if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = mmcv.Config.fromfile(args.config) if args.checkpoint == None: args.checkpoint = os.path.join(cfg.work_dir, 'latest.pth') else: args.checkpoint = os.path.join(cfg.work_dir, 'epoch_%d.pth' % (int(args.checkpoint))) cfg = mmcv.Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True # pass arg of fcn testing if args.fcn_testing: cfg.model.update({'fcn_testing': True}) cfg.model['cls_head'].update({'fcn_testing': True}) # for regular testing if cfg.data.test.oversample == 'three_crop': cfg.model.spatial_temporal_module.spatial_size = 8 dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) if args.launcher == 'none': raise NotImplementedError( "By default, we use distributed testing, so that launcher should be pytorch" ) else: distributed = True init_dist(args.launcher, **cfg.dist_params) model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) data_loader = build_dataloader(dataset, imgs_per_gpu=1, workers_per_gpu=1, dist=distributed, shuffle=False) load_checkpoint(model, args.checkpoint, map_location='cpu') find_unused_parameters = cfg.get('find_unused_parameters', False) model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False, find_unused_parameters=find_unused_parameters) outputs = multi_test(model, data_loader, cfg.work_dir) rank, _ = get_dist_info() if args.out and rank == 0: print('writing results to {}'.format(args.out)) mmcv.dump(outputs, args.out) data_path = [] gt_labels = [] pre = [] for i in range(len(dataset)): ann = dataset.get_ann_info(i) gt_labels.append(ann['label']) data_path.append(ann['path']) pre.append(outputs[i].mean(axis=0)) save_data = { path: [p, g] for path, p, g in zip(data_path, pre, gt_labels) } with open(os.path.join(cfg.work_dir, 'test.pkl'), 'wb') as f: pickle.dump(save_data, f) if args.use_softmax: print("Averaging score over {} clips with softmax".format( outputs[0].shape[0])) results = [softmax(res, dim=1).mean(axis=0) for res in outputs] else: print("Averaging score over {} clips without softmax (ie, raw)". format(outputs[0].shape[0])) results = [res.mean(axis=0) for res in outputs] top1, top5 = top_k_accuracy(results, gt_labels, k=(1, 5)) mean_acc = mean_class_accuracy(results, gt_labels) with open(os.path.join(cfg.work_dir, 'test_result.txt'), 'w') as f: f.writelines('model is :' + args.checkpoint + '\n') f.writelines("Mean Class Accuracy = {:.04f}".format(mean_acc * 100) + '\n') f.writelines("Top-1 Accuracy = {:.04f}".format(top1 * 100) + '\n') f.writelines("Top-5 Accuracy = {:.04f}".format(top5 * 100) + '\n') print("Mean Class Accuracy = {:.04f}".format(mean_acc * 100)) print("Top-1 Accuracy = {:.04f}".format(top1 * 100)) print("Top-5 Accuracy = {:.04f}".format(top5 * 100))
def main(): global args args = parse_args() # if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): # raise ValueError('The output file must be a pkl file.') cfg = mmcv.Config.fromfile(args.config) # must use fcn testing cfg.model.update({'fcn_testing': True}) cfg.model['cls_head'].update({'fcn_testing': True}) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True if args.testfile != '': cfg.data.test.ann_file = args.testfile dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) if args.launcher == 'none': distributed = False else: distributed = True init_dist(args.launcher, **cfg.dist_params) assert distributed, "We only support distributed testing" model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) data_loader = build_dataloader( dataset, imgs_per_gpu=1, workers_per_gpu=1, dist=distributed, shuffle=False) load_checkpoint(model, args.checkpoint, map_location='cpu') find_unused_parameters = cfg.get('find_unused_parameters', False) model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False, find_unused_parameters=find_unused_parameters) outputs = multi_test(model, data_loader) rank, _ = get_dist_info() if args.out and rank == 0: print('writing results to {}'.format(args.out)) # mmcv.dump(outputs, args.out) results_numpyformat = np.zeros((1,226)) for i in range(len(outputs)): results_numpyformat = np.row_stack((results_numpyformat,outputs[i])) np.save("res",results_numpyformat[1:,:]) # gt_labels = [] image_name = [] for i in range(len(dataset)): ann = dataset.get_ann_info(i) image_name.append(ann['path']) # gt_labels.append(ann['label']) print(image_name[0]) if args.use_softmax: print("Averaging score over {} clips with softmax".format(outputs[0].shape[0])) results = [softmax(res, dim=1).mean(axis=0) for res in outputs] else: print("Averaging score over {} clips without softmax (ie, raw)".format(outputs[0].shape[0])) results = [res.mean(axis=0) for res in outputs] prediction = pd.read_csv('predictions.csv',header=None) if not os.path.exists(args.out): os.mkdir(args.out) pbar = tqdm(total=len(image_name)) for i in range(len(results)): pred_class = np.argsort(results[i])[-1:].item() # index = prediction[(prediction[0]==image_name[i].replace("_depth",""))].index.item() index = prediction[(prediction[0]==image_name[i].replace("_color",""))].index.item() # print("{}:{}".format(index,pred_class)) prediction.iloc[index,1] = pred_class pbar.update(1) # break prediction.to_csv(os.path.join(args.out,'predictions.csv'),header=False,index=False)
def main(): global args args = parse_args() # if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): # raise ValueError('The output file must be a pkl file.') cfg = mmcv.Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.data.test.test_mode = True # pass arg of fcn testing if args.fcn_testing: cfg.model.update({'fcn_testing': True}) cfg.model['cls_head'].update({'fcn_testing': True}) # for regular testing if cfg.data.test.oversample == 'three_crop': cfg.model.spatial_temporal_module.spatial_size = 8 dataset = obj_from_dict(cfg.data.test, datasets, dict(test_mode=True)) # dataset[0] if args.launcher == 'none': # raise NotImplementedError("By default, we use distributed testing, so that launcher should be pytorch") distributed = False else: distributed = True init_dist(args.launcher, **cfg.dist_params) model = build_recognizer(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) data_loader = build_dataloader(dataset, imgs_per_gpu=1, workers_per_gpu=1, dist=distributed, shuffle=False) load_checkpoint(model, args.checkpoint, map_location='cpu') # find_unused_parameters = cfg.get('find_unused_parameters', False) # model = MMDistributedDataParallel( # model.cuda(), # device_ids=[torch.cuda.current_device()], # broadcast_buffers=False, # find_unused_parameters=find_unused_parameters) model = MMDataParallel(model, device_ids=range(args.test_gpus, args.test_gpus + 1)) outputs = multi_test(model, data_loader) # print(outputs) # print(type(outputs)) # print(len(outputs)) rank, _ = get_dist_info() if args.out and rank == 0: print('writing results to {}'.format(args.out)) # mmcv.dump(outputs, args.out) results_numpyformat = np.zeros((1, 226)) for i in range(len(outputs)): results_numpyformat = np.row_stack( (results_numpyformat, outputs[i])) np.save(os.path.join(args.out, args.name), results_numpyformat[1:, :]) # gt_labels = [] image_name = [] for i in range(len(dataset)): ann = dataset.get_ann_info(i) image_name.append(ann['path']) # gt_labels.append(ann['label']) if args.use_softmax: print("Averaging score over {} clips with softmax".format( outputs[0].shape[0])) results = [softmax(res, dim=1).mean(axis=0) for res in outputs] else: print("Averaging score over {} clips without softmax (ie, raw)". format(outputs[0].shape[0])) results = [res.mean(axis=0) for res in outputs] prediction = pd.read_csv('predictions_testphase.csv', header=None) if not os.path.exists(args.out): os.mkdir(args.out) pbar = tqdm(total=len(image_name)) for i in range(len(results)): pred_class = np.argsort(results[i])[-1:].item() # import pdb;pdb.set_trace() # print(pred_class) # print(image_name[i]) index = prediction[(prediction[0] == image_name[i].replace( "_{}".format(args.color_or_depth), ""))].index.item() # print("{}:{}".format(index,pred_class)) prediction.iloc[index, 1] = pred_class pbar.update(1) # if i==5: # break prediction.to_csv(os.path.join(args.out, '{}_predictions.csv'.format(args.name)), header=False, index=False)