def test_net_on_dataset( weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0 ): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) all_boxes, all_segms, all_keyps, all_bodys = \ multi_gpu_test_net_on_dataset( weights_file, dataset_name, proposal_file, num_images, output_dir ) else: all_boxes, all_segms, all_keyps, all_bodys = test_net( weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id ) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format(test_timer.average_time)) results = task_evaluation.evaluate_all( dataset, all_boxes, all_segms, all_keyps, all_bodys, output_dir ) return results
def generate_rpn_on_dataset( weights_file, dataset_name, _proposal_file_ignored, output_dir, multi_gpu=False, gpu_id=0 ): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) _boxes, _scores, _ids, rpn_file = multi_gpu_generate_rpn_on_dataset( weights_file, dataset_name, _proposal_file_ignored, num_images, output_dir ) else: # Processes entire dataset range by default _boxes, _scores, _ids, rpn_file = generate_rpn_on_range( weights_file, dataset_name, _proposal_file_ignored, output_dir, gpu_id=gpu_id ) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format(test_timer.average_time)) return evaluate_proposal_file(dataset, rpn_file, output_dir)
def get_roidb(dataset_name, proposal_file, is_source=True): ds = JsonDataset(dataset_name) roidb = ds.get_roidb( gt=True, proposal_file=proposal_file, crowd_filter_thresh=cfg.TRAIN.CROWD_FILTER_THRESH, is_source=is_source ) if cfg.VOC_SUBSET != '' and subset_pointer is not None: # print(len(voc_subset)) voc_subset = subset_pointer.subset this_sub = voc_subset[:len(roidb)] subset_pointer.subset = voc_subset[len(roidb):] # print('remains',len(get_roidb.voc_subset)) # should have 0 remains for the last set, voc_2012_train. # # for pruning disk space: # import os # for taking, roi in zip(this_sub,roidb): # if not taking: # os.remove(roi['image']) # filter roidb: roidb = [roi for taking,roi in zip(this_sub,roidb) if taking] if cfg.TRAIN.USE_FLIPPED: logger.info('Appending horizontally-flipped training examples...') extend_with_flipped_entries(roidb, ds) logger.info('Loaded dataset: {:s}'.format(dataset_name)) return roidb
def generate_rpn_on_dataset(weights_file, dataset_name, _proposal_file_ignored, output_dir, multi_gpu=False, gpu_id=0): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) _boxes, _scores, _ids, rpn_file = multi_gpu_generate_rpn_on_dataset( weights_file, dataset_name, _proposal_file_ignored, num_images, output_dir) else: # Processes entire dataset range by default _boxes, _scores, _ids, rpn_file = generate_rpn_on_range( weights_file, dataset_name, _proposal_file_ignored, output_dir, gpu_id=gpu_id) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format( test_timer.average_time)) return evaluate_proposal_file(dataset, rpn_file, output_dir)
def get_roidb_and_dataset(dataset_name, proposal_file, ind_range, gt_cls=False): """Get the roidb for the dataset specified in the global cfg. Optionally restrict it to a range of indices if ind_range is a pair of integers. """ dataset = JsonDataset(dataset_name) if cfg.TEST.PRECOMPUTED_PROPOSALS: assert proposal_file, 'No proposal file given' roidb = dataset.get_roidb(proposal_file=proposal_file, proposal_limit=cfg.TEST.PROPOSAL_LIMIT) else: roidb = dataset.get_roidb(gt=gt_cls) if ind_range is not None: total_num_images = len(roidb) start, end = ind_range roidb = roidb[start:end] else: start = 0 end = len(roidb) total_num_images = end return roidb, dataset, start, end, total_num_images
def test_cls_net_on_dataset(weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) acc = multi_gpu_test_cls_net_on_dataset(num_images, output_dir) else: acc = test_cls_net(weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format( test_timer.average_time)) logger.info('Classification Accuracy on TEST data is: {:.2f}%'.format(acc * 100)) return {"Accuracy": acc}
def test_net_on_dataset( weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0 ): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) all_boxes, all_segms, all_keyps = multi_gpu_test_net_on_dataset( weights_file, dataset_name, proposal_file, num_images, output_dir ) else: all_boxes, all_segms, all_keyps = test_net( weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id ) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format(test_timer.average_time)) results = task_evaluation.evaluate_all( dataset, all_boxes, all_segms, all_keyps, output_dir ) return results
def get_roidb_and_dataset(dataset_name, proposal_file, ind_range): """Get the roidb for the dataset specified in the global cfg. Optionally restrict it to a range of indices if ind_range is a pair of integers. """ if dataset_name == 'live_targets': from detectron.datasets.live_dataset import LiveRoidb roidb = LiveRoidb() import detectron.datasets.dummy_datasets as dummy_datasets json_dataset = dummy_datasets.get_coco_dataset() if not cfg.TRAIN.USE_FLIPPED: logger.info( 'Live target data set will use flipped examples anyway!') logger.info('"Loaded" dataset: {:s}'.format('live_targets')) return roidb, json_dataset, 0, len(roidb), len(roidb) dataset = JsonDataset(dataset_name) if cfg.TEST.PRECOMPUTED_PROPOSALS: assert proposal_file, 'No proposal file given' roidb = dataset.get_roidb(proposal_file=proposal_file, proposal_limit=cfg.TEST.PROPOSAL_LIMIT) else: roidb = dataset.get_roidb() if ind_range is not None: total_num_images = len(roidb) start, end = ind_range roidb = roidb[start:end] else: start = 0 end = len(roidb) total_num_images = end return roidb, dataset, start, end, total_num_images
def accuracy(dataset, detections_pkl): # Load predictions and ground truths ds = JsonDataset(dataset) roidb = ds.get_roidb(gt=True) dets = load_object(detections_pkl) all_boxes = dets['all_boxes'] def id_or_index(ix, val): if len(val) == 0: return val else: return val[ix] trues = 0. # Iterate through all images for ix, entry in enumerate(roidb): cls_boxes_i = [ id_or_index(ix, cls_k_boxes) for cls_k_boxes in all_boxes ] true_boxes = entry['boxes'] if (true_boxes.shape[0] == 0) == (len(cls_boxes_i[3]) == 0): trues += 1 # Finally, calculate accuracy by dividing the sum of true predictions by total samples acc = trues/len(roidb) print("Accuracy: " + str(acc)) return acc
def get_roidb(dataset_name, proposal_file): ds = JsonDataset(dataset_name) roidb = ds.get_roidb(gt=True, proposal_file=proposal_file, crowd_filter_thresh=cfg.TRAIN.CROWD_FILTER_THRESH) if cfg.TRAIN.USE_FLIPPED: logger.info('Appending horizontally-flipped training examples...') extend_with_flipped_entries(roidb, ds) logger.info('Loaded dataset: {:s}'.format(ds.name)) return roidb
def get_roidb(dataset_name, proposal_file): ds = JsonDataset(dataset_name) roidb = ds.get_roidb( gt=True, proposal_file=proposal_file, crowd_filter_thresh=cfg.TRAIN.CROWD_FILTER_THRESH ) if cfg.TRAIN.USE_FLIPPED: logger.info('Appending horizontally-flipped training examples...') extend_with_flipped_entries(roidb, ds) logger.info('Loaded dataset: {:s}'.format(ds.name)) return roidb
def test_net_on_dataset(weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() model = '' if multi_gpu: num_images = len(dataset.get_roidb()) all_boxes, all_segms, all_keyps = multi_gpu_test_net_on_dataset( weights_file, dataset_name, proposal_file, num_images, output_dir) else: all_boxes, all_segms, all_keyps, model = test_net(weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format( test_timer.average_time)) results = task_evaluation.evaluate_all(dataset, all_boxes, all_segms, all_keyps, output_dir) roc_data = metrics.calculate_roc(all_boxes, dataset, cfg.TEST.IOU) froc_data = metrics.calculate_froc(all_boxes, dataset, cfg.TEST.IOU) auc_score = { dataset.name: { u'box': { u'AUC': auc(roc_data[0], roc_data[1]) } } } afroc_score = np.trapz(froc_data[0], froc_data[2]) afroc = {dataset.name: {u'box': {u'AFROC': afroc_score}}} print('Afroc score: {:.4f}'.format(afroc_score)) plot.plot_roc(roc_data, auc_score[dataset.name][u'box'][u'AUC'], dataset, model, output_dir) plot.plot_froc(froc_data, dataset, model, output_dir) plot.plot_afroc(froc_data, dataset, model, output_dir) save.np_save(np.stack(roc_data), 'roc', dataset, model, output_dir) save.np_save(np.stack(froc_data), 'froc', dataset, model, output_dir) results[dataset_name][u'box'].update(auc_score[dataset.name][u'box']) results[dataset_name][u'box'].update(afroc[dataset.name][u'box']) return results, auc_score, afroc_score
def vis(dataset, detections_pkl, thresh, output_dir, limit=0): ds = JsonDataset(dataset) roidb = ds.get_roidb() with open(detections_pkl, 'r') as f: dets = pickle.load(f) assert all(k in dets for k in ['all_boxes', 'all_segms', 'all_keyps']), \ 'Expected detections pkl file in the format used by test_engine.py' all_boxes = dets['all_boxes'] all_segms = dets['all_segms'] all_keyps = dets['all_keyps'] def id_or_index(ix, val): if len(val) == 0: return val else: return val[ix] for ix, entry in enumerate(roidb): if limit > 0 and ix >= limit: break if ix % 10 == 0: print('{:d}/{:d}'.format(ix + 1, len(roidb))) im = cv2.imread(entry['image']) im_name = os.path.splitext(os.path.basename(entry['image']))[0] cls_boxes_i = [ id_or_index(ix, cls_k_boxes) for cls_k_boxes in all_boxes ] cls_segms_i = [ id_or_index(ix, cls_k_segms) for cls_k_segms in all_segms ] cls_keyps_i = [ id_or_index(ix, cls_k_keyps) for cls_k_keyps in all_keyps ] vis_utils.vis_one_image( im[:, :, ::-1], '{:d}_{:s}'.format(ix, im_name), os.path.join(output_dir, 'vis'), cls_boxes_i, segms=cls_segms_i, keypoints=cls_keyps_i, thresh=thresh, box_alpha=0.8, dataset=ds, show_class=True )
def vis(dataset, detections_pkl, thresh, output_dir, limit=0): ds = JsonDataset(dataset) roidb = ds.get_roidb() with open(detections_pkl, 'rb') as f: dets = pickle.load(f) assert all(k in dets for k in ['all_boxes', 'all_segms', 'all_keyps']), \ 'Expected detections pkl file in the format used by test_engine.py' all_boxes = dets['all_boxes'] all_segms = dets['all_segms'] all_keyps = dets['all_keyps'] def id_or_index(ix, val): if len(val) == 0: return val else: return val[ix] for ix, entry in enumerate(roidb): if limit > 0 and ix >= limit: break if ix % 10 == 0: print('{:d}/{:d}'.format(ix + 1, len(roidb))) im = cv2.imread(entry['image']) im_name = os.path.splitext(os.path.basename(entry['image']))[0] cls_boxes_i = [ id_or_index(ix, cls_k_boxes) for cls_k_boxes in all_boxes ] cls_segms_i = [ id_or_index(ix, cls_k_segms) for cls_k_segms in all_segms ] cls_keyps_i = [ id_or_index(ix, cls_k_keyps) for cls_k_keyps in all_keyps ] vis_utils.vis_one_image( im[:, :, ::-1], '{:d}_{:s}'.format(ix, im_name), os.path.join(output_dir, 'vis'), cls_boxes_i, segms=cls_segms_i, keypoints=cls_keyps_i, thresh=thresh, box_alpha=0.8, dataset=ds, show_class=True )
def test_net_on_dataset(weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0): """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() ################################################################ import pickle res_file = os.path.join(output_dir, 'bbox_' + dataset_name + '_results.json') print("res_file = {}==========================".format(res_file)) if os.path.exists(res_file): import detectron.datasets.json_dataset_evaluator as json_dataset_evaluator print("res_file = {} exists! Loading res_file".format(res_file)) coco_eval = json_dataset_evaluator._do_detection_eval( dataset, res_file, output_dir) box_results = task_evaluation._coco_eval_to_box_results(coco_eval) results = OrderedDict([(dataset.name, box_results)]) return results ################################################################ det_name = "detections.pkl" det_file = os.path.join(output_dir, det_name) print("det_file = {}==========================".format(det_file)) if os.path.exists(det_file): print("{} exists! Loading detection results".format(det_file)) res = pickle.load(open(det_file)) all_boxes = res['all_boxes'] all_segms = res['all_segms'] all_keyps = res['all_keyps'] ################################################################ elif multi_gpu: num_images = len(dataset.get_roidb()) all_boxes, all_segms, all_keyps = multi_gpu_test_net_on_dataset( weights_file, dataset_name, proposal_file, num_images, output_dir) else: all_boxes, all_segms, all_keyps = test_net(weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format( test_timer.average_time)) results = task_evaluation.evaluate_all(dataset, all_boxes, all_segms, all_keyps, output_dir) return results
def test_net_on_dataset(weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0, subset_pointer=None): """Run inference on a dataset.""" if dataset_name[:5] != 'live_': dataset = JsonDataset(dataset_name) test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) all_boxes, all_segms, all_keyps = multi_gpu_test_net_on_dataset( weights_file, dataset_name, proposal_file, num_images, output_dir) else: all_boxes, all_segms, all_keyps = test_net( weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id, subset_pointer=subset_pointer) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format( test_timer.average_time)) if cfg.TEST.COCO_TO_VOC: all_boxes = coco_detects_to_voc(all_boxes) if dataset_name[:5] == 'live_': return None results = task_evaluation.evaluate_all(dataset, all_boxes, all_segms, all_keyps, output_dir, subset_pointer=subset_pointer) if subset_pointer is not None: # prune the subset for the following datasets: subset_pointer.subset = subset_pointer.subset[len(dataset.get_roidb() ):] print('remains', len(subset_pointer.subset) ) # should have 0 remains for the last set, voc_2012_train. return results
def do_reval(dataset_name, output_dir, args): dataset = JsonDataset(dataset_name) dets = load_object(os.path.join(output_dir, 'detections.pkl')) # Override config with the one saved in the detections file if args.cfg_file is not None: core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg'])) else: core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg) # re-filter on score threshold: dets['all_boxes'] = \ [ [ im[im[:,4] > cfg.TEST.SCORE_THRESH,:] if len(im) != 0 else [] for im in cls ] for cls in dets['all_boxes'] ] results = task_evaluation.evaluate_all(dataset, dets['all_boxes'], dets['all_segms'], dets['all_keyps'], output_dir, use_matlab=args.matlab_eval) task_evaluation.log_copy_paste_friendly_results(results)
def validate_tracking_params(weights_file, dataset_name): dataset = JsonDataset(dataset_name) output_dir = os.path.abspath(get_output_dir(dataset.name, training=False)) #tracking parameter files class_thresh_file = os.path.join(output_dir, 'AP_thresholds.txt') obs_model_file = os.path.join(output_dir, 'observation_model.txt') meas_cov_file = os.path.join(output_dir, 'meas_cov.txt') #generate param files if they do not exist if (not os.path.exists(class_thresh_file) or not os.path.exists(obs_model_file) or not os.path.exists(meas_cov_file)): logger.info('validation files for validation dataset %s do not ' 'exist. Generating them now' % (dataset.name)) #this performs inference on all images and calls the evaluation #script, generating the validation files test_net_on_dataset(weights_file,dataset.name,None,output_dir) #read parameters from files cla_thresh = load_class_thresholds(class_thresh_file, dataset) observation_model = np.loadtxt(obs_model_file, delimiter=',') ekf_sensor_noise = np.loadtxt(meas_cov_file, delimiter=',') return cla_thresh, observation_model, ekf_sensor_noise
def get_roidb(dataset_name, ind_range): """Get the roidb for the dataset specified in the global cfg. Optionally restrict it to a range of indices if ind_range is a pair of integers. """ dataset = JsonDataset(dataset_name) roidb = dataset.get_roidb() if ind_range is not None: total_num_images = len(roidb) start, end = ind_range roidb = roidb[start:end] else: start = 0 end = len(roidb) total_num_images = end return roidb, start, end, total_num_images
def get_roidb(dataset_info, proposal_file): ds = JsonDataset(dataset_info) roidb = ds.get_roidb(gt=True, proposal_file=proposal_file, crowd_filter_thresh=cfg.TRAIN.CROWD_FILTER_THRESH) if cfg.TRAIN.USE_FLIPPED: logger.info('Appending horizontally-flipped training examples...') extend_with_flipped_entries(roidb, ds) # TT: Augmentation if cfg.TRAIN.USE_TRANSFORMATION: logger.info('Appending augmented training examples...') transform_samples = int(cfg.TRAIN.TRANSFORM_SAMPLES) extend_with_augmented_entries(roidb, ds, aug_samples=transform_samples) # TT: end logger.info('Loaded dataset: {:s}'.format(ds.name)) return roidb
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dataset_name = cfg.TEST.DATASETS[0] dummy_coco_dataset = JsonDataset(dataset_name) # dummy_coco_dataset = dummy_datasets.get_paris_dataset() vid_dir = '/coco/paris_dataset/PARIS_demo.mp4' cap = cv2.VideoCapture(vid_dir) ret, im = cap.read() count = 0 while ret: im_name = str(count) out_name = os.path.join(args.output_dir, '{}'.format(str(count) + '.jpg')) logger.info('Processing frame -> {}'.format(count)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) vis_im = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) # cv2.imshow('frame', vis_im) # cv2.waitKey(10) ret, im = cap.read() count += 1 cap.release() cv2.destroyAllWindows()
def get_roidb_and_dataset(dataset_name, proposal_file, ind_range): """Get the roidb for the dataset specified in the global cfg. Optionally restrict it to a range of indices if ind_range is a pair of integers. """ dataset = JsonDataset(dataset_name) if cfg.TEST.PRECOMPUTED_PROPOSALS: assert proposal_file, 'No proposal file given' roidb = dataset.get_roidb( proposal_file=proposal_file, proposal_limit=cfg.TEST.PROPOSAL_LIMIT ) else: roidb = dataset.get_roidb() if ind_range is not None: total_num_images = len(roidb) start, end = ind_range roidb = roidb[start:end] else: start = 0 end = len(roidb) total_num_images = end return roidb, dataset, start, end, total_num_images
def do_reval(dataset_name, output_dir, args): dataset = JsonDataset(dataset_name) dets = load_object(os.path.join(output_dir, 'detections.pkl')) # Override config with the one saved in the detections file if args.cfg_file is not None: core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg'])) else: core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg) results = task_evaluation.evaluate_all(dataset, dets['all_boxes'], dets['all_segms'], dets['all_keyps'], output_dir, use_matlab=args.matlab_eval) task_evaluation.log_copy_paste_friendly_results(results)
def do_reval(dataset_name, output_dir, args): dataset = JsonDataset(dataset_name) with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f: dets = pickle.load(f) # Override config with the one saved in the detections file if args.cfg_file is not None: # bug: loads only already stored cfg # core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg'])) # merge config from passed config file!! core_config.merge_cfg_from_file(args.cfg_file) else: core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg) results = task_evaluation.evaluate_all(dataset, dets['all_boxes'], dets['all_segms'], dets['all_keyps'], output_dir, use_matlab=args.matlab_eval) task_evaluation.log_copy_paste_friendly_results(results)
def run_tracking(validation_dataset, tracking_datasets, weights_file, timestep, use_hmm=True, no_filtering=False, visualize=False, step=False): class_thresh, obs_model, meas_cov = validate_tracking_params(weights_file, validation_dataset) res_files = [] json_datasets = [] for i in range(len(tracking_datasets)): tracking_set_name = tracking_datasets[i] tracking_set_json = JsonDataset(tracking_set_name) detections, res_file = get_detections(weights_file, tracking_set_json, class_thresh) if not no_filtering: filtered_boxes, filtered_depths = do_kalman_filtering(detections, tracking_set_json, timestep, meas_cov, obs_model, use_hmm=use_hmm, viz=visualize, step=step) res_file = write_filtered_detections(tracking_set_json, filtered_boxes, filtered_depths, use_hmm) res_files.append(res_file) json_datasets.append(tracking_set_json) #perform the evaluation for all datasets tracking_dataset_name = '-'.join(tracking_datasets) tracking_output_dir = os.path.abspath(get_output_dir(tracking_dataset_name, training=False)) evaluate_tracking(res_files, json_datasets, tracking_output_dir, use_matlab=True)
from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import json import os import cv2 from PIL import Image import numpy as np from detectron.datasets.json_dataset import JsonDataset example_json = json.load( open('/coco/annotations/person_keypoints_minival2014.json')) dataset = JsonDataset('paris_2019_train') dataset_dir = '/coco/paris_dataset' res_json = json.load( open(os.path.join(dataset_dir, 'paris_building_train.json'))) json_keys = [u'images', u'annotations', u'categories'] im_info = [u'file_name', u'height', u'width', u'id'] ann_info = [ u'bbox', u'segmentation', u'num_keypoints', u'area', u'iscrowd', u'image_id', u'category_id', u'id', u'keypoints' ] cat_info = [] paris_data = [] classes = {} folder_idx = 5 ann_info = 6 images_list = [] anns_list = [] new_cat_id = 0 im_id = 0
def main(args): MINIMAL = False TRAIN = False FORWARD = False SHAPES = False HIDE_PARAMS = True if args.opts is not None: if 'minimal' in args.opts: MINIMAL = True if 'train' in args.opts: TRAIN = True if 'forward' in args.opts: FORWARD = True if 'shapes' in args.opts: SHAPES = True if 'params' in args.opts: HIDE_PARAMS = False if SHAPES and args.model_file is None: raise ValueError('Specify model file') MODEL_FILE = args.model_file NET_NAMES = args.net_names if MINIMAL: get_dot_graph = lambda net, shapes: net_drawer.GetPydotGraphMinimal( net, rankdir="BT") else: get_dot_graph = lambda net, shapes: net_drawer.GetPydotGraph( net, rankdir="BT", shapes=shapes, hide_params=HIDE_PARAMS) # Get model if args.cfg_file is not None: merge_cfg_from_file(args.cfg_file) cfg.NUM_GPUS = 1 cfg.VIS_NET = True if FORWARD: cfg.MODEL.FORWARD_ONLY = True assert_and_infer_cfg(cache_urls=False) if SHAPES and TRAIN: raise NotImplementedError # Run model to get shape information of all blobs if SHAPES: model = infer_engine.initialize_model_from_cfg(MODEL_FILE) workspace.RunNetOnce(model.param_init_net) nu.broadcast_parameters(model) dataset = JsonDataset(cfg.TRAIN.DATASETS[0]) roidb = dataset.get_roidb() with c2_utils.NamedCudaScope(0): if cfg.MODEL.TRACKING_ON: roidb_min = [roidb[0], roidb[1]] im_list = [cv2.imread(e['image']) for e in roidb_min] infer_engine.multi_im_detect_all(model, im_list, [None, None]) else: infer_engine.im_detect_all(model, roidb[0]['image'], None) else: model = model_builder.create(cfg.MODEL.TYPE, train=TRAIN) subprocess.call(["killall", "xdot"]) # Visualize all specified nets for net_name in NET_NAMES: net = getattr(model, net_name, None) if net: print('processing graph {}...'.format(net_name)) g = get_dot_graph(net.Proto(), shapes=SHAPES) name = net_name if TRAIN: name_append = 'train' else: name_append = 'infer' # Save graph graph_dir = os.path.join(args.output_dir, cfg.MODEL.TYPE) if not os.path.exists(graph_dir): os.makedirs(graph_dir) dot_name = os.path.join(graph_dir, '{}_{}.dot'.format(net_name, name_append)) g.write_dot(dot_name) subprocess.Popen(['xdot', dot_name])
def get_roidb(dataset_name, proposal_file): ds = JsonDataset(dataset_name) roidb = ds.get_roidb(gt=True,proposal_file=proposal_file,crowd_filter_thresh=cfg.TRAIN.CROWD_FILTER_THRESH) return roidb
from __future__ import unicode_literals import _init_paths import numpy as np import h5py import sys from detectron.datasets.json_dataset import JsonDataset from detectron.utils.io import save_object if __name__ == '__main__': dataset_name = sys.argv[1] file_in = sys.argv[2] file_out = sys.argv[3] ds = JsonDataset(dataset_name) roidb = ds.get_roidb() boxes = [] scores = [] ids = [] with h5py.File(file_in, 'r') as f: raw_boxes = f['boxes'] num_imgs = len(raw_boxes) assert num_imgs == len(roidb) for ind in range(num_imgs): if ind % 1000 == 0: print('{}/{}'.format(ind + 1, len(roidb)))
def visualize_ranking(dataset, detections_pkl, opts): # Load predictions and ground truths ds = JsonDataset(dataset) roidb = ds.get_roidb(gt=True) dets = load_object(detections_pkl) all_boxes = dets['all_boxes'] def id_or_index(ix, val): if len(val) == 0: return val else: return val[ix] # Load coordinates with open(opts.coord_file) as json_file: coord_data = json.load(json_file) # Iterate through all images and note false positive and negatives, as well as entry scores false_positives = [] false_negatives = [] scores = [] for ix, entry in enumerate(roidb): cls_boxes_i = [ id_or_index(ix, cls_k_boxes) for cls_k_boxes in all_boxes ] preds = np.array(cls_boxes_i[opts.class_id]) entry['preds'] = preds true_boxes = entry['boxes'] if preds.shape[0] > 0 and np.max(preds[:, -1]) > opts.threshold: box_scores = preds[:, -1] box_scores = box_scores[np.where(box_scores > opts.threshold)] score = np.sum( box_scores[np.argsort(box_scores)[-opts.box_count:]]) scores.append([entry, score]) if true_boxes.shape[0] == 0: false_positives.append(entry) else: if true_boxes.shape[0] > 0: false_negatives = add_negative(false_negatives, entry, coord_data, opts.min_distance) # Find top rated entries scores = np.array(scores) scores = scores[np.argsort(scores[:, 1])[::-1]] for entry in scores[:, 0]: entry['coords'] = coord_data[os.path.split(entry['image'])[-1]] # Filter by proximity for i in range(scores.shape[0]): if scores[i][1] > 0: current_entry = scores[i][0] for j in range(i + 1, scores.shape[0]): second_entry = scores[j][0] dist = distance( (current_entry['coords'][0], current_entry['coords'][1]), (second_entry['coords'][0], second_entry['coords'][1])).km * 1000 if dist < opts.min_distance: scores[j][1] = 0 scores = scores[np.where(scores[:, 1] > 0)] top_entries = scores[np.argsort(scores[:, 1])[-opts.image_count:][::-1]] # Choose random negative samples false_samples = np.append(false_negatives, false_positives) np.random.shuffle(false_samples) # Visualize positive and negative samples rows_cols = (opts.image_count, 2) if opts.angle == 'ver' else (2, opts.image_count) plt_shape = (6., opts.image_count * 2.5) if opts.angle == 'ver' else (opts.image_count * 2.5, 6.) fig = plt.figure(1, plt_shape) grid = ImageGrid( fig, 111, nrows_ncols=rows_cols, axes_pad=0.03, label_mode='L', ) # Show top ranked images for i, result in enumerate(top_entries): entry = result[0] score = result[1] grid_idx = i if opts.angle == 'ver': grid_idx = i * 2 # Load image and add bounding boxes im = cv2.imread(entry['image']) preds = entry['preds'] true_boxes = entry['boxes'] for bbox in true_boxes: im = vis_bbox( im, (bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]), _GT_COLOR, opts.box_thickness) count = 0 for bbox in preds: if bbox[-1] > opts.threshold: count += 1 print( os.path.split(entry['image'])[-1] + ': ' + str(bbox[0:4])) im = vis_bbox( im, (bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]), _PRED_COLOR, opts.box_thickness) if count >= opts.box_count: break # Adjust grid setting im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) show_img(grid, im, grid_idx) t = grid[grid_idx].text(12, 42, "Score: " + str(round(score, 3)), fontsize=8, bbox=dict(boxstyle='square', fc='white', ec='none', alpha=0.6)) if i == 0: if opts.angle == 'ver': grid[grid_idx].set_title("Top\nPredictions", size=18) else: grid[grid_idx].set_ylabel("Top Predictions", fontsize=13) # Show random negative samples (false positive, false negative) for i, entry in enumerate(false_samples): if i >= opts.image_count: break grid_idx = opts.image_count + i if opts.angle == 'ver': grid_idx = 2 * i + 1 # Load image and add bounding boxes im = cv2.imread(entry['image']) preds = entry['preds'] true_boxes = entry['boxes'] for bbox in true_boxes: im = vis_bbox( im, (bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]), _GT_COLOR, opts.box_thickness) for bbox in preds: if bbox[-1] > opts.threshold: im = vis_bbox( im, (bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]), _PRED_COLOR, opts.box_thickness) # Adjust grid setting im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) grid[grid_idx].imshow(im) grid[grid_idx].grid(False) grid[grid_idx].set_xticks([]) grid[grid_idx].set_yticks([]) if i == 0: if opts.angle == 'ver': grid[grid_idx].set_title("Errors", size=18) else: grid[grid_idx].set_ylabel("Errors", fontsize=13) plt.axis('off') plt.subplots_adjust(hspace=1) plt.savefig("ranking.png", dpi=300, bbox_inches='tight')
def get_roidb(dataset_name, proposal_file): ds = JsonDataset(dataset_name) roidb = ds.get_roidb(gt=True, proposal_file=proposal_file, crowd_filter_thresh=cfg.TRAIN.CROWD_FILTER_THRESH) sum1 = 0 roidb0 = roidb * 1 #for shanghai circuit if 0: #for shanghai ltps label =3 num_list = [[], [], []] for roidb_i, roidb_list in enumerate(roidb0): try: ppp = roidb_list['gt_classes'][0] except: continue if roidb_list['gt_classes'][0] == 1: num_list[0].append(roidb_list) if roidb_list['gt_classes'][0] == 2: num_list[1].append(roidb_list) if roidb_list['gt_classes'][0] == 3: num_list[2].append(roidb_list) num_list_num = [ len(num_list[0]), len(num_list[1]), len(num_list[2]) ] print(num_list_num) num_max = max(num_list_num) else_num = [num_max - sub_num for sub_num in num_list_num] up_int = int(0) for ii, sub_else_num in enumerate(else_num): if sub_else_num > len(num_list[ii]): up_int = math.ceil( float(sub_else_num) / len(num_list[ii])) #up get int vv = num_list[ii] * 1 for up_int_i in range(int(up_int) - 1): for sub_vv in vv: num_list[ii].append(sub_vv) #else: uu = random.sample(num_list[ii], sub_else_num) for sub_uu in uu: roidb.append(sub_uu) if 0: #for shanghai tp label =2 tp num_list = [[], []] for roidb_i, roidb_list in enumerate(roidb0): try: ppp = roidb_list['gt_classes'][0] except: continue if roidb_list['gt_classes'][0] == 1: num_list[0].append(roidb_list) if roidb_list['gt_classes'][0] == 2: num_list[1].append(roidb_list) num_list_num = [len(num_list[0]), len(num_list[1])] num_max = max(num_list_num) else_num = [num_max - sub_num for sub_num in num_list_num] up_int = int(0) for ii, sub_else_num in enumerate(else_num): if sub_else_num > len(num_list[ii]): up_int = math.ceil( float(sub_else_num) / len(num_list[ii])) #up get int vv = num_list[ii] * 1 for up_int_i in range(int(up_int) - 1): for sub_vv in vv: num_list[ii].append(sub_vv) #else: uu = random.sample(num_list[ii], sub_else_num) for sub_uu in uu: roidb.append(sub_uu) if 0: #for mask num_list = [[], [], [], []] for roidb_i, roidb_list in enumerate(roidb0): try: ppp = roidb_list['gt_classes'][0] except: continue if roidb_list['gt_classes'][0] == 1: num_list[0].append(roidb_list) if roidb_list['gt_classes'][0] == 2: num_list[1].append(roidb_list) if roidb_list['gt_classes'][0] == 3: num_list[2].append(roidb_list) if roidb_list['gt_classes'][0] == 4: num_list[3].append(roidb_list) #if roidb_list['gt_classes'][0] == 5: # aa=1 if 1: num_list_num = [ len(num_list[0]), len(num_list[1]), len(num_list[2]), len(num_list[3]) ] num_max = max(num_list_num) else_num = [num_max - sub_num for sub_num in num_list_num] up_int = int(0) for ii, sub_else_num in enumerate(else_num): if sub_else_num > len(num_list[ii]): up_int = math.ceil( float(sub_else_num) / len(num_list[ii])) #up get int vv = num_list[ii] * 1 for up_int_i in range(int(up_int) - 1): for sub_vv in vv: num_list[ii].append(sub_vv) #else: uu = random.sample(num_list[ii], sub_else_num) for sub_uu in uu: roidb.append(sub_uu) if 0: # for mask verify roidb0 = roidb * 1 num_list = [[], [], [], []] for roidb_i, roidb_list in enumerate(roidb0): try: ppp = roidb_list['gt_classes'][0] except: continue if roidb_list['gt_classes'][0] == 1: num_list[0].append(roidb_list) if roidb_list['gt_classes'][0] == 2: num_list[1].append(roidb_list) if roidb_list['gt_classes'][0] == 3: num_list[2].append(roidb_list) if roidb_list['gt_classes'][0] == 4: num_list[3].append(roidb_list) num_list_num = [ len(num_list[0]), len(num_list[1]), len(num_list[2]), len(num_list[3]) ] print('ok') if 0: #for S5 for roidb_i, roidb_list in enumerate(roidb0): try: ppp = roidb_list['gt_classes'][0] except: continue if roidb_list['gt_classes'][0] == 0: print('test.jpg') if 0: #not for S5 for roidb_i, roidb_list in enumerate(roidb0): try: ppp = roidb_list['gt_classes'][0] except: continue if roidb_list['gt_classes'][ 0] != 0: #and roidb_list['gt_classes'][0] != 1: #print('else') for mm in range(3): #for 3 S3 S4 5 S2 3 S1 ? 2 for S5 roidb.append(roidb_list) if 0: # for S4 if 1 in roidb_list['gt_classes']: #1 for baise for mm in range(8): #for 3 S3 S4 8 roidb.append(roidb_list) if 0: roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) roidb.append(roidb_list) sum1 += 1 #if roidb_list['gt_classes'][0] == 1: # print('error') if cfg.TRAIN.USE_FLIPPED: logger.info('Appending horizontally-flipped training examples...') extend_with_flipped_entries(roidb, ds) logger.info('Loaded dataset: {:s}'.format(ds.name)) return roidb
offset_matrix = np.array([[1, 0, o_x], [0, 1, o_y], [0, 0, 1]]) reset_matrix = np.array([[1, 0, -o_x], [0, 1, -o_y], [0, 0, 1]]) transform_matrix = np.dot(np.dot(offset_matrix, matrix), reset_matrix) return transform_matrix # input_dir = '/mnt/genesis/vegas/Databases/CBIS-DDSM_resized/Train/Ground Truth' # output = '/mnt/genesis/vegas/transformed' # test = '/mnt/genesis/vegas' input_dir = '/mnt/Cargo_2/Diploma_Thesis/Databases/CBIS-DDSM/Train/Ground Truth' # output = '/mnt/genesis/vegas/transformed' test = '/home/gru' ds = JsonDataset('CBIS_DDSM_train') roidb = ds.get_roidb(gt=True, proposal_file=None, crowd_filter_thresh=0.7 ) # if not os.path.isdir(output): # os.mkdir(output) images = [os.path.join(root, file) for root, _, files in os.walk(os.path.join(input_dir, 'Ground Truth')) for file in files] for i in range(len(roidb)): if '00465_LEFT_CC' not in roidb[i]['image']: continue # angle = uniform(-20, 20) angle = 17.87189165364299 # shear = uniform(-0.2, 0.2)
from __future__ import print_function from __future__ import unicode_literals import cPickle as pickle import numpy as np import scipy.io as sio import sys from detectron.datasets.json_dataset import JsonDataset if __name__ == '__main__': dataset_name = sys.argv[1] file_in = sys.argv[2] file_out = sys.argv[3] ds = JsonDataset(dataset_name) roidb = ds.get_roidb() raw_data = sio.loadmat(file_in)['boxes'].ravel() assert raw_data.shape[0] == len(roidb) boxes = [] scores = [] ids = [] for i in range(raw_data.shape[0]): if i % 1000 == 0: print('{}/{}'.format(i + 1, len(roidb))) # selective search boxes are 1-indexed and (y1, x1, y2, x2) i_boxes = raw_data[i][:, (1, 0, 3, 2)] - 1 boxes.append(i_boxes.astype(np.float32)) scores.append(np.zeros((i_boxes.shape[0]), dtype=np.float32)) ids.append(roidb[i]['id'])
def main(args): datasetName = 'logo_1048_test' #'furniture_val' logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 vis = True #False shuffleList = False args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) if args.cls_thrsh_file is not None: class_thresholds = { l.split('\t')[0]: float(l.rstrip().split('\t')[1]) for l in open(args.cls_thrsh_file, 'r').readlines() } print(class_thresholds) else: class_thresholds = None #dummy_coco_dataset = dummy_datasets.get_coco_dataset() dataset = JsonDataset(datasetName) print(args.im_or_folder) #if os.path.isdir(args.im_or_folder): # im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) #else: # im_list = [args.im_or_folder] if osp.isdir(args.im_or_folder): if args.im_list is None: im_list = glob.glob(args.im_or_folder + '/*.' + args.image_ext) im_list = [osp.basename(n) for n in im_list] else: im_list = [ l.rstrip().split('\t')[0] + '.jpg' for l in open(args.im_list, 'r').readlines() ] im_list = [osp.join(args.im_or_folder, n) for n in im_list] print(im_list[0]) if shuffleList: from random import shuffle shuffle(im_list) checkMkdir(args.output_dir) outTable = osp.join(args.output_dir, 'HF_CT_Measurement_Detected_Boxes.tsv') with open(outTable, 'wb') as fout: for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) #logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) #logger.info('Inference time: {:.3f}s'.format(time.time() - t)) #for k, v in timers.items(): # logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') outStrings = output_detbbox_one_image( im[:, :, ::-1], im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dataset, #dummy_coco_dataset, box_alpha=0.3, show_class=True, class_thresholds=class_thresholds, thresh=0.5, kp_thresh=2) if outStrings is not None: fout.write(outStrings) if vis: vis_utils.vis_detbbox_one_image( #vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dataset, #dummy_coco_dataset, box_alpha=0.3, show_class=True, class_thresholds=class_thresholds, thresh=0.5, kp_thresh=2)
assert_and_infer_cfg() logger.info('Testing with config:') logger.info(pprint.pformat(cfg)) while not os.path.exists(cfg.TEST.WEIGHTS) and args.wait: logger.info('Waiting for \'{}\' to exist...'.format(cfg.TEST.WEIGHTS)) time.sleep(10) all_results = run_inference(cfg.TEST.WEIGHTS, ind_range=args.range, multi_gpu_testing=args.multi_gpu_testing, check_expected_results=False, evaluation=False) all_boxes = all_results['all_boxes'] test_dataset = JsonDataset(cfg.TEST.DATASETS[0]) image_set = test_dataset.name.split('_')[-1] root_path = DATASETS[test_dataset.name][ROOT_DIR] image_set_path = os.path.join(root_path, 'ImageSets', 'Main', image_set + '.txt') with open(image_set_path, 'r') as f: image_index = [x.strip() for x in f.readlines()] test_roidb = test_dataset.get_roidb() for i, entry in enumerate(test_roidb): index = os.path.splitext(os.path.split(entry['image'])[1])[0] assert index == image_index[i] # crop images based on detected boxes and store into imgs_crop imgs_crop = []
def test_net_on_dataset(weights_file, dataset_name, proposal_file, output_dir, multi_gpu=False, gpu_id=0): load_from_tmp = False """Run inference on a dataset.""" dataset = JsonDataset(dataset_name) if not load_from_tmp: test_timer = Timer() test_timer.tic() if multi_gpu: num_images = len(dataset.get_roidb()) all_boxes, all_segms, all_keyps, all_personmasks, all_parss, all_bodys = \ multi_gpu_test_net_on_dataset( weights_file, dataset_name, proposal_file, num_images, output_dir ) else: all_boxes, all_segms, all_keyps, all_personmasks, all_parss, all_bodys = test_net( weights_file, dataset_name, proposal_file, output_dir, gpu_id=gpu_id) test_timer.toc() logger.info('Total inference time: {:.3f}s'.format( test_timer.average_time)) else: tmp_path = '/coco/results/detectron-output_mulres_intersup_mulsaclesup_lowfeat23_int05/test/dense_coco_2014_minival/generalized_rcnn/detections.pkl' #tmp_path = '/coco/results/detectron-output_mulres_intersup/test/dense_coco_2014_minival/generalized_rcnn/detections.pkl' #tmp_path = '/coco/results/detectron-output_mulres_intersup_onlysegpart_fliped/test/MHP_seg_val/generalized_rcnn/detections.pkl' #tmp_path = '/coco/results/detectron-output_mulres_intersup_onlysegpart_fliped/test/CIHP_seg_val/generalized_rcnn/detections.pkl' tmp_file = open(tmp_path, 'r') print('detections results from: ', tmp_path) tmp_pkl = pickle.load(tmp_file) all_boxes = tmp_pkl['all_boxes'] all_segms = tmp_pkl['all_segms'] all_keyps = tmp_pkl['all_keyps'] if 'all_personmasks' not in tmp_pkl.keys(): all_personmasks = None else: all_personmasks = tmp_pkl['all_personmasks'] all_parss = tmp_pkl['all_parss'] all_bodys = tmp_pkl['all_bodys'] ''' for i in range(len(all_bodys[1])): for j in range(len(all_bodys[1][i])): #print("all_bodys[1][i][j]: ",all_bodys[1][i][j].shape) all_bodys[1][i][j][0][np.where(all_bodys[1][i][j][0] == 3)] = 4 all_bodys[1][i][j][0][np.where(all_bodys[1][i][j][0] == 4)] = 3 all_bodys[1][i][j][0][np.where(all_bodys[1][i][j][0] == 6)] = 5 all_bodys[1][i][j][0][np.where(all_bodys[1][i][j][0] == 5)] = 6 ''' if cfg.VIS: vis_wholedataset( dataset_name, proposal_file, output_dir, all_boxes=all_boxes, all_segms=all_segms, all_keyps=all_keyps, all_personmasks=all_personmasks, all_parss=all_parss, all_bodys=all_bodys, img_name=['COCO_val2014_000000464089.jpg'], show_box=False, ) results = task_evaluation.evaluate_all(dataset, all_boxes, all_segms, all_keyps, all_personmasks, all_parss, all_bodys, output_dir) return results