def main(): args = parse_args() if args.output_dir is not None: mkdir_or_exist(args.output_dir) cfg = build_data_cfg(args.config, args.skip_type, args.cfg_options) try: dataset = build_dataset(cfg.data.train, default_args=dict(filter_empty_gt=False)) except TypeError: # seg dataset doesn't have `filter_empty_gt` key dataset = build_dataset(cfg.data.train) data_infos = dataset.data_infos dataset_type = cfg.dataset_type # configure visualization mode vis_task = args.task # 'det', 'seg', 'multi_modality-det', 'mono-det' for idx, data_info in enumerate(track_iter_progress(data_infos)): if dataset_type in ['KittiDataset', 'WaymoDataset']: data_path = data_info['point_cloud']['velodyne_path'] elif dataset_type in [ 'ScanNetDataset', 'SUNRGBDDataset', 'ScanNetSegDataset', 'S3DISSegDataset', 'S3DISDataset' ]: data_path = data_info['pts_path'] elif dataset_type in ['NuScenesDataset', 'LyftDataset']: data_path = data_info['lidar_path'] elif dataset_type in ['NuScenesMonoDataset']: data_path = data_info['file_name'] else: raise NotImplementedError( f'unsupported dataset type {dataset_type}') file_name = osp.splitext(osp.basename(data_path))[0] if vis_task in ['det', 'multi_modality-det']: # show 3D bboxes on 3D point clouds show_det_data(idx, dataset, args.output_dir, file_name, show=args.online) if vis_task in ['multi_modality-det', 'mono-det']: # project 3D bboxes to 2D image show_proj_bbox_img( idx, dataset, args.output_dir, file_name, show=args.online, is_nus_mono=(dataset_type == 'NuScenesMonoDataset')) elif vis_task in ['seg']: # show 3D segmentation mask on 3D point clouds show_seg_data(idx, dataset, args.output_dir, file_name, show=args.online)
def test_single_gpu_test(): if not torch.cuda.is_available(): pytest.skip('test requires GPU and torch+cuda') cfg = _get_config_module('votenet/votenet_16x8_sunrgbd-3d-10class.py') cfg.model.train_cfg = None model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg')) dataset_cfg = cfg.data.test dataset_cfg.data_root = './tests/data/sunrgbd' dataset_cfg.ann_file = 'tests/data/sunrgbd/sunrgbd_infos.pkl' dataset = build_dataset(dataset_cfg) data_loader = build_dataloader( dataset, samples_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) model = MMDataParallel(model, device_ids=[0]) results = single_gpu_test(model, data_loader) bboxes_3d = results[0]['boxes_3d'] scores_3d = results[0]['scores_3d'] labels_3d = results[0]['labels_3d'] assert bboxes_3d.tensor.shape[0] >= 0 assert bboxes_3d.tensor.shape[1] == 7 assert scores_3d.shape[0] >= 0 assert labels_3d.shape[0] >= 0
def main(): args = parse_args() cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # build the dataloader # TODO: support multiple images per gpu (only minor changes are needed) dataset = build_dataset(cfg.data.test) data_loader = build_dataloader(dataset, samples_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) # build the model and load checkpoint model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_module(model) model = MMDataParallel(model, device_ids=[0]) model.eval() # the first several iterations may be very slow so skip them num_warmup = 5 pure_inf_time = 0 # benchmark with several samples and take the average for i, data in enumerate(data_loader): torch.cuda.synchronize() start_time = time.perf_counter() with torch.no_grad(): model(return_loss=False, rescale=True, **data) torch.cuda.synchronize() elapsed = time.perf_counter() - start_time if i >= num_warmup: pure_inf_time += elapsed if (i + 1) % args.log_interval == 0: fps = (i + 1 - num_warmup) / pure_inf_time print(f'Done image [{i + 1:<3}/ {args.samples}], ' f'fps: {fps:.1f} img / s') if (i + 1) == args.samples: pure_inf_time += elapsed fps = (i + 1 - num_warmup) / pure_inf_time print(f'Overall fps: {fps:.1f} img / s') break
def main(): args = parse_args() if args.result is not None and \ not args.result.endswith(('.pkl', '.pickle')): raise ValueError('The results file must be a pkl file.') cfg = Config.fromfile(args.config) cfg.data.test.test_mode = True # build the dataset dataset = build_dataset(cfg.data.test) results = mmcv.load(args.result) if getattr(dataset, 'show', None) is not None: # data loading pipeline for showing eval_pipeline = cfg.get('eval_pipeline', {}) if eval_pipeline: dataset.show(results, args.show_dir, pipeline=eval_pipeline) else: dataset.show(results, args.show_dir) # use default pipeline else: raise NotImplementedError( 'Show is not implemented for dataset {}!'.format( type(dataset).__name__))
def main(): args = parse_args() cfg = Config.fromfile(args.config) if args.cfg_options is not None: cfg.merge_from_dict(args.cfg_options) # import modules from string list. if cfg.get('custom_imports', None): from mmcv.utils import import_modules_from_strings import_modules_from_strings(**cfg['custom_imports']) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None # in case the test dataset is concatenated samples_per_gpu = 1 if isinstance(cfg.data.test, dict): cfg.data.test.test_mode = True samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) if samples_per_gpu > 1: # Replace 'ImageToTensor' to 'DefaultFormatBundle' cfg.data.test.pipeline = replace_ImageToTensor( cfg.data.test.pipeline) elif isinstance(cfg.data.test, list): for ds_cfg in cfg.data.test: ds_cfg.test_mode = True samples_per_gpu = max( [ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test]) if samples_per_gpu > 1: for ds_cfg in cfg.data.test: ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline) dataset = build_dataset(cfg.data.test) #import ipdb; ipdb.set_trace() for scene_id in range(len(dataset)): info = dataset.get_ann_info(scene_id) gt_boxes = info['gt_bboxes_3d'].to('cuda:0') gt_labels = info['gt_labels_3d'] filename = dataset.data_infos[scene_id]['point_cloud']['velodyne_path'] filename = '{}/{}'.format('/mnt/xrhuang/datasets/kitti', filename) points = torch.as_tensor(np.fromfile(filename, dtype=np.float32).reshape(-1, 4)[:, :3]).to('cuda:0') box_indices = gt_boxes.points_in_boxes(points) # 0: pedestrian, 1: cyclist, 2: car. #import ipdb; ipdb.set_trace() for i in range(len(gt_boxes)): if gt_labels[i] == -1: continue gt_name = info['gt_names'][i] #print(gt_name) points_i = points[box_indices == i] print(points_i.shape) filename = '{}_{:06d}_{:03d}.ply'.format(gt_name, scene_id, i) filename = os.path.join('kitti_objects', filename) pcd = o3d.geometry.PointCloud() pcd.points = o3d.utility.Vector3dVector(points_i.detach().cpu().numpy()) o3d.io.write_point_cloud(filename, pcd, write_ascii=True)
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_start_time = time.time() cfg = Config.fromfile(args.config) cfg_last = time.time() - cfg_start_time print('cfg time:', cfg_last) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) dataset_start_time = time.time() dataset = build_dataset(cfg.data.test) data_loader = build_dataloader( dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) dataset_last = time.time() - dataset_start_time print('dataset & dataloader time:', dataset_last) # build the model and load checkpoint model_start_time = time.time() model = build_detector(cfg.model, train_cfg=None, test_cfg=None) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_module(model) # old versions did not save class info in checkpoints, this walkaround is # for backward compatibility if 'CLASSES' in checkpoint['meta']: model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES model_time = time.time() - model_start_time print('model time:', model_time) model = MMDataParallel(model, device_ids=[0]) single_seg_test(model, data_loader)
def main(): args = parse_args() epoch = int(os.path.basename(args.checkpoint)[6:-4]) print(f'Epoch [{epoch}]') cfg_start_time = time.time() cfg = Config.fromfile(args.config) cfg_last = time.time() - cfg_start_time print('cfg time:', cfg_last) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None # cfg.data.test.test_mode = True # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader samples_per_gpu = 1 dataset_start_time = time.time() # dataset = build_dataset(cfg.data.test) dataset = build_dataset(cfg.data.get(args.split)) data_loader = build_dataloader(dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) dataset_last = time.time() - dataset_start_time print('dataset & dataloader time:', dataset_last) # build the model and load checkpoint model_start_time = time.time() model = build_detector(cfg.model, train_cfg=None, test_cfg=None) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') # old versions did not save class info in checkpoints, this walkaround is # for backward compatibility if 'CLASSES' in checkpoint['meta']: model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES model_time = time.time() - model_start_time print('model time:', model_time) model = MMDataParallel(model, device_ids=[0]) seg_test_with_loss(model, data_loader)
def _init_data(self): # build the dataloader # TODO right config (train / val / test?) samples_per_gpu = 1 dataset = build_dataset(self.cfg.data.test) self.data_loader = build_dataloader( dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=1, dist=False, shuffle=False, ) # get class information self.cat2id = dataset.cat2id
def _init_data(self, mode): # build the dataloader samples_per_gpu = 1 dataset = None if mode == "train": dataset = build_dataset(self.cfg.data.train) elif mode == "test": dataset = build_dataset(self.cfg.data.test) elif mode == "val": dataset = build_dataset(self.cfg.data.val) elif mode == "easy_test": # use the regular test config but change the ann file to the extension test set data_root = pathlib.Path(self.cfg.data.test.ann_file).parent easy_test_ann_file = data_root.joinpath( "carla_infos_easy_test.pkl") self.cfg.data.test.ann_file = str(easy_test_ann_file) dataset = build_dataset(self.cfg.data.test) else: raise ValueError("unsupportet dataset type {}".format(mode)) self.data_loader = build_dataloader( dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=1, dist=False, shuffle=False, ) # get class information self.cat2id = dataset.cat2id cat2id_file = self._result_base_path.joinpath(self._cat_to_id) with open(cat2id_file, 'w') as fp: json.dump(self.cat2id, fp, indent=4)
def main(): args = parse_args() cfg = Config.fromfile(args.config) data_dir = osp.abspath(args.work_dir) mmcv.mkdir_or_exist(data_dir) dataset = build_dataset(cfg.data.train) prog_bar = mmcv.ProgressBar(len(dataset)) for _, datum in enumerate(dataset): filename = datum["img_metas"].data["pts_filename"].split("/")[-1] filename = osp.splitext(filename)[0] with open(osp.join(data_dir, f"{filename}.pkl"), "wb") as fp: pickle.dump(datum, fp, protocol=pickle.HIGHEST_PROTOCOL) prog_bar.update()
def main(): args = parse_args() if args.output_dir is not None: mkdir_or_exist(args.output_dir) cfg = retrieve_data_cfg(args.config, args.skip_type, args.cfg_options) if cfg.data.train['type'] == 'RepeatDataset': cfg.data.train.dataset['pipeline'] = get_loading_pipeline( cfg.train_pipeline) else: cfg.data.train['pipeline'] = get_loading_pipeline(cfg.train_pipeline) dataset = build_dataset(cfg.data.train, default_args=dict(filter_empty_gt=False)) # For RepeatDataset type, the infos are stored in dataset.dataset if cfg.data.train['type'] == 'RepeatDataset': dataset = dataset.dataset data_infos = dataset.data_infos for idx, data_info in enumerate(track_iter_progress(data_infos)): if cfg.dataset_type in ['KittiDataset', 'WaymoDataset']: pts_path = data_info['point_cloud']['velodyne_path'] elif cfg.dataset_type in ['ScanNetDataset', 'SUNRGBDDataset']: pts_path = data_info['pts_path'] elif cfg.dataset_type in ['NuScenesDataset', 'LyftDataset']: pts_path = data_info['lidar_path'] else: raise NotImplementedError( f'unsupported dataset type {cfg.dataset_type}') file_name = osp.splitext(osp.basename(pts_path))[0] save_path = osp.join(args.output_dir, f'{file_name}.png') if args.output_dir else None example = dataset.prepare_train_data(idx) points = example['points']._data.numpy() points = Coord3DMode.convert_point(points, Coord3DMode.LIDAR, Coord3DMode.DEPTH) gt_bboxes = dataset.get_ann_info(idx)['gt_bboxes_3d'].tensor if gt_bboxes is not None: gt_bboxes = Box3DMode.convert(gt_bboxes, Box3DMode.LIDAR, Box3DMode.DEPTH) vis = Visualizer(points, save_path='./show.png') vis.add_bboxes(bbox3d=gt_bboxes, bbox_color=(0, 0, 1)) vis.show(save_path) del vis
def main(): args = parse_args() assert args.out or args.eval or args.format_only or args.show, \ ('Please specify at least one operation (save/eval/format/show the ' 'results) with the argument "--out", "--eval", "--format_only" ' 'or "--show"') if args.eval and args.format_only: raise ValueError('--eval and --format_only cannot be both specified') if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) dataset = build_dataset(cfg.data.test) if args.out: print('Loading outputs') outputs = mmcv.load(args.out) print('Loaded:', len(outputs)) # print(outputs[0]['pts_bbox'].keys()) # boxes_3d, scores_3d, labels_3d kwargs = {} if args.options is None else args.options if args.format_only: dataset.format_results(outputs, **kwargs) if args.eval: dataset.evaluate(outputs, args.eval, pkl_path=cfg.data.test.ann_file, jsonfile_prefix=args.json, **kwargs)
def setup(self, config_file, checkpoint_file, fuse_conv): cfg = Config.fromfile(config_file) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # build the dataloader # TODO: support multiple images per gpu (only minor changes are needed) dataset = build_dataset(cfg.data.test) data_loader = build_dataloader( dataset, samples_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) # build the model and load checkpoint model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) load_checkpoint(model, checkpoint_file, map_location='cpu') if fuse_conv: model = fuse_module(model) self._fuse_conv = fuse_conv model = MMDataParallel(model, device_ids=[0]) model.eval() return model, data_loader, dataset
def main(): args = parse_args() assert args.out or args.eval or args.format_only or args.show \ or args.show_dir, \ ('Please specify at least one operation (save/eval/format/show the ' 'results / save the results) with the argument "--out", "--eval"' ', "--format-only", "--show" or "--show-dir"') if args.eval and args.format_only: raise ValueError('--eval and --format_only cannot be both specified') if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = Config.fromfile(args.config) if args.cfg_options is not None: cfg.merge_from_dict(args.cfg_options) # import modules from string list. if cfg.get('custom_imports', None): from mmcv.utils import import_modules_from_strings import_modules_from_strings(**cfg['custom_imports']) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None # in case the test dataset is concatenated samples_per_gpu = 1 if isinstance(cfg.data.test, dict): cfg.data.test.test_mode = True samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) if samples_per_gpu > 1: # Replace 'ImageToTensor' to 'DefaultFormatBundle' cfg.data.test.pipeline = replace_ImageToTensor( cfg.data.test.pipeline) elif isinstance(cfg.data.test, list): for ds_cfg in cfg.data.test: ds_cfg.test_mode = True samples_per_gpu = max( [ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test]) if samples_per_gpu > 1: for ds_cfg in cfg.data.test: ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline) # 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) # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader dataset = build_dataset(cfg.data.test) data_loader = build_dataloader(dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=distributed, shuffle=False) # build the model and load checkpoint cfg.model.train_cfg = None model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg')) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_conv_bn(model) # old versions did not save class info in checkpoints, this walkaround is # for backward compatibility if 'CLASSES' in checkpoint.get('meta', {}): model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES if not distributed: model = MMDataParallel(model, device_ids=[0]) outputs = single_gpu_test(model, data_loader, args.show, args.show_dir) else: model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False) outputs = multi_gpu_test(model, data_loader, args.tmpdir, args.gpu_collect) rank, _ = get_dist_info() if rank == 0: if args.out: print(f'\nwriting results to {args.out}') mmcv.dump(outputs, args.out) kwargs = {} if args.eval_options is None else args.eval_options if args.format_only: dataset.format_results(outputs, **kwargs) if args.eval: eval_kwargs = cfg.get('evaluation', {}).copy() # hard-code way to remove EvalHook args for key in [ 'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best', 'rule' ]: eval_kwargs.pop(key, None) eval_kwargs.update(dict(metric=args.eval, **kwargs)) print(dataset.evaluate(outputs, **eval_kwargs))
def main(): args = parse_args() cfg = Config.fromfile(args.config) if args.cfg_options is not None: cfg.merge_from_dict(args.cfg_options) # import modules from string list. if cfg.get('custom_imports', None): from mmcv.utils import import_modules_from_strings import_modules_from_strings(**cfg['custom_imports']) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True # work_dir is determined in this priority: CLI > segment in file > filename if args.work_dir is not None: # update configs according to CLI args if args.work_dir is not None cfg.work_dir = args.work_dir elif cfg.get('work_dir', None) is None: # use config filename as default work_dir if cfg.work_dir is None cfg.work_dir = osp.join('./work_dirs', osp.splitext(osp.basename(args.config))[0]) if args.resume_from is not None: cfg.resume_from = args.resume_from if args.gpu_ids is not None: cfg.gpu_ids = args.gpu_ids else: cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus) if args.autoscale_lr: # apply the linear scaling rule (https://arxiv.org/abs/1706.02677) cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8 # 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) # re-set gpu_ids with distributed training mode _, world_size = get_dist_info() cfg.gpu_ids = range(world_size) # create work_dir mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir)) # dump config cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config))) # init the logger before other steps timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) log_file = osp.join(cfg.work_dir, f'{timestamp}.log') logger = get_root_logger(log_file=log_file, log_level=cfg.log_level) # add a logging filter logging_filter = logging.Filter('mmdet') logging_filter.filter = lambda record: record.find('mmdet') != -1 # init the meta dict to record some important information such as # environment info and seed, which will be logged meta = dict() # log env info env_info_dict = collect_env() env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()]) dash_line = '-' * 60 + '\n' logger.info('Environment info:\n' + dash_line + env_info + '\n' + dash_line) meta['env_info'] = env_info meta['config'] = cfg.pretty_text # log some basic info logger.info(f'Distributed training: {distributed}') logger.info(f'Config:\n{cfg.pretty_text}') # set random seeds if args.seed is not None: logger.info(f'Set random seed to {args.seed}, ' f'deterministic: {args.deterministic}') set_random_seed(args.seed, deterministic=args.deterministic) cfg.seed = args.seed meta['seed'] = args.seed meta['exp_name'] = osp.basename(args.config) model = build_detector(cfg.model, train_cfg=cfg.get('train_cfg'), test_cfg=cfg.get('test_cfg')) logger.info(f'Model:\n{model}') datasets = [build_dataset(cfg.data.train)] if len(cfg.workflow) == 2: val_dataset = copy.deepcopy(cfg.data.val) # in case we use a dataset wrapper if 'dataset' in cfg.data.train: val_dataset.pipeline = cfg.data.train.dataset.pipeline else: val_dataset.pipeline = cfg.data.train.pipeline # set test_mode=False here in deep copied config # which do not affect AP/AR calculation later # refer to https://mmdetection3d.readthedocs.io/en/latest/tutorials/customize_runtime.html#customize-workflow # noqa val_dataset.test_mode = False datasets.append(build_dataset(val_dataset)) if cfg.checkpoint_config is not None: # save mmdet version, config file content and class names in # checkpoints as meta data cfg.checkpoint_config.meta = dict(mmdet_version=__version__, config=cfg.pretty_text, CLASSES=datasets[0].CLASSES) # add an attribute for visualization convenience model.CLASSES = datasets[0].CLASSES train_detector(model, datasets, cfg, distributed=distributed, validate=(not args.no_validate), timestamp=timestamp, meta=meta)
parser.add_argument("--idx", type=int, nargs='+', default=0, help="Sample index in the dataset") parser.add_argument("--outdir", type=str, default='cache/', help="Path to the output directory") args = parser.parse_args() # Build dataset and model cfg = mmcv.Config.fromfile(args.cfg) dataset = build_dataset(cfg.data.val) model = init_detector(args.cfg, args.ckpt, device='cuda') # Execution function def execution(idx): global dataset, model, cfg, args print() # Select and infer a sample sample = dataset.__getitem__(idx) if isinstance(sample['img_metas'], list): filename = sample['img_metas'][0].data['pts_filename'] else: filename = sample['img_metas'].data['pts_filename']
def main(): args = parse_args() assert args.out or args.eval or args.format_only or args.show, \ ('Please specify at least one operation (save/eval/format/show the ' 'results) with the argument "--out", "--eval", "--format_only" ' 'or "--show"') if args.eval and args.format_only: raise ValueError('--eval and --format_only cannot be both specified') #if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): # raise ValueError('The output file must be a pkl file.') cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # 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) # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) dataset = build_dataset(cfg.data.test) data_loader = build_dataloader(dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=distributed, shuffle=False) # build the model and load checkpoint model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_module(model) # old versions did not save class info in checkpoints, this walkaround is # for backward compatibility if 'CLASSES' in checkpoint['meta']: model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES if not distributed: model = MMDataParallel(model, device_ids=[0]) outputs = single_gpu_test(model, data_loader, args.show, args.show_dir) else: model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False) outputs = multi_gpu_test(model, data_loader, args.tmpdir, args.gpu_collect) #pkl_saved_path = '/home/radmin/jk/code/seg/SelectiveSeg/work_dirs/20210322_pano_all_preds/results/output_pkl/results.pkl' #outputs = mmcv.load(pkl_saved_path) rank, _ = get_dist_info() if rank == 0: if args.out and args.need_pkl_res: pkl_res_path = os.path.join(args.out, 'output_pkl') mmcv.mkdir_or_exist(pkl_res_path) pkl_res_path = os.path.join(pkl_res_path, 'results.pkl') print(f'\nwriting results to {pkl_res_path}') mmcv.dump(outputs, pkl_res_path) if args.need_bin_res: import torch import numpy as np bin_res_path = os.path.join(args.out, 'pred_label') mmcv.mkdir_or_exist(bin_res_path) box_res_path = os.path.join(args.out, 'box_label') mmcv.mkdir_or_exist(box_res_path) for i, res in enumerate(outputs): sem_preds = res['sem_preds'] if 'ins_preds' not in res: ins_preds = torch.zeros_like(sem_preds) else: ins_preds = res['ins_preds'] preds = torch.stack([sem_preds, ins_preds], dim=-1) preds = preds.cpu().numpy() preds = np.array(preds, dtype=np.uint8) file_name = str(i).zfill(6) postfix = '.bin' preds.tofile(bin_res_path + '/' + file_name + postfix) if 'pts_bbox' in res: bbox_preds = res['pts_bbox'] bbox_3d = bbox_preds['boxes_3d'].tensor dim = bbox_3d.size(1) if dim == 3: pseudo_size = bbox_3d.new_ones((bbox_3d.size(0), 3)) pseudo_theta = bbox_3d.new_zeros((bbox_3d.size(0), 1)) bbox_3d = torch.cat( [bbox_3d, pseudo_size, pseudo_theta], dim=1) else: # check here bbox_3d = torch.cat([ bbox_preds['boxes_3d'].gravity_center, bbox_preds['boxes_3d'].tensor[:, 3:] ], dim=1) temp_label = bbox_preds['labels_3d'].view(-1, 1) temp_score = bbox_preds['scores_3d'].view(-1, 1) temp_id = torch.zeros_like(temp_score) file_bbox_3d = torch.cat( [temp_label, bbox_3d, temp_score, temp_id], dim=1) file_bbox_3d = file_bbox_3d.numpy() postfix = '.txt' np.savetxt(box_res_path + '/' + file_name + postfix, file_bbox_3d, fmt='%.3f') if 'seg' in args.eval: mmcv.mkdir_or_exist(args.out) dataset.evaluate_seg(outputs, result_names=['sem_preds'], out_dir=args.out) elif 'pano' in args.eval: import numpy as np from selective_seg.util_tools.evaluate_panoptic import init_eval, printResults, eval_one_scan #log_file = osp.join(args.out, f'{timestamp}.log') log_file = os.path.join(args.out, 'pano_res.log') logger = get_root_logger(log_file=log_file, log_level=cfg.log_level) gt_label_path = '/data/nuscenes_opendata/ordered_seg_label/val/seg_ins_mask' mmcv.mkdir_or_exist(args.out) min_points = 15 # 15 for nuscenes, 50 for semantickitti official param evaluator = init_eval(dataset_type=cfg['dataset_type'], min_points=min_points) for i in range(len(outputs)): gt_file_path = os.path.join(gt_label_path, str(i).zfill(6) + '.bin') gt_labels = np.fromfile(gt_file_path, dtype=np.uint8).reshape(-1, 2) gt_sem_labels = gt_labels[:, 0] gt_ins_labels = gt_labels[:, 1] pred_sem_labels = outputs[i]['sem_preds'].cpu().numpy() pred_ins_labels = outputs[i]['ins_preds'].cpu().numpy() eval_one_scan(evaluator, gt_sem_labels, gt_ins_labels, pred_sem_labels, pred_ins_labels) eval_results = printResults(evaluator, logger=logger) '''
def create_groundtruth_database(dataset_class_name, data_path, info_prefix, info_path=None, mask_anno_path=None, used_classes=None, database_save_path=None, db_info_save_path=None, relative_path=True, add_rgb=False, lidar_only=False, bev_only=False, coors_range=None, with_mask=False): """Given the raw data, generate the ground truth database. Args: dataset_class_name (str): Name of the input dataset. data_path (str): Path of the data. info_prefix (str): Prefix of the info file. info_path (str): Path of the info file. Default: None. mask_anno_path (str): Path of the mask_anno. Default: None. used_classes (list[str]): Classes have been used. Default: None. database_save_path (str): Path to save database. Default: None. db_info_save_path (str): Path to save db_info. Default: None. relative_path (bool): Whether to use relative path. Default: True. with_mask (bool): Whether to use mask. Default: False. """ print(f'Create GT Database of {dataset_class_name}') dataset_cfg = dict(type=dataset_class_name, data_root=data_path, ann_file=info_path) if dataset_class_name == 'KittiDataset': file_client_args = dict(backend='disk') dataset_cfg.update(test_mode=False, split='training', modality=dict( use_lidar=True, use_depth=False, use_lidar_intensity=True, use_camera=with_mask, ), pipeline=[ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4, file_client_args=file_client_args), dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True, file_client_args=file_client_args) ]) elif dataset_class_name == 'NuScenesDataset': dataset_cfg.update(use_valid_flag=True, pipeline=[ dict(type='LoadPointsFromFile', load_dim=5, use_dim=5), dict(type='LoadPointsFromMultiSweeps', coord_type='LIDAR', sweeps_num=10, use_dim=[0, 1, 2, 3, 4], pad_empty_sweeps=True, remove_close=True), dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True) ]) elif dataset_class_name == 'WaymoDataset': file_client_args = dict(backend='disk') dataset_cfg.update(test_mode=False, split='training', modality=dict( use_lidar=True, use_depth=False, use_lidar_intensity=True, use_camera=False, ), pipeline=[ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=6, use_dim=5, file_client_args=file_client_args), dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True, file_client_args=file_client_args) ]) dataset = build_dataset(dataset_cfg) if database_save_path is None: database_save_path = osp.join(data_path, f'{info_prefix}_gt_database') if db_info_save_path is None: db_info_save_path = osp.join(data_path, f'{info_prefix}_dbinfos_train.pkl') mmcv.mkdir_or_exist(database_save_path) all_db_infos = dict() if with_mask: coco = COCO(osp.join(data_path, mask_anno_path)) imgIds = coco.getImgIds() file2id = dict() for i in imgIds: info = coco.loadImgs([i])[0] file2id.update({info['file_name']: i}) group_counter = 0 for j in track_iter_progress(list(range(len(dataset)))): input_dict = dataset.get_data_info(j) dataset.pre_pipeline(input_dict) example = dataset.pipeline(input_dict) annos = example['ann_info'] image_idx = example['sample_idx'] points = example['points'].tensor.numpy() gt_boxes_3d = annos['gt_bboxes_3d'].tensor.numpy() names = annos['gt_names'] group_dict = dict() if 'group_ids' in annos: group_ids = annos['group_ids'] else: group_ids = np.arange(gt_boxes_3d.shape[0], dtype=np.int64) difficulty = np.zeros(gt_boxes_3d.shape[0], dtype=np.int32) if 'difficulty' in annos: difficulty = annos['difficulty'] num_obj = gt_boxes_3d.shape[0] point_indices = box_np_ops.points_in_rbbox(points, gt_boxes_3d) if with_mask: # prepare masks gt_boxes = annos['gt_bboxes'] img_path = osp.split(example['img_info']['filename'])[-1] if img_path not in file2id.keys(): print(f'skip image {img_path} for empty mask') continue img_id = file2id[img_path] kins_annIds = coco.getAnnIds(imgIds=img_id) kins_raw_info = coco.loadAnns(kins_annIds) kins_ann_info = _parse_coco_ann_info(kins_raw_info) h, w = annos['img_shape'][:2] gt_masks = [ _poly2mask(mask, h, w) for mask in kins_ann_info['masks'] ] # get mask inds based on iou mapping bbox_iou = bbox_overlaps(kins_ann_info['bboxes'], gt_boxes) mask_inds = bbox_iou.argmax(axis=0) valid_inds = (bbox_iou.max(axis=0) > 0.5) # mask the image # use more precise crop when it is ready # object_img_patches = np.ascontiguousarray( # np.stack(object_img_patches, axis=0).transpose(0, 3, 1, 2)) # crop image patches using roi_align # object_img_patches = crop_image_patch_v2( # torch.Tensor(gt_boxes), # torch.Tensor(mask_inds).long(), object_img_patches) object_img_patches, object_masks = crop_image_patch( gt_boxes, gt_masks, mask_inds, annos['img']) for i in range(num_obj): filename = f'{image_idx}_{names[i]}_{i}.bin' abs_filepath = osp.join(database_save_path, filename) rel_filepath = osp.join(f'{info_prefix}_gt_database', filename) # save point clouds and image patches for each object gt_points = points[point_indices[:, i]] gt_points[:, :3] -= gt_boxes_3d[i, :3] if with_mask: if object_masks[i].sum() == 0 or not valid_inds[i]: # Skip object for empty or invalid mask continue img_patch_path = abs_filepath + '.png' mask_patch_path = abs_filepath + '.mask.png' mmcv.imwrite(object_img_patches[i], img_patch_path) mmcv.imwrite(object_masks[i], mask_patch_path) with open(abs_filepath, 'w') as f: gt_points.tofile(f) if (used_classes is None) or names[i] in used_classes: db_info = { 'name': names[i], 'path': rel_filepath, 'image_idx': image_idx, 'gt_idx': i, 'box3d_lidar': gt_boxes_3d[i], 'num_points_in_gt': gt_points.shape[0], 'difficulty': difficulty[i], } local_group_id = group_ids[i] # if local_group_id >= 0: if local_group_id not in group_dict: group_dict[local_group_id] = group_counter group_counter += 1 db_info['group_id'] = group_dict[local_group_id] if 'score' in annos: db_info['score'] = annos['score'][i] if with_mask: db_info.update({'box2d_camera': gt_boxes[i]}) if names[i] in all_db_infos: all_db_infos[names[i]].append(db_info) else: all_db_infos[names[i]] = [db_info] for k, v in all_db_infos.items(): print(f'load {len(v)} {k} database infos') with open(db_info_save_path, 'wb') as f: pickle.dump(all_db_infos, f)
# 'classes': ['car', 'truck', 'trailer', 'bus', 'construction_vehicle', 'bicycle', 'motorcycle', 'pedestrian', 'traffic_cone', 'barrier'], 'modality': {'use_lidar': True, 'use_camera': False, 'use_radar': False, 'use_map': False, 'use_external': False}, 'test_mode': False, 'box_type_3d': 'LiDAR', 'dataset': {'type': 'NuScenesDataset', 'data_root': 'data/nuscenes/', 'ann_file': 'data/nuscenes/nuscenes_infos_train.pkl', 'pipeline': [{'type': 'LoadPointsFromFile', 'coord_type': 'LIDAR', 'load_dim': 5, 'use_dim': 5, 'file_client_args': {'backend': 'disk'}}, {'type': 'LoadPointsFromMultiSweeps', 'sweeps_num': 9, 'use_dim': [0, 1, 2, 3, 4], 'file_client_args': {'backend': 'disk'}, 'pad_empty_sweeps': True, 'remove_close': True}, {'type': 'LoadAnnotations3D', 'with_bbox_3d': True, 'with_label_3d': True}, {'type': 'ObjectSample', 'db_sampler': {'data_root': 'data/nuscenes/', 'info_path': 'data/nuscenes/nuscenes_dbinfos_train.pkl', 'rate': 1.0, 'prepare': {'filter_by_difficulty': [-1], 'filter_by_min_points': {'car': 5, 'truck': 5, 'bus': 5, 'trailer': 5, 'construction_vehicle': 5, 'traffic_cone': 5, 'barrier': 5, 'motorcycle': 5, 'bicycle': 5, 'pedestrian': 5}}, 'classes': ['car', 'truck', 'construction_vehicle', 'bus', 'trailer', 'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone'], 'sample_groups': {'car': 2, 'truck': 3, 'construction_vehicle': 7, 'bus': 4, 'trailer': 6, 'barrier': 2, 'motorcycle': 6, 'bicycle': 6, 'pedestrian': 2, 'traffic_cone': 2}, 'points_loader': {'type': 'LoadPointsFromFile', 'coord_type': 'LIDAR', 'load_dim': 5, 'use_dim': [0, 1, 2, 3, 4], 'file_client_args': {'backend': 'disk'}}, 'type': 'DataBaseSampler'}}, {'type': 'GlobalRotScaleTrans', 'rot_range': [-0.3925, 0.3925], 'scale_ratio_range': [0.95, 1.05], 'translation_std': [0, 0, 0]}, {'type': 'RandomFlip3D', 'sync_2d': False, 'flip_ratio_bev_horizontal': 0.5, 'flip_ratio_bev_vertical': 0.5}, {'type': 'PointsRangeFilter', 'point_cloud_range': [-51.2, -51.2, -5.0, 51.2, 51.2, 3.0]}, {'type': 'ObjectRangeFilter', 'point_cloud_range': [-51.2, -51.2, -5.0, 51.2, 51.2, 3.0]}, {'type': 'ObjectNameFilter', 'classes': ['car', 'truck', 'construction_vehicle', 'bus', 'trailer', 'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone']}, {'type': 'PointShuffle'}, {'type': 'DefaultFormatBundle3D', 'class_names': ['car', 'truck', 'construction_vehicle', 'bus', 'trailer', 'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone']}, {'type': 'Collect3D', 'keys': ['points', 'gt_bboxes_3d', 'gt_labels_3d']}], 'classes': ['car', 'truck', 'construction_vehicle', 'bus', 'trailer', 'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone'], 'load_interval': 1, 'test_mode': False, 'use_valid_flag': True, 'box_type_3d': 'LiDAR'}} train = dict( type=dataset_type, data_root=data_root, ann_file=data_root + 'nuscenes_infos_train.pkl', pipeline=train_pipeline, classes=class_names, load_interval=1, test_mode=False, use_valid_flag=True, # we use box_type_3d='LiDAR' in kitti and nuscenes dataset # and box_type_3d='Depth' in sunrgbd and scannet dataset. box_type_3d='LiDAR') dataset = build_dataset(train) #data_loader = build_dataloader(dataset, 1, 3, 1, dist=False, seed=816) # #import ipdb; ipdb.set_trace() #for data in data_loader: # print(data) print(len(dataset)) i = 0 while i < len(dataset): i = np.random.randint(len(dataset)) print(f'showing data sample {i}') if dataset.show_data(i, 'visualization/nuscenes/'): i += 10 else:
def main(): args = parse_args() cfg = Config.fromfile(args.config) if args.cfg_options is not None: cfg.merge_from_dict(args.cfg_options) # import modules from plguin/xx, registry will be updated if hasattr(cfg, 'plugin') & cfg.plugin: import importlib if hasattr(cfg, 'plugin_dir'): plugin_dir = cfg.plugin_dir _module_dir = os.path.dirname(plugin_dir) _module_dir = _module_dir.split('/') _module_path = _module_dir[0] for m in _module_dir[1:]: _module_path = _module_path + '.' + m print(_module_path) plg_lib = importlib.import_module(_module_path) else: # import dir is the dirpath for the config file _module_dir = os.path.dirname(args.config) _module_dir = _module_dir.split('/') _module_path = _module_dir[0] for m in _module_dir[1:]: _module_path = _module_path + '.' + m print(_module_path) plg_lib = importlib.import_module(_module_path) # import modules from string list. # if cfg.get('custom_imports', None): # from mmcv.utils import import_modules_from_strings # import_modules_from_strings(**cfg['custom_imports']) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None # in case the test dataset is concatenated samples_per_gpu = 1 if isinstance(cfg.data.test, dict): cfg.data.test.test_mode = True samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) if samples_per_gpu > 1: # Replace 'ImageToTensor' to 'DefaultFormatBundle' cfg.data.test.pipeline = replace_ImageToTensor( cfg.data.test.pipeline) elif isinstance(cfg.data.test, list): for ds_cfg in cfg.data.test: ds_cfg.test_mode = True samples_per_gpu = max( [ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test]) if samples_per_gpu > 1: for ds_cfg in cfg.data.test: ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline) # 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) # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader dataset = build_dataset(cfg.data.test) data_loader = build_dataloader(dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=distributed, shuffle=False) if not os.path.exists(args.out_dir): os.mkdir(args.out_dir) # build the model and load checkpoint cfg.model.train_cfg = None model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg')) #from IPython import embed #embed() fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) #if args.checkpoint is not None: # checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_conv_bn(model) if not distributed: model = MMDataParallel(model, device_ids=[0]) else: model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False) model.eval() meta_json = {} print('len of data loader: ', len(data_loader)) for i, data in tqdm(enumerate(data_loader)): with torch.no_grad(): data = scatter(data, [-1])[0] for k, v in data.items(): if isinstance(v, torch.Tensor): data[k] = v.cuda() key_img_path = data['img_metas'][0]['filename'] key_img_name = os.path.join(*key_img_path.split('/')[2:]) key_img_filename = key_img_path.split('/')[-1] save_path = os.path.join(args.out_dir, key_img_filename) outputs = model.module.preprocess_forward(data) outputs = outputs.detach().cpu().numpy() np.save(save_path, outputs) meta_json[key_img_name] = save_path + '.npy' with open( os.path.join(args.out_dir, 'sf_inp_val_meta_{}.json'.format(args.local_rank)), 'w') as f: json.dump(meta_json, f)
def main(): args = parse_args() if args.output_dir is not None: mkdir_or_exist(args.output_dir) cfg = build_data_cfg(args.config, args.skip_type, args.cfg_options) try: dataset = build_dataset(cfg.data.train, default_args=dict(filter_empty_gt=False)) except TypeError: # seg dataset doesn't have `filter_empty_gt` key dataset = build_dataset(cfg.data.train) data_infos = dataset.data_infos dataset_type = cfg.dataset_type # configure visualization mode vis_type = 'det' # single-modality detection if dataset_type in ['ScanNetSegDataset', 'S3DISSegDataset']: vis_type = 'seg' # segmentation multi_modality = args.multi_modality if multi_modality: # check whether dataset really supports multi-modality input if not is_multi_modality(dataset): warnings.warn( f'{dataset_type} with current config does not support multi-' 'modality data loading, only show point clouds here') multi_modality = False for idx, data_info in enumerate(track_iter_progress(data_infos)): if dataset_type in ['KittiDataset', 'WaymoDataset']: pts_path = data_info['point_cloud']['velodyne_path'] elif dataset_type in [ 'ScanNetDataset', 'SUNRGBDDataset', 'ScanNetSegDataset', 'S3DISSegDataset' ]: pts_path = data_info['pts_path'] elif dataset_type in ['NuScenesDataset', 'LyftDataset']: pts_path = data_info['lidar_path'] else: raise NotImplementedError( f'unsupported dataset type {dataset_type}') file_name = osp.splitext(osp.basename(pts_path))[0] if vis_type == 'det': # show 3D bboxes on 3D point clouds show_det_data(idx, dataset, args.output_dir, file_name, show=args.online) if multi_modality: # project 3D bboxes to 2D image show_proj_bbox_img(idx, dataset, args.output_dir, file_name, show=args.online) elif vis_type == 'seg': # show 3D segmentation mask on 3D point clouds show_seg_data(idx, dataset, args.output_dir, file_name, show=args.online)
from mmdet3d.datasets import NuScenesDataset from mmdet3d.datasets import build_dataset from mmdet.datasets import build_dataloader from mmcv import Config, DictAction import os.path as osp import argparse import numpy as np parser = argparse.ArgumentParser() parser.add_argument('config', help='train config file path') args = parser.parse_args() np.random.seed(0) # fix dataset items cfg = Config.fromfile(args.config) print('cfg loaded') # dataset = build_dataset(cfg.data.source_train) dataset = build_dataset(cfg.data.source_test) print('dataset loaded') print() # import open3d as o3d # pcd = o3d.geometry.PointCloud() # v3d = o3d.utility.Vector3dVector k = len(dataset) print('len dataset:', k) # 15695 for i in range(5): # data_info = dataset.get_data_info(i) # print(data_info['pts_filename']) # print(data_info['img_filename'][0]) data = dataset[i]
parser.add_argument("--idx", type=int, nargs='+', default=0, help="Sample index in the dataset") parser.add_argument("--outdir", type=str, default='cache/', help="Path to the output directory") args = parser.parse_args() # Build dataset cfg = mmcv.Config.fromfile(args.cfg) dataset = build_dataset(cfg.data.train) img_norm_cfg = cfg.get('img_norm_cfg', None) if img_norm_cfg is not None: _MEAN = torch.tensor(img_norm_cfg['mean']) _STD = torch.tensor(img_norm_cfg['std']) # Execution def execution(idx): # Select and infer a sample print("\nProcessing idx {}...".format(idx)) sample = dataset.__getitem__(idx) # Get img_file img_file = None
def main(): args = parse_args() cfg = Config.fromfile(args.config) # import modules from plguin/xx, registry will be updated if hasattr(cfg, 'plugin') & cfg.plugin: import importlib _module_dir = os.path.dirname(args.config) _module_dir = _module_dir.split('/') _module_path = _module_dir[0] for m in _module_dir[1:]: _module_path = _module_path + '.' + m print(_module_path) plg_lib = importlib.import_module(_module_path) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # build the dataloader # TODO: support multiple images per gpu (only minor changes are needed) dataset = build_dataset(cfg.data.test) data_loader = build_dataloader( dataset, samples_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) # build the model and load checkpoint cfg.model.train_cfg = None model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg')) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) #load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_module(model) model = MMDataParallel(model, device_ids=[0]) model.eval() # the first several iterations may be very slow so skip them num_warmup = 5 pure_inf_time = 0 # benchmark with several samples and take the average for i, data in enumerate(data_loader): torch.cuda.synchronize() start_time = time.perf_counter() img_keys = ['img{}'.format(i) for i in range(18)] now_depth_keys = ['depth_map{}'.format(i) for i in range(6, 12)] now_sf_keys = ['sf_map{}'.format(i) for i in range(6, 12)] # Imgs! # shape [18, N, 3, H, W] imgs = [data[tmp_key] for tmp_key in img_keys] prev_imgs, now_imgs, next_imgs = imgs[0:6], imgs[6:12], imgs[12:] # shape [N*6, 3, H, W] prev_imgs = torch.cat(prev_imgs, dim=0) now_imgs = torch.cat(now_imgs, dim=0) next_imgs = torch.cat(next_imgs, dim=0) now_depth = torch.cat([data[tmp_key] for tmp_key in now_depth_keys], dim=0) now_depth = now_depth.unsqueeze(dim=1) now_sf = torch.cat([data[tmp_key] for tmp_key in now_sf_keys], dim=0) now_sf = now_sf.permute(0, 3, 1, 2) all_imgs = torch.cat([prev_imgs, now_imgs, next_imgs], dim=0) camera_intrinsic = data['cam_intrinsic'] #img_x, img_y = now_imgs.size(-2), now_imgs.size(-1) img_x, img_y = now_imgs.size(-1), now_imgs.size(-2) #print(now_imgs.shape) scale_x = img_x / 1600 scale_y = img_y / 900 camera_intrinsic = scale_intrinsics(camera_intrinsic, scale_x, scale_y) prev_cam_intrin = camera_intrinsic[:, 0:6, ...].view(-1, 3, 3) now_cam_intrin = camera_intrinsic[:, 6:12, ...].view(-1, 3, 3) next_cam_intrin = camera_intrinsic[:, 12:18, ...].view(-1, 3, 3) cam_pose = data['cam_pose'] # [N, 6, 4, 4] => [N*6, 4, 4] prev_cam_pose = cam_pose[:, 0:6, ...].view(-1, 4, 4) now_cam_pose = cam_pose[:, 6:12, ...].view(-1, 4, 4) next_cam_pose = cam_pose[:, 12:18, ...].view(-1, 4, 4) B, _, H, W = now_imgs.shape with torch.no_grad(): #fused_motion = (now2next_sf_pred - now2prev_sf_pred) / 2 real_sf = convert_res_sf_to_sf(now_cam_intrin, next_cam_intrin, now_cam_pose, next_cam_pose, now_depth, now_sf/10.0)
def main(): args = parse_args() cfg = Config.fromfile(args.config) if args.options is not None: cfg.merge_from_dict(args.options) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True # work_dir is determined in this priority: CLI > segment in file > filename if args.work_dir is not None: # update configs according to CLI args if args.work_dir is not None cfg.work_dir = args.work_dir elif cfg.get('work_dir', None) is None: # use config filename as default work_dir if cfg.work_dir is None cfg.work_dir = osp.join('./work_dirs', osp.splitext(osp.basename(args.config))[0]) if args.resume_from is not None: cfg.resume_from = args.resume_from if args.gpu_ids is not None: cfg.gpu_ids = args.gpu_ids else: cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus) if args.autoscale_lr: # apply the linear scaling rule (https://arxiv.org/abs/1706.02677) cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8 # 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) # create work_dir mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir)) # init the logger before other steps timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) log_file = osp.join(cfg.work_dir, f'{timestamp}.log') logger = get_root_logger(log_file=log_file, log_level=cfg.log_level) # add a logging filter logging_filter = logging.Filter('mmdet') logging_filter.filter = lambda record: record.find('mmdet') != -1 # init the meta dict to record some important information such as # environment info and seed, which will be logged meta = dict() # log env info env_info_dict = collect_env() env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()]) dash_line = '-' * 60 + '\n' logger.info('Environment info:\n' + dash_line + env_info + '\n' + dash_line) meta['env_info'] = env_info # log some basic info logger.info(f'Distributed training: {distributed}') logger.info(f'Config:\n{cfg.pretty_text}') # set random seeds if args.seed is not None: logger.info(f'Set random seed to {args.seed}, ' f'deterministic: {args.deterministic}') set_random_seed(args.seed, deterministic=args.deterministic) cfg.seed = args.seed meta['seed'] = args.seed model = build_detector(cfg.model) logger.info(f'Model:\n{model}') datasets = [ build_dataset(cfg.data.source_train), build_dataset(cfg.data.target_train) ] # if len(cfg.workflow) == 2: # val_dataset = copy.deepcopy(cfg.data.val) # val_dataset.pipeline = cfg.data.train.pipeline # datasets.append(build_dataset(val_dataset)) if cfg.checkpoint_config is not None: # save mmdet version, config file content and class names in # checkpoints as meta data cfg.checkpoint_config.meta = dict(mmdet_version=__version__, config=cfg.pretty_text, CLASSES=datasets[0].CLASSES) # add an attribute for visualization convenience model.CLASSES = datasets[0].CLASSES train_single_seg_detector(model, datasets, cfg, distributed=distributed, timestamp=timestamp, meta=meta)
from mmdet3d.datasets import NuScenesDataset from mmdet3d.datasets import build_dataset from mmdet.datasets import build_dataloader from mmcv import Config, DictAction import os.path as osp import argparse import numpy as np parser = argparse.ArgumentParser() parser.add_argument('--config', help='train config file path') args = parser.parse_args() np.random.seed(0) # fix dataset items cfg = Config.fromfile(args.config) print('cfg loaded') source_train = build_dataset(cfg.data.source_train) source_test = build_dataset(cfg.data.source_test) # target_train = build_dataset(cfg.data.target_train) # target_test = build_dataset(cfg.data.target_test) # target_val = build_dataset(cfg.data.target_val) dss = [source_train, source_test] print('dataset splits loaded') print() # import open3d as o3d # pcd = o3d.geometry.PointCloud() # v3d = o3d.utility.Vector3dVector num_classes = len(source_train.SEG_CLASSES) source_train_count = np.zeros(num_classes, dtype=np.int64) source_test_count = np.zeros(num_classes, dtype=np.int64)
def main(): args = parse_args() cfg = Config.fromfile(args.config) if args.cfg_options is not None: cfg.merge_from_dict(args.cfg_options) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True # work_dir is determined in this priority: CLI > segment in file > filename if args.work_dir is not None: # update configs according to CLI args if args.work_dir is not None cfg.work_dir = args.work_dir elif cfg.get('work_dir', None) is None: # use config filename as default work_dir if cfg.work_dir is None cfg.work_dir = osp.join('./work_dirs', osp.splitext(osp.basename(args.config))[0]) if args.resume_from is not None: cfg.resume_from = args.resume_from if args.gpus is not None: cfg.gpu_ids = range(1) warnings.warn('`--gpus` is deprecated because we only support ' 'single GPU mode in non-distributed training. ' 'Use `gpus=1` now.') if args.gpu_ids is not None: cfg.gpu_ids = args.gpu_ids[0:1] warnings.warn('`--gpu-ids` is deprecated, please use `--gpu-id`. ' 'Because we only support single GPU mode in ' 'non-distributed training. Use the first GPU ' 'in `gpu_ids` now.') if args.gpus is None and args.gpu_ids is None: cfg.gpu_ids = [args.gpu_id] if args.autoscale_lr: # apply the linear scaling rule (https://arxiv.org/abs/1706.02677) cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8 # 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) # re-set gpu_ids with distributed training mode _, world_size = get_dist_info() cfg.gpu_ids = range(world_size) # create work_dir mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir)) # dump config cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config))) # init the logger before other steps timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) log_file = osp.join(cfg.work_dir, f'{timestamp}.log') # specify logger name, if we still use 'mmdet', the output info will be # filtered and won't be saved in the log_file # TODO: ugly workaround to judge whether we are training det or seg model if cfg.model.type in ['EncoderDecoder3D']: logger_name = 'mmseg' else: logger_name = 'mmdet' logger = get_root_logger(log_file=log_file, log_level=cfg.log_level, name=logger_name) # init the meta dict to record some important information such as # environment info and seed, which will be logged meta = dict() # log env info env_info_dict = collect_env() env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()]) dash_line = '-' * 60 + '\n' logger.info('Environment info:\n' + dash_line + env_info + '\n' + dash_line) meta['env_info'] = env_info meta['config'] = cfg.pretty_text # log some basic info logger.info(f'Distributed training: {distributed}') logger.info(f'Config:\n{cfg.pretty_text}') # set random seeds if args.seed is not None: logger.info(f'Set random seed to {args.seed}, ' f'deterministic: {args.deterministic}') set_random_seed(args.seed, deterministic=args.deterministic) cfg.seed = args.seed meta['seed'] = args.seed meta['exp_name'] = osp.basename(args.config) model = build_model(cfg.model, train_cfg=cfg.get('train_cfg'), test_cfg=cfg.get('test_cfg')) model.init_weights() logger.info(f'Model:\n{model}') datasets = [build_dataset(cfg.data.train)] if len(cfg.workflow) == 2: val_dataset = copy.deepcopy(cfg.data.val) # in case we use a dataset wrapper if 'dataset' in cfg.data.train: val_dataset.pipeline = cfg.data.train.dataset.pipeline else: val_dataset.pipeline = cfg.data.train.pipeline # set test_mode=False here in deep copied config # which do not affect AP/AR calculation later # refer to https://mmdetection3d.readthedocs.io/en/latest/tutorials/customize_runtime.html#customize-workflow # noqa val_dataset.test_mode = False datasets.append(build_dataset(val_dataset)) if cfg.checkpoint_config is not None: # save mmdet version, config file content and class names in # checkpoints as meta data cfg.checkpoint_config.meta = dict( mmdet_version=mmdet_version, mmseg_version=mmseg_version, mmdet3d_version=mmdet3d_version, config=cfg.pretty_text, CLASSES=datasets[0].CLASSES, PALETTE=datasets[0].PALETTE # for segmentors if hasattr(datasets[0], 'PALETTE') else None) # add an attribute for visualization convenience model.CLASSES = datasets[0].CLASSES train_model(model, datasets, cfg, distributed=distributed, validate=(not args.no_validate), timestamp=timestamp, meta=meta)
def main(): args = parse_args() assert args.out or args.eval or args.format_only or args.show, \ ('Please specify at least one operation (save/eval/format/show the ' 'results) with the argument "--out", "--eval", "--format_only" ' 'or "--show"') if args.eval and args.format_only: raise ValueError('--eval and --format_only cannot be both specified') if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg_start_time = time.time() cfg = Config.fromfile(args.config) cfg_last = time.time() - cfg_start_time print('cfg time:', cfg_last) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) dataset_start_time = time.time() dataset = build_dataset(cfg.data.test) data_loader = build_dataloader(dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=False, shuffle=False) dataset_last = time.time() - dataset_start_time print('dataset & dataloader time:', dataset_last) # data_batch = iter(data_loader).next() # print(len(data_batch['points'][0].data[0])) # print(type(data_batch['seg_label'][0].data[0][0])) # print(data_batch['seg_label'][0].data[0][0].shape) # build the model and load checkpoint model_start_time = time.time() model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_module(model) # old versions did not save class info in checkpoints, this walkaround is # for backward compatibility if 'CLASSES' in checkpoint['meta']: model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES model_time = time.time() - model_start_time print('model time:', model_time) model = MMDataParallel(model, device_ids=[0]) # outputs = mmda_single_gpu_test(model, data_loader, args.show, args.show_dir) # len(outputs)=len(dataset) outputs = single_gpu_test(model, data_loader, args.show, args.show_dir) # len(outputs)=len(dataset) if args.out: print(f'\nwriting results to {args.out}') mmcv.dump(outputs, args.out) kwargs = {} if args.options is None else args.options if args.format_only: dataset.format_results(outputs, **kwargs) if args.eval: dataset.evaluate(outputs, args.eval, jsonfile_prefix=args.json, **kwargs)
def main(): args = parse_args() cfg = Config.fromfile(args.config) if args.cfg_options is not None: cfg.merge_from_dict(args.cfg_options) # import modules from plguin/xx, registry will be updated if hasattr(cfg, 'plugin') & cfg.plugin: import importlib if hasattr(cfg, 'plugin_dir'): plugin_dir = cfg.plugin_dir _module_dir = os.path.dirname(plugin_dir) _module_dir = _module_dir.split('/') _module_path = _module_dir[0] for m in _module_dir[1:]: _module_path = _module_path + '.' + m print(_module_path) plg_lib = importlib.import_module(_module_path) else: # import dir is the dirpath for the config file _module_dir = os.path.dirname(args.config) _module_dir = _module_dir.split('/') _module_path = _module_dir[0] for m in _module_dir[1:]: _module_path = _module_path + '.' + m print(_module_path) plg_lib = importlib.import_module(_module_path) # import modules from string list. if cfg.get('custom_imports', None): from mmcv.utils import import_modules_from_strings import_modules_from_strings(**cfg['custom_imports']) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None # in case the test dataset is concatenated samples_per_gpu = 1 if isinstance(cfg.data.test, dict): cfg.data.test.test_mode = True samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1) if samples_per_gpu > 1: # Replace 'ImageToTensor' to 'DefaultFormatBundle' cfg.data.test.pipeline = replace_ImageToTensor( cfg.data.test.pipeline) elif isinstance(cfg.data.test, list): for ds_cfg in cfg.data.test: ds_cfg.test_mode = True samples_per_gpu = max( [ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test]) if samples_per_gpu > 1: for ds_cfg in cfg.data.test: ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline) distributed = False # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader dataset = build_dataset(cfg.data.test) data_loader = build_dataloader( dataset, samples_per_gpu=samples_per_gpu, workers_per_gpu=cfg.data.workers_per_gpu, dist=distributed, shuffle=False) if not os.path.exists(args.out_dir): os.mkdir(args.out_dir) # build the model and load checkpoint cfg.model.train_cfg = None model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg')) #from IPython import embed #embed() fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_conv_bn(model) model = MMDataParallel(model, device_ids=[0]) model.eval() output_list = [] for i, data in enumerate(data_loader): with torch.no_grad(): data = scatter(data, [-1])[0] for k, v in data.items(): if isinstance(v, torch.Tensor): data[k] = v.cuda() outputs = model.module.eval_forward(data) output_list.append(outputs) if i >= 100: break merged_output_list = [] for i, output in enumerate(output_list): save_dir = os.path.join(args.out_dir, 'sample-{}'.format(i)) if not os.path.isdir(save_dir): os.mkdir(save_dir) outputs = parse_output(output, save_dir) merged_output_list.append(outputs) save_dir = os.path.join(args.out_dir, 'gifs') if not os.path.isdir(save_dir): os.mkdir(save_dir) merge_output(merged_output_list, save_dir)
def main(): args = parse_args() assert args.out or args.eval or args.format_only or args.show, \ ('Please specify at least one operation (save/eval/format/show the ' 'results) with the argument "--out", "--eval", "--format_only" ' 'or "--show"') if args.eval and args.format_only: raise ValueError('--eval and --format_only cannot be both specified') if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') cfg = Config.fromfile(args.config) # set cudnn_benchmark if cfg.get('cudnn_benchmark', False): torch.backends.cudnn.benchmark = True cfg.model.pretrained = None cfg.data.test.test_mode = True # 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) # set random seeds if args.seed is not None: set_random_seed(args.seed, deterministic=args.deterministic) # build the dataloader # TODO: support multiple images per gpu (only minor changes are needed) dataset = build_dataset(cfg.data.test) data_loader = build_dataloader(dataset, samples_per_gpu=1, workers_per_gpu=cfg.data.workers_per_gpu, dist=distributed, shuffle=False) # build the model and load checkpoint model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) fp16_cfg = cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') if args.fuse_conv_bn: model = fuse_module(model) # old versions did not save class info in checkpoints, this walkaround is # for backward compatibility if 'CLASSES' in checkpoint['meta']: model.CLASSES = checkpoint['meta']['CLASSES'] else: model.CLASSES = dataset.CLASSES if not distributed: model = MMDataParallel(model, device_ids=[0]) outputs = single_gpu_test(model, data_loader, args.show, args.show_dir) else: model = MMDistributedDataParallel( model.cuda(), device_ids=[torch.cuda.current_device()], broadcast_buffers=False) outputs = multi_gpu_test(model, data_loader, args.tmpdir, args.gpu_collect) rank, _ = get_dist_info() if rank == 0: if args.out: print(f'\nwriting results to {args.out}') mmcv.dump(outputs, args.out) kwargs = {} if args.options is None else args.options if args.format_only: dataset.format_results(outputs, **kwargs) if args.eval: dataset.evaluate(outputs, args.eval, **kwargs)