for v in value: object_list.append(v) messages.append('\n') messages.append('import mmcv\n') messages.append("constant = mmcv.load('deployment.yml')\n") messages.append('\n') messages.append('class ObjectManage:\n') for v in object_list: messages.append(f' {class_to_object_name(v)} = {v}()\n') messages.append(' pass\n') with open(file_path, 'a') as f: f.writelines(messages) def class_to_object_name(class_name): list_ = [] for m in [*class_name]: if m in upper: list_.append(obj[m]) else: list_.append(m) name_str = ''.join(list_) return name_str[1:] if __name__ == "__main__": opts = mmcv.load('target_project_infomation.yml') create_object_script(opts)
def test_object_sample(): db_sampler = mmcv.ConfigDict({ 'data_root': './tests/data/kitti/', 'info_path': './tests/data/kitti/kitti_dbinfos_train.pkl', 'rate': 1.0, 'prepare': { 'filter_by_difficulty': [-1], 'filter_by_min_points': { 'Pedestrian': 10 } }, 'classes': ['Pedestrian', 'Cyclist', 'Car'], 'sample_groups': { 'Pedestrian': 6 } }) np.random.seed(0) object_sample = ObjectSample(db_sampler) points = np.fromfile( './tests/data/kitti/training/velodyne_reduced/000000.bin', np.float32).reshape(-1, 4) annos = mmcv.load('./tests/data/kitti/kitti_infos_train.pkl') info = annos[0] rect = info['calib']['R0_rect'].astype(np.float32) Trv2c = info['calib']['Tr_velo_to_cam'].astype(np.float32) annos = info['annos'] loc = annos['location'] dims = annos['dimensions'] rots = annos['rotation_y'] gt_names = annos['name'] gt_bboxes_3d = np.concatenate([loc, dims, rots[..., np.newaxis]], axis=1).astype(np.float32) gt_bboxes_3d = CameraInstance3DBoxes(gt_bboxes_3d).convert_to( Box3DMode.LIDAR, np.linalg.inv(rect @ Trv2c)) CLASSES = ('Pedestrian', 'Cyclist', 'Car') gt_labels = [] for cat in gt_names: if cat in CLASSES: gt_labels.append(CLASSES.index(cat)) else: gt_labels.append(-1) gt_labels = np.array(gt_labels, dtype=np.long) points = LiDARPoints(points, points_dim=4) input_dict = dict(points=points, gt_bboxes_3d=gt_bboxes_3d, gt_labels_3d=gt_labels) input_dict = object_sample(input_dict) points = input_dict['points'] gt_bboxes_3d = input_dict['gt_bboxes_3d'] gt_labels_3d = input_dict['gt_labels_3d'] repr_str = repr(object_sample) expected_repr_str = 'ObjectSample sample_2d=False, ' \ 'data_root=./tests/data/kitti/, ' \ 'info_path=./tests/data/kitti/kitti' \ '_dbinfos_train.pkl, rate=1.0, ' \ 'prepare={\'filter_by_difficulty\': [-1], ' \ '\'filter_by_min_points\': {\'Pedestrian\': 10}}, ' \ 'classes=[\'Pedestrian\', \'Cyclist\', \'Car\'], ' \ 'sample_groups={\'Pedestrian\': 6}' assert repr_str == expected_repr_str assert points.tensor.numpy().shape == (800, 4) assert gt_bboxes_3d.tensor.shape == (1, 7) assert np.all(gt_labels_3d == [0])
def load_proposals(self, proposal_file): return mmcv.load(proposal_file)
"If disparity map given, it will be divided by {:.2f} to get the real disparity value" .format(disp_div_factor)) print("Initial Model ... ") model = init_model(config_path, checkpoint_path, device) print("Model initialed!") print("Start Inference ... ") inference_stereo( model, batchesDict, log_dir, pad_to_shape, crop_shape, scale_factor, disp_div_factor, device, ) print("Inference Done!") print("Start Visualization ... ") for batch in batchesDict: pkl_path = os.path.join( log_dir, batch['left_image_path'].split('/')[-1].split('.')[0], 'result.pkl') print("Visualize ", pkl_path) result_pkl = mmcv.load(pkl_path) visualize_disp(result_pkl) print("Done!")
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 = mmcv.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) # create work_dir with timestamp tag timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime()) cfg.work_dir = osp.dirname(args.checkpoint) if args.out is None: args.out = osp.join( cfg.work_dir, '{}_{}'.format(timestamp, osp.basename(args.checkpoint).replace('pth', 'pkl'))) mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir)) # init the logger before other steps log_file = osp.join(cfg.work_dir, '{}_test.log'.format(timestamp)) logger = get_root_logger(log_file=log_file, log_level=cfg.log_level) # log some basic info logger.info('Command-line argument:\n{}'.format(' '.join(sys.argv[1:]))) logger.info('Distributed training: {}'.format(distributed)) logger.info('MMDetection Version: {}'.format(__version__)) logger.info('Config:\n{}'.format(cfg.text)) # 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, imgs_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') # 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 args.use_cache and osp.exists(args.out): print('\nreuse results from {}'.format(args.out)) outputs = mmcv.load(args.out) else: if not distributed: model = MMDataParallel(model, device_ids=[0]) outputs = single_gpu_test(model, data_loader, args.show) 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) print('\nwriting results to {}'.format(args.out)) mmcv.dump(outputs, args.out) rank, _ = get_dist_info() if rank == 0: kwargs = {} if args.options is None else args.options if args.format_only: save_dir = osp.join(cfg.work_dir, osp.basename(args.out).split('.')[0] + '_out') print('\nsaving results to {}'.format(save_dir)) kwargs['data_loader'] = data_loader kwargs['save_dir'] = save_dir dataset.format_results(outputs, **kwargs) if args.eval: kwargs['logger'] = logger dataset.evaluate(outputs, args.eval, **kwargs)
def load_annotations(self, ann_file): img_infos = mmcv.load(ann_file) for item in img_infos: item.update({'id': item['filename'].split('/')[-1].split('.')[0]}) return img_infos
def get_data_sample(): def _parse_h36m_imgname(imgname): """Parse imgname to get information of subject, action and camera. A typical h36m image filename is like: S1_Directions_1.54138969_000001.jpg """ subj, rest = osp.basename(imgname).split('_', 1) action, rest = rest.split('.', 1) camera, rest = rest.split('_', 1) return subj, action, camera ann_flle = 'tests/data/h36m/test_h36m.npz' camera_param_file = 'tests/data/h36m/cameras.pkl' data = np.load(ann_flle) cameras = mmcv.load(camera_param_file) _imgnames = data['imgname'] _joints_2d = data['part'][:, H36M_JOINT_IDX].astype(np.float32) _joints_3d = data['S'][:, H36M_JOINT_IDX].astype(np.float32) _centers = data['center'].astype(np.float32) _scales = data['scale'].astype(np.float32) frame_ids = [0] target_frame_id = 0 results = { 'frame_ids': frame_ids, 'target_frame_id': target_frame_id, 'input_2d': _joints_2d[frame_ids, :, :2], 'input_2d_visible': _joints_2d[frame_ids, :, -1:], 'input_3d': _joints_3d[frame_ids, :, :3], 'input_3d_visible': _joints_3d[frame_ids, :, -1:], 'target': _joints_3d[target_frame_id, :, :3], 'target_visible': _joints_3d[target_frame_id, :, -1:], 'imgnames': _imgnames[frame_ids], 'scales': _scales[frame_ids], 'centers': _centers[frame_ids], } # add camera parameters subj, _, camera = _parse_h36m_imgname(_imgnames[frame_ids[0]]) results['camera_param'] = cameras[(subj, camera)] # add image size results['image_width'] = results['camera_param']['w'] results['image_height'] = results['camera_param']['h'] # add ann_info ann_info = {} ann_info['num_joints'] = 17 ann_info['joint_weights'] = np.full(17, 1.0, dtype=np.float32) ann_info['flip_pairs'] = [[1, 4], [2, 5], [3, 6], [11, 14], [12, 15], [13, 16]] ann_info['upper_body_ids'] = (0, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) ann_info['lower_body_ids'] = (1, 2, 3, 4, 5, 6) ann_info['use_different_joint_weights'] = False results['ann_info'] = ann_info return results
parser.add_argument( '--out', type=str, help='output path of gathered metrics to be stored') parser.add_argument( '--not-show', action='store_true', help='not show metrics') args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() root_path = args.root metrics_out = args.out benchmark_json_path = args.benchmark_json model_configs = mmcv.load(benchmark_json_path)['models'] result_dict = {} for config in model_configs: config_name = osp.split(config)[-1] config_name = osp.splitext(config_name)[0] result_path = osp.join(root_path, config_name) if osp.exists(result_path): # 1 read config cfg = mmcv.Config.fromfile(config) total_epochs = cfg.total_epochs final_results = cfg.evaluation.metric if not isinstance(final_results, list): final_results = [final_results] final_results_out = [] for key in final_results:
def lvis_fast_eval_recall(results, lvisEval, max_dets, iou_thrs=np.arange(0.5, 0.96, 0.05)): if mmcv.is_str(results): assert results.endswith('.pkl') results = mmcv.load(results) if isinstance(results[0], tuple): proposals = [] for idx in range(len(results)): proposals.append(results[idx][-1]) results = proposals assert isinstance(results, list), \ 'results must be a list of numpy arrays, not {}'.format(type(results)) elif not isinstance(results, list): raise TypeError( 'results must be a list of numpy arrays or a filename, not {}'. format(type(results))) img_ids = lvisEval.lvis_gt.get_img_ids() area_rngs = lvisEval.params.area_rng freq_groups = [[] for _ in lvisEval.params.img_count_lbl] cat_data = lvisEval.lvis_gt.load_cats(lvisEval.params.cat_ids) for idx, _cat_data in enumerate(cat_data): frequency = _cat_data["frequency"] freq_groups[lvisEval.params.img_count_lbl.index(frequency)].append(idx+1) gt_bboxes_all = defaultdict(list) dt_bboxes_all = [] for area_idx in range(len(area_rngs)): for group_idx in range(len(freq_groups)): gt_bboxes_all[group_idx, area_idx] = [] gt_bboxes = defaultdict(list) all_num = np.zeros((len(freq_groups), len(area_rngs))) group_num = np.zeros((len(freq_groups), 1)) for i in range(len(img_ids)): dt_bboxes = [] for area_idx in range(len(area_rngs)): for group_idx in range(len(freq_groups)): gt_bboxes[group_idx, area_idx] = [] ann_ids = lvisEval.lvis_gt.get_ann_ids(img_ids=[img_ids[i]]) ann_info = lvisEval.lvis_gt.load_anns(ann_ids) det_ids = lvisEval.lvis_dt.get_ann_ids(img_ids=[img_ids[i]]) det_info = lvisEval.lvis_dt.load_anns(det_ids) img_pl = set() for ann in ann_info: img_pl.add(ann["category_id"]) img_pl_group = dict() for cat in img_pl: for group_idx, freq_group in enumerate(freq_groups): if cat in freq_group: img_pl_group[cat] = group_idx break for ann in ann_info: for area_idx, area_rng in enumerate(area_rngs): if area_rng[0] <= ann['area'] < area_rng[1]: group_idx = img_pl_group[ann['category_id']] if area_idx == 0: group_num[group_idx] += 1 # only count for area all x1, y1, w, h = ann['bbox'] gt_bboxes[group_idx, area_idx].append( [x1, y1, x1 + w - 1, y1 + h - 1]) for det in det_info: x1, y1, w, h = det['bbox'] dt_bboxes.append([x1, y1, x1 + w - 1, y1 + h - 1, det['score']]) for area_idx in range(len(area_rngs)): for group_idx in range(len(freq_groups)): if len(gt_bboxes[group_idx, area_idx]) == 0: gt_bboxes_all[group_idx, area_idx].append(np.zeros((0, 4))) else: all_num[group_idx, area_idx] += len(gt_bboxes[group_idx, area_idx]) gt_bboxes_all[group_idx, area_idx].append( np.array(gt_bboxes[group_idx, area_idx], dtype=np.float32)) if len(dt_bboxes) == 0: dt_bboxes_all.append(np.zeros((0, 5))) else: dt_bboxes_all.append( np.array(dt_bboxes, dtype=np.float32)) ar_all = np.zeros((len(freq_groups), len(area_rngs), len(max_dets))) for group_idx in range(len(freq_groups)): for area_idx in range(len(area_rngs)): recalls = eval_recalls( gt_bboxes_all[group_idx, area_idx], dt_bboxes_all, max_dets, iou_thrs, print_summary=False) ar_all[group_idx, area_idx, :] = recalls.mean(axis=1) ar_all = np.transpose(ar_all, (2, 0, 1)) area_rng_name = ["all", "small", "medium", "large"] freq_group_name = ["rare", "common", "freq"] table_data = [['Num'] + area_rng_name] for group_idx in range(len(freq_groups)): row = ['{}'.format(int(val)) for val in all_num[group_idx, :].tolist()] row.insert(0, freq_group_name[group_idx]) table_data.append(row) print(AsciiTable(table_data).table) recalls = np.zeros((max_dets.size, len(freq_groups) + len(area_rngs))) for det_num_idx, max_det in enumerate(max_dets): ar = ar_all[det_num_idx, :, :] ar_cat_all = np.sum(ar * group_num, axis=0) / np.sum(group_num) for area_idx in range(len(area_rngs)): recalls[det_num_idx, area_idx] = ar_cat_all[area_idx] # all small meduim large for group_idx in range(len(freq_groups)): recalls[det_num_idx, group_idx + len(area_rngs)] = ar[group_idx, 0] # rare common freq row_header = ['AR@{}'.format(max_det)] + area_rng_name table_data = [row_header] for group_idx in range(len(freq_groups)): row = ['{:.3f}'.format(val) for val in ar[group_idx, :].tolist()] row.insert(0, freq_group_name[group_idx]) table_data.append(row) table = AsciiTable(table_data) print(table.table) row_header = ['AR'] + area_rng_name + freq_group_name table_data = [row_header] for i, num in enumerate(max_dets): row = [ '{:.3f}'.format(val) for val in recalls[i, :].tolist() ] row.insert(0, num) table_data.append(row) table = AsciiTable(table_data) print(table.table)
def main(self): split = self.split scene = self.scene # "all" or a single scene sel_scene_ids = self.sel_scene_ids data_root = self.data_root for scene_id in tqdm(sel_scene_ids, postfix=f"{split}_{scene}"): print("split: {} scene: {}".format(split, scene_id)) scene_root = osp.join(data_root, f"{scene_id:06d}") gt_dict = mmcv.load(osp.join(scene_root, "scene_gt.json")) # gt_info_dict = mmcv.load(osp.join(scene_root, "scene_gt_info.json")) # cam_dict = mmcv.load(osp.join(scene_root, "scene_camera.json")) for str_im_id in tqdm(gt_dict, postfix=f"{scene_id}"): int_im_id = int(str_im_id) for anno_i, anno in enumerate(gt_dict[str_im_id]): obj_id = anno["obj_id"] if obj_id not in idx2class: continue R = np.array(anno["cam_R_m2c"], dtype="float32").reshape(3, 3) t = np.array(anno["cam_t_m2c"], dtype="float32") / 1000.0 # pose = np.hstack([R, t.reshape(3, 1)]) save_path = osp.join( xyz_root, f"{scene_id:06d}/{int_im_id:06d}_{anno_i:06d}-xyz.pkl", ) # if osp.exists(save_path) and osp.getsize(save_path) > 0: # continue render_obj_id = cls_indexes.index(obj_id) # 0-based bgr_gl, depth_gl = self.get_renderer().render( render_obj_id, IM_W, IM_H, K, R, t, near, far) mask = (depth_gl > 0).astype("uint8") if mask.sum( ) == 0: # NOTE: this should be ignored at training phase print( f"not visible, split {split} scene {scene_id}, im {int_im_id} obj {idx2class[obj_id]} {obj_id}" ) print(f"{save_path}") xyz_info = { "xyz_crop": np.zeros((IM_H, IM_W, 3), dtype=np.float16), "xyxy": [0, 0, IM_W - 1, IM_H - 1], } if VIS: im_path = osp.join( data_root, f"{scene_id:06d}/rgb/{int_im_id:06d}.jpg", ) im = mmcv.imread(im_path) mask_path = osp.join( data_root, f"{scene_id:06d}/mask/{int_im_id:06d}_{anno_i:06d}.png", ) mask_visib_path = osp.join( data_root, f"{scene_id:06d}/mask_visib/{int_im_id:06d}_{anno_i:06d}.png", ) mask_gt = mmcv.imread(mask_path, "unchanged") mask_visib_gt = mmcv.imread( mask_visib_path, "unchanged") show_ims = [ bgr_gl[:, :, [2, 1, 0]], im[:, :, [2, 1, 0]], mask_gt, mask_visib_gt, ] show_titles = [ "bgr_gl", "im", "mask_gt", "mask_visib_gt", ] grid_show(show_ims, show_titles, row=2, col=2) raise RuntimeError( f"split {split} scene {scene_id}, im {int_im_id}" ) else: x1, y1, x2, y2 = mask2bbox_xyxy(mask) xyz_np = misc.calc_xyz_bp_fast(depth_gl, R, t, K) xyz_crop = xyz_np[y1:y2 + 1, x1:x2 + 1] xyz_info = { "xyz_crop": xyz_crop.astype( "float16" ), # save disk space w/o performance drop "xyxy": [x1, y1, x2, y2], } if VIS: print( f"xyz_crop min {xyz_crop.min()} max {xyz_crop.max()}" ) show_ims = [ bgr_gl[:, :, [2, 1, 0]], get_emb_show(xyz_np), get_emb_show(xyz_crop), ] show_titles = ["bgr_gl", "xyz", "xyz_crop"] grid_show(show_ims, show_titles, row=1, col=3) if not args.no_save: mmcv.mkdir_or_exist(osp.dirname(save_path)) mmcv.dump(xyz_info, save_path) if self.renderer is not None: self.renderer.close()
def test_batched_nms(): try: import mmcv from mmcv.ops import batched_nms except (ImportError, ModuleNotFoundError): pytest.skip('test requires compilation') # trt config os.environ['ONNX_BACKEND'] = 'MMCVTensorRT' fp16_mode = False max_workspace_size = 1 << 30 data = mmcv.load('./tests/data/batched_nms_data.pkl') nms_cfg = dict(type='nms', iou_threshold=0.7) boxes = data['boxes'].cuda() scores = data['scores'].cuda() idxs = data['idxs'].cuda() class_agnostic = False nms = partial(batched_nms, nms_cfg=nms_cfg, class_agnostic=class_agnostic) wrapped_model = WrapFunction(nms) wrapped_model.cpu().eval() input_data = (boxes.detach().cpu(), scores.detach().cpu(), idxs.detach().cpu()) input_names = ['boxes', 'scores', 'idxs'] output_names = ['dets', 'inds'] with torch.no_grad(): torch.onnx.export(wrapped_model, input_data, onnx_file, export_params=True, keep_initializers_as_inputs=True, input_names=input_names, output_names=output_names, opset_version=11) onnx_model = onnx.load(onnx_file) # create trt engine and wraper opt_shape_dict = { 'boxes': [list(boxes.shape), list(boxes.shape), list(boxes.shape)], 'scores': [list(scores.shape), list(scores.shape), list(scores.shape)], 'idxs': [list(idxs.shape), list(idxs.shape), list(idxs.shape)] } trt_engine = onnx2trt(onnx_model, opt_shape_dict, fp16_mode=fp16_mode, max_workspace_size=max_workspace_size) save_trt_engine(trt_engine, trt_file) trt_model = TRTWraper(trt_file, input_names, output_names) with torch.no_grad(): trt_outputs = trt_model({ 'boxes': boxes, 'scores': scores, 'idxs': idxs }) trt_dets = trt_outputs['dets'] trt_inds = trt_outputs['inds'] trt_inds = trt_inds.long() # compute pytorch_output with torch.no_grad(): pytorch_outputs = wrapped_model(boxes, scores, idxs) pytorch_dets, pytorch_inds = pytorch_outputs # allclose if os.path.exists(onnx_file): os.remove(onnx_file) if os.path.exists(trt_file): os.remove(trt_file) num_boxes = pytorch_dets.shape[0] trt_dets = trt_dets[:num_boxes, ...] trt_inds = trt_inds[:num_boxes] trt_scores = trt_dets[:, 4] pytorch_scores = pytorch_dets[:, 4] os.environ.pop('ONNX_BACKEND') assert torch.allclose(pytorch_scores, trt_scores) assert torch.equal(pytorch_inds, trt_inds)
from glob import glob if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--sub_csv_pattern') parser.add_argument('--parents_only', type=int, default=0) parser.add_argument('--no_expand', type=int, default=0) parser.add_argument('--thres', type=float) args = parser.parse_args() data_dir = '/Users/bo_liu/Documents/open-images/data/' repo_dir = '/Users/bo_liu/Documents/open-images/open-images/' sub_dir = '/Users/bo_liu/Documents/open-images/subs/' all_keyed_child = mmcv.load(data_dir + 'seg_all_keyed_child.pkl') sub_csvs = sorted(glob(args.sub_csv_pattern)) for sub_csv in sub_csvs: assert 'of25.csv' in sub_csv or 'of25_msk_vote' in sub_csv if 'of25_msk_vote' in sub_csv: k = int(sub_csv.split('of25_msk_vote')[-2].split('_')[-1]) else: k = int(sub_csv.replace('of25.csv', '').split('_')[-1]) assert k >= 0 and k <= 24 import gc gc.collect() sub = pd.read_csv(sub_csv)
def __init__(self, info_path, data_root, rate, prepare, sample_groups, classes=None, attr_classes=None, points_loader=dict( type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=[0, 1, 2, 3])): # Feng Xiang added attr_classes input super().__init__() self.data_root = data_root self.info_path = info_path self.rate = rate self.prepare = prepare self.classes = classes # Feng Xiang code # code begin self.attr_classes = attr_classes # self.attr_cat2label = {name: i for i, name in enumerate(attr_classes)} # self.attr_label2cat = {i: name for i, name in enumerate(attr_classes)} # print(self.attr_classes) # code end self.cat2label = {name: i for i, name in enumerate(classes)} self.label2cat = {i: name for i, name in enumerate(classes)} self.points_loader = mmcv.build_from_cfg(points_loader, PIPELINES) db_infos = mmcv.load(info_path) # filter database infos from mmdet3d.utils import get_root_logger logger = get_root_logger() for k, v in db_infos.items(): logger.info(f'load {len(v)} {k} database infos') for prep_func, val in prepare.items(): db_infos = getattr(self, prep_func)(db_infos, val) logger.info('After filter database:') for k, v in db_infos.items(): logger.info(f'load {len(v)} {k} database infos') self.db_infos = db_infos # load sample groups # TODO: more elegant way to load sample groups self.sample_groups = [] for name, num in sample_groups.items(): self.sample_groups.append({name: int(num)}) self.group_db_infos = self.db_infos # just use db_infos self.sample_classes = [] # Feng Xiang code # code begin self.sample_attr_classes = [] # code end self.sample_max_nums = [] for group_info in self.sample_groups: self.sample_classes += list(group_info.keys()) self.sample_max_nums += list(group_info.values()) self.sampler_dict = {} for k, v in self.group_db_infos.items(): self.sampler_dict[k] = BatchSampler(v, k, shuffle=True)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--ann-file', type=str, default='tests/data/h36m/test_h36m_body3d.npz') parser.add_argument('--camera-param-file', type=str, default='tests/data/h36m/cameras.pkl') parser.add_argument('--img-root', type=str, default='tests/data/h36m') parser.add_argument('--out-file', type=str, default='tests/data/h36m/h36m_coco.json') parser.add_argument('--full-img-name', action='store_true') args = parser.parse_args() h36m_data = np.load(args.ann_file) h36m_camera_params = mmcv.load(args.camera_param_file) h36m_coco = {} # categories h36m_cats = [{ 'supercategory': 'person', 'id': 1, 'name': 'person', 'keypoints': [ 'root (pelvis)', 'left_hip', 'left_knee', 'left_foot', 'right_hip', 'right_knee', 'right_foot', 'spine', 'thorax', 'neck_base', 'head', 'left_shoulder', 'left_elbow', 'left_wrist', 'right_shoulder', 'right_elbow', 'right_wrist' ], 'skeleton': [[0, 1], [1, 2], [2, 3], [0, 4], [4, 5], [5, 6], [0, 7], [7, 8], [8, 9], [9, 10], [8, 11], [11, 12], [12, 13], [8, 14], [14, 15], [15, 16]], }] # images imgnames = h36m_data['imgname'] if not args.full_img_name: imgnames = [osp.basename(fn) for fn in imgnames] tasks = [(idx, fn, args.img_root) for idx, fn in enumerate(imgnames)] h36m_imgs = mmcv.track_parallel_progress(_get_img_info, tasks, nproc=12) # annotations kpts_2d = h36m_data['part'] kpts_3d = h36m_data['S'] centers = h36m_data['center'] scales = h36m_data['scale'] tasks = [(idx, ) + args + (h36m_camera_params, ) for idx, args in enumerate( zip(kpts_2d, kpts_3d, centers, scales, imgnames))] h36m_anns = mmcv.track_parallel_progress(_get_ann, tasks, nproc=12) # remove invalid data h36m_imgs = [img for img in h36m_imgs if img is not None] h36m_img_ids = set([img['id'] for img in h36m_imgs]) h36m_anns = [ann for ann in h36m_anns if ann['image_id'] in h36m_img_ids] h36m_coco = { 'categories': h36m_cats, 'images': h36m_imgs, 'annotations': h36m_anns, } mmcv.dump(h36m_coco, args.out_file)
def parse_results(config_file, resultfile, dstpath, type): cfg = Config.fromfile(config_file) data_test = cfg.data['test'] dataset = get_dataset(data_test) outputs = mmcv.load(resultfile) if type == 'OBB': # dota1 has tested obb_results_dict = OBBDetComp4(dataset, outputs) current_thresh = 0.1 elif type == 'HBB': # dota1 has tested hbb_results_dict = HBBDet2Comp4(dataset, outputs) elif type == 'HBBOBB': # dota1 has tested # dota2 hbb_results_dict, obb_results_dict = HBBOBB2Comp4(dataset, outputs) current_thresh = 0.3 elif type == 'Mask': # TODO: dota1 did not pass # dota2, hbb has passed, obb has passed hbb_results_dict, obb_results_dict = HBBSeg2Comp4(dataset, outputs) current_thresh = 0.3 #print(obb_results_dict) print(len(obb_results_dict)) dataset_type = cfg.dataset_type if 'obb_results_dict' in vars(): if not os.path.exists(os.path.join(dstpath, 'Task1_results')): os.makedirs(os.path.join(dstpath, 'Task1_results')) for cls in obb_results_dict: with open(os.path.join(dstpath, 'Task1_results', cls + '.txt'), 'w') as obb_f_out: for index, outline in enumerate(obb_results_dict[cls]): if index != (len(obb_results_dict[cls]) - 1): obb_f_out.write(outline + '\n') else: obb_f_out.write(outline) if not os.path.exists(os.path.join(dstpath, 'Task1_results_nms')): os.makedirs(os.path.join(dstpath, 'Task1_results_nms')) mergebypoly_multiprocess(os.path.join(dstpath, 'Task1_results'), os.path.join(dstpath, 'Task1_results_nms'), nms_type=r'py_cpu_nms_poly_fast', o_thresh=current_thresh) OBB2HBB(os.path.join(dstpath, 'Task1_results_nms'), os.path.join(dstpath, 'Transed_Task2_results_nms')) if 'hbb_results_dict' in vars(): if not os.path.exists(os.path.join(dstpath, 'Task2_results')): os.makedirs(os.path.join(dstpath, 'Task2_results')) for cls in hbb_results_dict: with open(os.path.join(dstpath, 'Task2_results', cls + '.txt'), 'w') as f_out: for index, outline in enumerate(hbb_results_dict[cls]): if index != (len(hbb_results_dict[cls]) - 1): f_out.write(outline + '\n') else: f_out.write(outline) if not os.path.exists(os.path.join(dstpath, 'Task2_results_nms')): os.makedirs(os.path.join(dstpath, 'Task2_results_nms')) mergebyrec(os.path.join(dstpath, 'Task2_results'), os.path.join(dstpath, 'Task2_results_nms'))
def load_annotations(self, ann_file): return mmcv.load(ann_file, encoding='latin1')
def after_train_epoch(self, runner): if not self.every_n_epochs(runner, self.interval): return runner.logger.info( "Start Visualizing on {} dataset({} images).".format( self.dataset.name, len(self.dataset))) # get prog bar if runner.rank == 0: prog_bar = mmcv.ProgressBar(len(self.dataset)) else: prog_bar = None runner.model.eval() results = [None for _ in range(len(self.dataset))] for idx in range(runner.rank, len(self.dataset), runner.world_size): data = self.dataset[idx] data_gpu = scatter(collate([data], samples_per_gpu=1), [torch.cuda.current_device()])[0] # compute output with torch.no_grad(): result = runner.model(data_gpu) # convert result to suitable visualization image item = self.dataset.data_list[idx] result['leftImage'] = imread( osp.join(self.cfg.data.vis.data_root, item['left_image_path'])).astype(np.float32) result['rightImage'] = imread( osp.join(self.cfg.data.vis.data_root, item['right_image_path'])).astype(np.float32) image_name = item['left_image_path'].split('/')[-1] result = prepare_visualize(result, runner.epoch + 1, self.cfg.work_dir, image_name) results[idx] = result batch_size = runner.world_size if runner.rank == 0: for _ in range(batch_size): prog_bar.update() if runner.rank == 0: print('\n') dist.barrier() for i in range(1, min(runner.world_size, len(self.dataset))): tmp_file = osp.join(runner.work_dir, 'temp_{}.pkl'.format(i)) tmp_results = mmcv.load(tmp_file) for idx in range(i, len(results), runner.world_size): results[idx] = tmp_results[idx] os.remove(tmp_file) self.visualize(runner, results) else: tmp_file = osp.join(runner.work_dir, 'temp_{}.pkl'.format(runner.rank)) mmcv.dump(results, tmp_file) dist.barrier() dist.barrier() torch.cuda.empty_cache()
def __init__(self, ann_file, img_prefix, img_scale, img_norm_cfg, multiscale_mode='value', size_divisor=None, flip_ratio=0, with_ignore=False, extra_aug=None, resize_keep_ratio=True, sample_file=None, num_classes=8, test_mode=False): super(Vision3DDataset, self).__init__() # prefix of images path self.img_prefix = img_prefix self.name = osp.basename(ann_file).split('.')[0] # load annotations (and proposals) self.raw_annotations = self.load_annotations(ann_file) # support dict or list if isinstance(self.raw_annotations, list): self.ids = range(len(self.raw_annotations)) elif isinstance(self.raw_annotations, dict): if sample_file is not None and osp.isfile(sample_file): self.ids = mmcv.load(sample_file, encoding='latin1') else: self.ids = sorted(list(self.raw_annotations.keys())) else: raise Exception("Unrecognized type of annotations: {}".format( type(self.raw_annotations))) # filter images with no annotation during training if not test_mode: self._filter_imgs() # (long_edge, short_edge) or [(long1, short1), (long2, short2), ...] self.img_scales = img_scale if isinstance(img_scale, list) else [img_scale] assert mmcv.is_list_of(self.img_scales, tuple) # normalization configs self.img_norm_cfg = img_norm_cfg # multi-scale mode (only applicable for multi-scale training) self.multiscale_mode = multiscale_mode assert multiscale_mode in ['value', 'range'] # flip ratio self.flip_ratio = flip_ratio assert flip_ratio >= 0 and flip_ratio <= 1 # padding border to ensure the image size can be divided by # size_divisor (used for FPN) self.size_divisor = size_divisor # some datasets provide bbox annotations as ignore/crowd/difficult, self.with_ignore = with_ignore # in test mode or not self.test_mode = test_mode # set group flag for the sampler if not self.test_mode: self._set_group_flag() # transforms self.img_transform = ImageTransform( size_divisor=self.size_divisor, **self.img_norm_cfg) self.point_transform = PointTransform() self.numpy2tensor = Numpy2Tensor() # if use extra augmentation if extra_aug is not None: self.extra_aug = ExtraAugmentation(**extra_aug) else: self.extra_aug = None # image rescale if keep ratio self.resize_keep_ratio = resize_keep_ratio self.num_classes = num_classes
def inference_multi_modality_detector(model, pcd, image, ann_file): """Inference point cloud with the multimodality detector. Args: model (nn.Module): The loaded detector. pcd (str): Point cloud files. image (str): Image files. ann_file (str): Annotation files. Returns: tuple: Predicted results and data from pipeline. """ cfg = model.cfg device = next(model.parameters()).device # model device # build the data pipeline test_pipeline = deepcopy(cfg.data.test.pipeline) test_pipeline = Compose(test_pipeline) box_type_3d, box_mode_3d = get_box_type(cfg.data.test.box_type_3d) # get data info containing calib data_infos = mmcv.load(ann_file) image_idx = int(re.findall(r'\d+', image)[-1]) # xxx/sunrgbd_000017.jpg for x in data_infos: if int(x['image']['image_idx']) != image_idx: continue info = x break data = dict( pts_filename=pcd, img_prefix=osp.dirname(image), img_info=dict(filename=osp.basename(image)), box_type_3d=box_type_3d, box_mode_3d=box_mode_3d, img_fields=[], bbox3d_fields=[], pts_mask_fields=[], pts_seg_fields=[], bbox_fields=[], mask_fields=[], seg_fields=[]) # depth map points to image conversion if box_mode_3d == Box3DMode.DEPTH: data.update(dict(calib=info['calib'])) data = test_pipeline(data) # LiDAR to image conversion if box_mode_3d == Box3DMode.LIDAR: rect = info['calib']['R0_rect'].astype(np.float32) Trv2c = info['calib']['Tr_velo_to_cam'].astype(np.float32) P2 = info['calib']['P2'].astype(np.float32) lidar2img = P2 @ rect @ Trv2c data['img_metas'][0].data['lidar2img'] = lidar2img elif box_mode_3d == Box3DMode.DEPTH: data['calib'][0]['Rt'] = data['calib'][0]['Rt'].astype(np.float32) data['calib'][0]['K'] = data['calib'][0]['K'].astype(np.float32) data = collate([data], samples_per_gpu=1) if next(model.parameters()).is_cuda: # scatter to specified GPU data = scatter(data, [device.index])[0] else: # this is a workaround to avoid the bug of MMDataParallel data['img_metas'] = data['img_metas'][0].data data['points'] = data['points'][0].data data['img'] = data['img'][0].data if box_mode_3d == Box3DMode.DEPTH: data['calib'][0]['Rt'] = data['calib'][0]['Rt'][0].data data['calib'][0]['K'] = data['calib'][0]['K'][0].data # forward the model with torch.no_grad(): result = model(return_loss=False, rescale=True, **data) return result, data
def get_distortions_from_file(filename): eval_output = mmcv.load(filename) return get_distortions_from_results(eval_output)
def main(): args = parse_args() assert args.out or args.show or args.json_out, \ ('Please specify at least one operation (save or show the results) ' 'with the argument "--out" or "--show" or "--json_out"') if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): raise ValueError('The output file must be a pkl file.') if args.json_out is not None and args.json_out.endswith('.json'): args.json_out = args.json_out[:-5] cfg = mmcv.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) # build the dataloader # TODO: support multiple images per gpu (only minor changes are needed) dataset = build_dataset(cfg.data.test) ## uncomment to only eval on first 100 imgs # dataset.img_infos = dataset.img_infos[:100] data_loader = build_dataloader(dataset, imgs_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') # 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 args.existing_json: result_files = { 'bbox': './coco_maskrcnn_r50fpn.pkl.bbox.json', 'segm': './coco_maskrcnn_r50fpn.pkl.segm.json', 'proposal': './coco_maskrcnn_r50fpn.pkl.proposal.json' } eval_types = ['proposal_fast'] result_files = mmcv.load('./debug_coco_maskrcnn_r50fpn.pkl') result_files = [item[2] for item in result_files] coco_eval(result_files, eval_types, dataset.coco) exit() if not distributed: model = MMDataParallel(model, device_ids=[0]) outputs = single_gpu_test(model, data_loader, args.show) else: model = MMDistributedDataParallel(model.cuda()) outputs = multi_gpu_test(model, data_loader, args.tmpdir) rank, _ = get_dist_info() if args.out and rank == 0: print('\nwriting results to {}'.format(args.out)) mmcv.dump(outputs, args.out) eval_types = args.eval if eval_types: print('Starting evaluate {}'.format(' and '.join(eval_types))) if eval_types == ['proposal_fast']: result_file = args.out coco_eval(result_file, eval_types, dataset.coco) else: if not isinstance(outputs[0], dict): result_files = results2json(dataset, outputs, args.out) coco_eval(result_files, eval_types, dataset.coco) else: for name in outputs[0]: print('\nEvaluating {}'.format(name)) outputs_ = [out[name] for out in outputs] result_file = args.out + '.{}'.format(name) result_files = results2json(dataset, outputs_, result_file) coco_eval(result_files, eval_types, dataset.coco) # Save predictions in the COCO json format if args.json_out and rank == 0: if not isinstance(outputs[0], dict): results2json(dataset, outputs, args.json_out) else: for name in outputs[0]: outputs_ = [out[name] for out in outputs] result_file = args.json_out + '.{}'.format(name) results2json(dataset, outputs_, result_file)
def get_coco_style_results(filename, task='bbox', metric=None, prints='mPC', aggregate='benchmark'): assert aggregate in ['benchmark', 'all'] if prints == 'all': prints = ['P', 'mPC', 'rPC'] elif isinstance(prints, str): prints = [prints] for p in prints: assert p in ['P', 'mPC', 'rPC'] if metric is None: metrics = [ 'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'AR1', 'AR10', 'AR100', 'ARs', 'ARm', 'ARl' ] elif isinstance(metric, list): metrics = metric else: metrics = [metric] for metric_name in metrics: assert metric_name in [ 'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'AR1', 'AR10', 'AR100', 'ARs', 'ARm', 'ARl' ] eval_output = mmcv.load(filename) num_distortions = len(list(eval_output.keys())) results = np.zeros((num_distortions, 6, len(metrics)), dtype='float32') for corr_i, distortion in enumerate(eval_output): for severity in eval_output[distortion]: for metric_j, metric_name in enumerate(metrics): mAP = eval_output[distortion][severity][task][metric_name] results[corr_i, severity, metric_j] = mAP P = results[0, 0, :] if aggregate == 'benchmark': mPC = np.mean(results[:15, 1:, :], axis=(0, 1)) else: mPC = np.mean(results[:, 1:, :], axis=(0, 1)) rPC = mPC / P print('\nmodel: {}'.format(osp.basename(filename))) if metric is None: if 'P' in prints: print('Performance on Clean Data [P] ({})'.format(task)) print_coco_results(P) if 'mPC' in prints: print('Mean Performance under Corruption [mPC] ({})'.format(task)) print_coco_results(mPC) if 'rPC' in prints: print('Realtive Performance under Corruption [rPC] ({})'.format( task)) print_coco_results(rPC) else: if 'P' in prints: print('Performance on Clean Data [P] ({})'.format(task)) for metric_i, metric_name in enumerate(metrics): print('{:5} = {:0.3f}'.format(metric_name, P[metric_i])) if 'mPC' in prints: print('Mean Performance under Corruption [mPC] ({})'.format(task)) for metric_i, metric_name in enumerate(metrics): print('{:5} = {:0.3f}'.format(metric_name, mPC[metric_i])) if 'rPC' in prints: print('Relative Performance under Corruption [rPC] ({})'.format( task)) for metric_i, metric_name in enumerate(metrics): print('{:5} => {:0.1f} %'.format(metric_name, rPC[metric_i] * 100)) return results
def main(): args = parse_args() assert args.out or args.show, \ ('Please specify at least one operation (save or show the results) ' 'with the argument "--out" or "--show"') 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.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) # 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, # imgs_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.det_ckpt is not None: # print('Loading Detection Models!!!!!!') # det_ckpt = load_checkpoint(model, args.det_ckpt, 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 # # if not distributed: # model = MMDataParallel(model, device_ids=[0]) # outputs = single_gpu_test(model, data_loader, args.show) # else: # model = MMDistributedDataParallel(model.cuda()) # outputs = multi_gpu_test(model, data_loader, args.tmpdir) outputs = mmcv.load(args.out) print('Finding video tubes...') track_results = finding_video_tubes(outputs, dataset) print('Finding video tubes done!') # draw_results(track_results, dataset, args.out, cfg) rank, _ = get_dist_info() if args.out and rank == 0: # print('\nwriting results to {}'.format(args.out)) # mmcv.dump(outputs, args.out) # result_files = results2json(dataset, outputs['bbox_results'], args.out) # coco_eval(result_files, ['bbox'], cfg.data.test.ann_file) # For tracking # result_files = results2json(dataset, track_results['bbox_results'], # args.out) # coco_eval(result_files, ['bbox'], cfg.data.test.ann_file) print("Evaluating tracking...") mdat_eval(track_results['track_results'], dataset, args.out, cfg)
# Copyright (c) OpenMMLab. All rights reserved. # In this example, we convert babel120_train to MMAction2 format # The required files can be downloaded from the homepage of BABEL project import numpy as np from mmcv import dump, load def gen_babel(x, y): data = [] for i, xx in enumerate(x): sample = dict() sample['keypoint'] = xx.transpose(3, 1, 2, 0).astype(np.float16) sample['label'] = y[1][0][i] names = [y[0][i], y[1][1][i], y[1][2][i], y[1][3][i]] sample['frame_dir'] = '_'.join([str(k) for k in names]) sample['total_frames'] = 150 data.append(sample) return data x = np.load('train_ntu_sk_120.npy') y = load('train_label_120.pkl') data = gen_babel(x, y) dump(data, 'babel120_train.pkl')
def test_global_rot_scale_trans(): angle = 0.78539816 scale = [0.95, 1.05] trans_std = 1.0 # rot_range should be a number or seq of numbers with pytest.raises(AssertionError): global_rot_scale_trans = GlobalRotScaleTrans(rot_range='0.0') # scale_ratio_range should be seq of numbers with pytest.raises(AssertionError): global_rot_scale_trans = GlobalRotScaleTrans(scale_ratio_range=1.0) # translation_std should be a positive number or seq of positive numbers with pytest.raises(AssertionError): global_rot_scale_trans = GlobalRotScaleTrans(translation_std='0.0') with pytest.raises(AssertionError): global_rot_scale_trans = GlobalRotScaleTrans(translation_std=-1.0) global_rot_scale_trans = GlobalRotScaleTrans(rot_range=angle, scale_ratio_range=scale, translation_std=trans_std, shift_height=False) np.random.seed(0) points = np.fromfile('tests/data/scannet/points/scene0000_00.bin', np.float32).reshape(-1, 6) annos = mmcv.load('tests/data/scannet/scannet_infos.pkl') info = annos[0] gt_bboxes_3d = info['annos']['gt_boxes_upright_depth'] depth_points = DepthPoints(points.copy(), points_dim=6, attribute_dims=dict(color=[3, 4, 5])) gt_bboxes_3d = DepthInstance3DBoxes(gt_bboxes_3d.copy(), box_dim=gt_bboxes_3d.shape[-1], with_yaw=False, origin=(0.5, 0.5, 0.5)) input_dict = dict(points=depth_points.clone(), bbox3d_fields=['gt_bboxes_3d'], gt_bboxes_3d=gt_bboxes_3d.clone()) input_dict = global_rot_scale_trans(input_dict) trans_depth_points = input_dict['points'] trans_bboxes_3d = input_dict['gt_bboxes_3d'] noise_rot = 0.07667607233534723 scale_factor = 1.021518936637242 trans_factor = np.array([0.97873798, 2.2408932, 1.86755799]) true_depth_points = depth_points.clone() true_bboxes_3d = gt_bboxes_3d.clone() true_depth_points, noise_rot_mat_T = true_bboxes_3d.rotate( noise_rot, true_depth_points) true_bboxes_3d.scale(scale_factor) true_bboxes_3d.translate(trans_factor) true_depth_points.scale(scale_factor) true_depth_points.translate(trans_factor) assert torch.allclose(trans_depth_points.tensor, true_depth_points.tensor, atol=1e-6) assert torch.allclose(trans_bboxes_3d.tensor, true_bboxes_3d.tensor, atol=1e-6) assert input_dict['pcd_scale_factor'] == scale_factor assert torch.allclose(input_dict['pcd_rotation'], noise_rot_mat_T, atol=1e-6) assert np.allclose(input_dict['pcd_trans'], trans_factor) repr_str = repr(global_rot_scale_trans) expected_repr_str = f'GlobalRotScaleTrans(rot_range={[-angle, angle]},' \ f' scale_ratio_range={scale},' \ f' translation_std={[trans_std for _ in range(3)]},' \ f' shift_height=False)' assert repr_str == expected_repr_str # points with shift_height but no bbox global_rot_scale_trans = GlobalRotScaleTrans(rot_range=angle, scale_ratio_range=scale, translation_std=trans_std, shift_height=True) # points should have height attribute when shift_height=True with pytest.raises(AssertionError): input_dict = global_rot_scale_trans(input_dict) np.random.seed(0) shift_height = points[:, 2:3] * 0.99 points = np.concatenate([points, shift_height], axis=1) depth_points = DepthPoints(points.copy(), points_dim=7, attribute_dims=dict(color=[3, 4, 5], height=6)) input_dict = dict(points=depth_points.clone(), bbox3d_fields=[]) input_dict = global_rot_scale_trans(input_dict) trans_depth_points = input_dict['points'] true_shift_height = shift_height * scale_factor assert np.allclose( trans_depth_points.tensor.numpy(), np.concatenate([true_depth_points.tensor.numpy(), true_shift_height], axis=1), atol=1e-6)
def main(): args = parse_args() if 'cuda' in args.device.lower(): if torch.cuda.is_available(): with_cuda = True else: raise RuntimeError('No CUDA device found, please check it again.') else: with_cuda = False if args.root_work_dir is None: # get the current time stamp now = datetime.now() ts = now.strftime('%Y_%m_%d_%H_%M') args.root_work_dir = f'work_dirs/inference_speed_test_{ts}' mmcv.mkdir_or_exist(osp.abspath(args.root_work_dir)) cfg = mmcv.load(args.config) dummy_datasets = mmcv.load(args.dummy_dataset_config)['dummy_datasets'] results = [] for i in range(args.priority + 1): models = cfg['model_list'][f'P{i}'] for cur_model in models: cfg_file = cur_model['config'] model_cfg = Config.fromfile(cfg_file) test_dataset = model_cfg['data']['test'] dummy_dataset = dummy_datasets[test_dataset['type']] test_dataset.update(dummy_dataset) dataset = build_dataset(test_dataset) data_loader = build_dataloader( dataset, samples_per_gpu=args.batch_size, workers_per_gpu=model_cfg.data.workers_per_gpu, dist=False, shuffle=False) data_loader = IterLoader(data_loader) if 'pretrained' in model_cfg.model.keys(): del model_cfg.model['pretrained'] model = init_pose_model(model_cfg, device=args.device.lower()) fp16_cfg = model_cfg.get('fp16', None) if fp16_cfg is not None: wrap_fp16_model(model) if args.fuse_conv_bn: model = fuse_conv_bn(model) # benchmark with several iterations and take the average pure_inf_time = 0 speed = [] for iteration in range(args.num_iters + args.num_warmup): data = next(data_loader) data['img'] = data['img'].to(args.device.lower()) data['img_metas'] = data['img_metas'].data[0] if with_cuda: torch.cuda.synchronize() start_time = time.perf_counter() with torch.no_grad(): model(return_loss=False, **data) if with_cuda: torch.cuda.synchronize() elapsed = time.perf_counter() - start_time if iteration >= args.num_warmup: pure_inf_time += elapsed speed.append(1 / elapsed) speed_mean = np.mean(speed) speed_std = np.std(speed) split_line = '=' * 30 result = f'{split_line}\nModel config:{cfg_file}\n' \ f'Device: {args.device}\n' \ f'Batch size: {args.batch_size}\n' \ f'Overall average speed: {speed_mean:.2f} \u00B1 ' \ f'{speed_std:.2f} items / s\n' \ f'Total iters: {args.num_iters}\n'\ f'Total time: {pure_inf_time:.2f} s \n{split_line}\n'\ print(result) results.append(result) print('!!!Please be cautious if you use the results in papers. ' 'You may need to check if all ops are included and verify that the ' 'speed computation is correct.') with open(osp.join(args.root_work_dir, 'inference_speed.txt'), 'w') as f: for res in results: f.write(res)
def load_annotations(self, ann_file): return mmcv.load(ann_file)
def _file2dict(filename, use_predefined_variables=True): filename = osp.abspath(osp.expanduser(filename)) check_file_exist(filename) fileExtname = osp.splitext(filename)[1] if fileExtname not in ['.py', '.json', '.yaml', '.yml']: raise IOError('Only py/yml/yaml/json type are supported now!') with tempfile.TemporaryDirectory() as temp_config_dir: temp_config_file = tempfile.NamedTemporaryFile( dir=temp_config_dir, suffix=fileExtname) if platform.system() == 'Windows': temp_config_file.close() temp_config_name = osp.basename(temp_config_file.name) # Substitute predefined variables if use_predefined_variables: Config._substitute_predefined_vars(filename, temp_config_file.name) else: shutil.copyfile(filename, temp_config_file.name) # Substitute base variables from placeholders to strings base_var_dict = Config._pre_substitute_base_vars( temp_config_file.name, temp_config_file.name) if filename.endswith('.py'): temp_module_name = osp.splitext(temp_config_name)[0] sys.path.insert(0, temp_config_dir) Config._validate_py_syntax(filename) mod = import_module(temp_module_name) sys.path.pop(0) cfg_dict = { name: value for name, value in mod.__dict__.items() if not name.startswith('__') } # delete imported module del sys.modules[temp_module_name] elif filename.endswith(('.yml', '.yaml', '.json')): import mmcv cfg_dict = mmcv.load(temp_config_file.name) # close temp file temp_config_file.close() cfg_text = filename + '\n' with open(filename, 'r', encoding='utf-8') as f: # Setting encoding explicitly to resolve coding issue on windows cfg_text += f.read() if BASE_KEY in cfg_dict: cfg_dir = osp.dirname(filename) base_filename = cfg_dict.pop(BASE_KEY) base_filename = base_filename if isinstance( base_filename, list) else [base_filename] cfg_dict_list = list() cfg_text_list = list() for f in base_filename: _cfg_dict, _cfg_text = Config._file2dict(osp.join(cfg_dir, f)) cfg_dict_list.append(_cfg_dict) cfg_text_list.append(_cfg_text) base_cfg_dict = dict() for c in cfg_dict_list: if len(base_cfg_dict.keys() & c.keys()) > 0: raise KeyError('Duplicate key is not allowed among bases') base_cfg_dict.update(c) # Subtitute base variables from strings to their actual values cfg_dict = Config._substitute_base_vars(cfg_dict, base_var_dict, base_cfg_dict) base_cfg_dict = Config._merge_a_into_b(cfg_dict, base_cfg_dict) cfg_dict = base_cfg_dict # merge cfg_text cfg_text_list.append(cfg_text) cfg_text = '\n'.join(cfg_text_list) return cfg_dict, cfg_text
def load_annotations(self, ann_file): """Load annotation from annotation file.""" return mmcv.load(ann_file)
for name in os.listdir(src_): src_f = os.path.join(src_, name) dst_f = os.path.join(dst, name) shutil.copyfile(src_f, dst_f) if __name__ == "__main__": data_root = "../data/" print("generate normal image dir") moveFiles(data_root + 'normal_image', [ data_root + 'guangdong1_round1_train1_20190818/normal_Images', data_root + 'guangdong1_round1_train2_20190828/normal_Images' ]) print('done') class_to_ind = mmcv.load("./source/cls2ind.pkl") ind_to_class = mmcv.load("./source/ind2cls.pkl") a = mmcv.load(data_root + "guangdong1_round1_train1_20190818/" + "Annotations/anno_train.json") for i in range(len(a)): a[i][ "dir"] = data_root + "guangdong1_round1_train1_20190818/" + "defect_Images/" + a[ i]['name'] b = mmcv.load(data_root + "guangdong1_round1_train2_20190828/" + "Annotations/anno_train.json") for i in range(len(b)): b[i][ "dir"] = data_root + "guangdong1_round1_train2_20190828/" + "defect_Images/" + b[ i]['name'] annos = a + b data_dir = "../data"