def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) final = draw_final_outputs( img, results) # image contain boxes,labels and scores viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def visualize(model, model_path, nr_visualize=100, output_dir='output'): """ Visualize some intermediate results (proposals, raw predictions) inside the pipeline. """ df = get_train_dataflow() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor( PredictConfig(model=model, session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals/boxes'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals/probs'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_probs', 'final_boxes', 'final_probs', 'final_labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df.get_data()), nr_visualize): img = dp[0] if cfg.MODE_MASK: gt_boxes, gt_labels, gt_masks = dp[-3:] else: gt_boxes, gt_labels = dp[-2:] rpn_boxes, rpn_scores, all_probs, \ final_boxes, final_probs, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_probs[good_proposals_ind]) results = [ DetectionResult(*args) for args in zip(final_boxes, final_probs, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) print(len(results)) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info("Inference output written to output.png") tpviz.interactive_imshow(viz)
def visualize(model_path, nr_visualize=50, output_dir='output'): df = get_train_dataflow_coco() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor( PredictConfig(model=Model(), session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_rpn_proposals/boxes', 'generate_rpn_proposals/probs', 'fastrcnn_all_probs', 'final_boxes', 'final_probs', 'final_labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df.get_data()), nr_visualize): img, _, _, gt_boxes, gt_labels = dp rpn_boxes, rpn_scores, all_probs, \ final_boxes, final_probs, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_probs[good_proposals_ind]) if config.USE_SECOND_HEAD: results = [ SecondDetectionResult(*args) for args in zip(final_boxes, final_probs, final_labels, [None] * len(final_labels)) ] else: results = [ DetectionResult(*args) for args in zip(final_boxes, final_probs, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def visualize(model, model_path, nr_visualize=100, output_dir='output'): """ Visualize some intermediate results (proposals, raw predictions) inside the pipeline. """ df = get_train_dataflow() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor(PredictConfig( model=model, session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals/boxes'.format('fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals/scores'.format('fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_scores', 'output/boxes', 'output/scores', 'output/labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df), nr_visualize): img = dp[0] if cfg.MODE_MASK: gt_boxes, gt_labels, gt_masks = dp[-3:] else: gt_boxes, gt_labels = dp[-2:] rpn_boxes, rpn_scores, all_scores, \ final_boxes, final_scores, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall(img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_scores[good_proposals_ind]) results = [DetectionResult(*args) for args in zip(final_boxes, final_scores, final_labels, [None] * len(final_labels))] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches([ gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info( "Inference output for {} written to output.png".format(input_file)) tpviz.interactive_imshow(viz)
def sample(model_path): pred = PredictConfig(session_init=get_model_loader(model_path), model=Model(), input_names=['label', 'z'], output_names=['gen/gen']) ds = MapData(RandomZData((100, 100)), lambda dp: [np.arange(100) % 10, dp[0]]) pred = SimpleDatasetPredictor(pred, ds) for o in pred.get_result(): o = o[0] * 255.0 viz = stack_patches(o, nr_row=10, nr_col=10) viz = cv2.resize(viz, (800, 800)) interactive_imshow(viz)
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) t = time.time() results = detect_one_image(img, pred_func) t_final = time.time() - t height, width, channels = img.shape print("Time: ", t_final, " for ", height * width / 1e6, " Mpixels , i.e. Width=", width, " Height=", height, " Channels=", channels) print("Throughput: ", height * width / 1e6 / t_final, " Mpixels/Sec") final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def predict(model_path, input_file): pred = OfflinePredictor( PredictConfig(model=Model(), session_init=get_model_loader(model_path), input_names=['image'], output_names=[ 'fastrcnn_fg_probs', 'fastrcnn_fg_boxes', ])) img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def sample(model_path): pred = PredictConfig( session_init=get_model_loader(model_path), model=Model(), input_names=['label', 'z'], output_names=['gen/gen']) ds = MapData(RandomZData((100, 100)), lambda dp: [np.arange(100) % 10, dp[0]]) pred = SimpleDatasetPredictor(pred, ds) for o in pred.get_result(): o = o[0] * 255.0 viz = stack_patches(o, nr_row=10, nr_col=10) viz = cv2.resize(viz, (800, 800)) interactive_imshow(viz)
def do_predict(pred_func, input_file): ''' 输入input_file,读取与图片,然后调用pred_func,得到了box,score,lables, 结果输出到output.jpg,并交互显示 boxes,labels,scores :param pred_func: :param input_file: :return: ''' img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info("Inference output for {} written to output.png".format(input_file)) tpviz.interactive_imshow(viz)
def visualize(model_path, nr_visualize=50, output_dir='output'): pred = OfflinePredictor( PredictConfig(model=Model(), session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_rpn_proposals/boxes', 'generate_rpn_proposals/probs', 'fastrcnn_all_probs', 'fastrcnn_fg_probs', 'fastrcnn_fg_boxes', ])) df = get_train_dataflow() df.reset_state() if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df.get_data()), nr_visualize): img, _, _, gt_boxes, gt_labels = dp rpn_boxes, rpn_scores, all_probs, fg_probs, fg_boxes = pred( img, gt_boxes, gt_labels) gt_viz = draw_annotation(img, gt_boxes, gt_labels) proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_probs[good_proposals_ind]) fg_boxes = clip_boxes(fg_boxes, img.shape[:2]) fg_viz = draw_predictions(img, fg_boxes, fg_probs) results = nms_fastrcnn_results(fg_boxes, fg_probs) final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, fg_viz, final_viz], 2, 3) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def sample(model_path): pred = OfflinePredictor( PredictConfig(session_init=get_model_loader(model_path), model=Model(), input_names=['z_code', 'z_noise'], output_names=['gen/viz'])) # sample all one-hot encodings (10 times) z_cat = np.tile(np.eye(10), [10, 1]) # sample continuos variables from -2 to +2 as mentioned in the paper z_uni = np.linspace(-2.0, 2.0, num=100) z_uni = z_uni[:, None] IMG_SIZE = 400 while True: # only categorical turned on z_noise = np.random.uniform(-1, 1, (100, NOISE_DIM)) zc = np.concatenate((z_cat, z_uni * 0, z_uni * 0), axis=1) o = pred(zc, z_noise)[0] viz1 = viz.stack_patches(o, nr_row=10, nr_col=10) viz1 = cv2.resize(viz1, (IMG_SIZE, IMG_SIZE)) # show effect of first continous variable with fixed noise zc = np.concatenate((z_cat, z_uni, z_uni * 0), axis=1) o = pred(zc, z_noise * 0)[0] viz2 = viz.stack_patches(o, nr_row=10, nr_col=10) viz2 = cv2.resize(viz2, (IMG_SIZE, IMG_SIZE)) # show effect of second continous variable with fixed noise zc = np.concatenate((z_cat, z_uni * 0, z_uni), axis=1) o = pred(zc, z_noise * 0)[0] viz3 = viz.stack_patches(o, nr_row=10, nr_col=10) viz3 = cv2.resize(viz3, (IMG_SIZE, IMG_SIZE)) canvas = viz.stack_patches([viz1, viz2, viz3], nr_row=1, nr_col=3, border=5, bgcolor=(255, 0, 0)) viz.interactive_imshow(canvas)
def sample(model_path): pred = OfflinePredictor(PredictConfig( session_init=get_model_loader(model_path), model=Model(), input_names=['z_code', 'z_noise'], output_names=['gen/viz'])) # sample all one-hot encodings (10 times) z_cat = np.tile(np.eye(10), [10, 1]) # sample continuos variables from -2 to +2 as mentioned in the paper z_uni = np.linspace(-2.0, 2.0, num=100) z_uni = z_uni[:, None] IMG_SIZE = 400 while True: # only categorical turned on z_noise = np.random.uniform(-1, 1, (100, NOISE_DIM)) zc = np.concatenate((z_cat, z_uni * 0, z_uni * 0), axis=1) o = pred(zc, z_noise)[0] viz1 = viz.stack_patches(o, nr_row=10, nr_col=10) viz1 = cv2.resize(viz1, (IMG_SIZE, IMG_SIZE)) # show effect of first continous variable with fixed noise zc = np.concatenate((z_cat, z_uni, z_uni * 0), axis=1) o = pred(zc, z_noise * 0)[0] viz2 = viz.stack_patches(o, nr_row=10, nr_col=10) viz2 = cv2.resize(viz2, (IMG_SIZE, IMG_SIZE)) # show effect of second continous variable with fixed noise zc = np.concatenate((z_cat, z_uni * 0, z_uni), axis=1) o = pred(zc, z_noise * 0)[0] viz3 = viz.stack_patches(o, nr_row=10, nr_col=10) viz3 = cv2.resize(viz3, (IMG_SIZE, IMG_SIZE)) canvas = viz.stack_patches( [viz1, viz2, viz3], nr_row=1, nr_col=3, border=5, bgcolor=(255, 0, 0)) viz.interactive_imshow(canvas)
def predict_unlabeled(model, model_path, nr_visualize=100, output_dir='output_patch_samples'): """Predict the pseudo label information of unlabeled data.""" assert cfg.EVAL.PSEUDO_INFERENCE, 'set cfg.EVAL.PSEUDO_INFERENCE=True' df, dataset_size = get_eval_unlabeled_dataflow(cfg.DATA.TRAIN, return_size=True) df.reset_state() predcfg = PredictConfig( model=model, session_init=SmartInit(model_path), input_names=['image'], # ['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals/boxes'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals/scores'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_scores', 'output/boxes', 'output/scores', # score of the labels 'output/labels', ]) pred = OfflinePredictor(predcfg) if os.path.isdir(output_dir): if os.path.isfile(os.path.join(output_dir, 'pseudo_data.npy')): os.remove(os.path.join(output_dir, 'pseudo_data.npy')) if not os.path.isdir(os.path.join(output_dir, 'vis')): os.makedirs(os.path.join(output_dir, 'vis')) else: shutil.rmtree(os.path.join(output_dir, 'vis')) fs.mkdir_p(output_dir + '/vis') else: fs.mkdir_p(output_dir) fs.mkdir_p(output_dir + '/vis') logger.warning('-' * 100) logger.warning('Write to {}'.format(output_dir)) logger.warning('-' * 100) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df), nr_visualize): img, img_id = dp # dp['image'], dp['img_id'] rpn_boxes, rpn_scores, all_scores, \ final_boxes, final_scores, final_labels = pred(img) outs = { 'proposals_boxes': rpn_boxes, # (?,4) 'proposals_scores': rpn_scores, # (?,) 'boxes': final_boxes, 'scores': final_scores, 'labels': final_labels } ratios = [10, 10] # [top 20% as background, bottom 20% as background] bg_ind, fg_ind = custom.find_bg_and_fg_proposals(all_scores, ratios=ratios) bg_viz = draw_predictions(img, rpn_boxes[bg_ind], all_scores[bg_ind]) fg_viz = draw_predictions(img, rpn_boxes[fg_ind], all_scores[fg_ind]) results = [ DetectionResult(*args) for args in zip(final_boxes, final_scores, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches([bg_viz, fg_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) assert cv2.imwrite('{}/vis/{:03d}.png'.format(output_dir, idx), viz) pbar.update() logger.info('Write {} samples to {}'.format(nr_visualize, output_dir)) ## Parallel inference the whole unlabled data pseudo_preds = collections.defaultdict(list) num_tower = max(cfg.TRAIN.NUM_GPUS, 1) graph_funcs = MultiTowerOfflinePredictor(predcfg, list( range(num_tower))).get_predictors() dataflows = [ get_eval_unlabeled_dataflow(cfg.DATA.TRAIN, shard=k, num_shards=num_tower) for k in range(num_tower) ] all_results = multithread_predict_dataflow(dataflows, graph_funcs) for id, result in tqdm.tqdm(enumerate(all_results)): img_id = result['image_id'] outs = { 'proposals_boxes': result['proposal_box'].astype(np.float16), # (?,4) 'proposals_scores': result['proposal_score'].astype(np.float16), # (?,) # 'frcnn_all_scores': result['frcnn_score'].astype(np.float16), 'boxes': result['bbox'].astype(np.float16), # (?,4) 'scores': result['score'].astype(np.float16), # (?,) 'labels': result['category_id'].astype(np.float16) # (?,) } pseudo_preds[img_id] = outs logger.warn('Writing to {}'.format( os.path.join(output_dir, 'pseudo_data.npy'))) try: dd.io.save(os.path.join(output_dir, 'pseudo_data.npy'), pseudo_preds) except RuntimeError: logger.error('Save failed. Check reasons manually...')
def do_visualize(model, model_path, nr_visualize=100, output_dir='output'): """ Visualize some intermediate results (proposals, raw predictions) inside the pipeline. """ df = get_train_dataflow() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor( PredictConfig( model=model, session_init=get_model_loader(model_path), input_names=['images', 'orig_image_dims', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals_topk_per_image/boxes'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals_topk_per_image/scores'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_scores', 'output/boxes', 'output/scores', 'output/labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df), nr_visualize): img, gt_boxes, gt_labels = dp['images'], dp['gt_boxes'], dp[ 'gt_labels'] orig_shape = img.shape[:2] rpn_boxes, rpn_scores, all_scores, \ final_boxes, final_scores, final_labels = pred(np.expand_dims(img, axis=0), np.expand_dims(np.array(img.shape), axis=0), np.expand_dims(gt_boxes, axis=0), np.expand_dims(gt_labels, axis=0)) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall # custom op creates different shape for boxes, convert back to original rpn_boxes = np.array([i[1:] for i in rpn_boxes]) proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_scores[good_proposals_ind]) results = [ DetectionResult(*args) for args in zip(final_boxes, final_scores, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def preprocess(fname): print("start preproc mapillary") start = time.time() label_fname = fname.replace(train_img_path, train_label_path).replace(".jpg", ".png") pil_label = Image.open(label_fname) label = np.array(pil_label) instances = np.unique(label) instance_classes = [x // 256 for x in instances] # filter by categories we use instances_valid = [ cls in config.MAPILLARY_CAT_IDS_TO_USE for cls in instance_classes ] instances = [ inst for inst, valid in zip(instances, instances_valid) if valid ] instance_classes = [ cls for cls, valid in zip(instance_classes, instances_valid) if valid ] if len(instances) == 0: print("no instances") pil_label.close() return None if map_to_coco: instance_classes = [ config.MAPILLARY_TO_COCO_MAP[cls] for cls in instance_classes ] instance_classes = [ config.VOID_LABEL if cls == config.VOID_LABEL else COCOMeta.category_id_to_class_id[cls] for cls in instance_classes ] else: # remap to contiguous numbers starting with 1 instance_classes = [ config.MAPILLARY_CAT_IDS_TO_USE.index(cls) + 1 for cls in instance_classes ] masks = np.array([label == inst for inst in instances], dtype=np.uint8) #import cProfile #start1 = time.time() boxes1 = np.array( [get_bbox_from_segmentation_mask(mask) for mask in masks], dtype=np.float32) #boxes1_time = time.time() - start1 #pr = cProfile.Profile() #pr.enable() #start1 = time.time() #boxes2 = get_bboxes_from_segmentation_masks(masks) #print("boxes1", boxes1_time, "boxes2", time.time() - start1) #pr.disable() #pr.print_stats(sort="cumulative") #assert (boxes1 == boxes2).all(), (boxes1, boxes2) boxes = boxes1 second_klass = np.array(instance_classes, dtype=np.int) klass = np.ones_like(second_klass) is_crowd = np.zeros_like(second_klass) res = preproc_img(fname, boxes, klass, second_klass, is_crowd, aug) if res is None: print("mapillary: preproc_img returned None on", fname) pil_label.close() return None ret, params = res if add_mask: do_flip, h, w = params[1] assert do_flip in (True, False), do_flip # augment label label = np.array(pil_label.resize((w, h), Image.NEAREST)) if do_flip: label = label[:, ::-1] # create augmented masks masks = np.array([label == inst for inst in instances], dtype=np.uint8) ret.append(masks) end = time.time() elapsed = end - start print("mapillary example done, elapsed:", elapsed) VISUALIZE = False if VISUALIZE: from viz import draw_annotation, draw_mask config.CLASS_NAMES = [str(idx) for idx in range(81)] im = ret[0] boxes = ret[3] draw_klass = ret[-2] viz = draw_annotation(im, boxes, draw_klass) for mask in masks: viz = draw_mask(viz, mask) tpviz.interactive_imshow(viz) pil_label.close() return ret
images=np.array([im for im,_ in images_and_shape]) orgin_shape=[s for _,s in images_and_shape] result=self.predict_416(images,batchSize,score_thresh,iou_thresh) for r,orgin in zip(result,orgin_shape): w,h=orgin if len(r['boxes'])==0 :continue bb=r['boxes']*np.array([w,h,w,h])/416 bb[:, [0, 2]] = np.maximum(bb[:, [0, 2]], 0) bb[:, [1, 3]] = np.maximum(bb[:, [1, 3]], 0) bb[:, [0, 2]] = np.minimum(bb[:, [0, 2]], w) bb[:, [1, 3]] = np.minimum(bb[:, [1, 3]], h) r['boxes']=bb return result import tensorpack.utils.viz as viz if __name__ == '__main__': model_path='/home/zxk/AI/tensorflow-yolov3/checkpoint/yolov3.ckpt' service=YoLoService(model_path) imagelist=['/home/zxk/PycharmProjects/deepAI1/daily/8/DeepLearning/myproject/yolo3/data/demo_data/611.jpg'] result=service.predict_imagelist(imagelist) # for r in result: # print(r['boxes'].shape,r['labels'].shape,r['scores'].shape) # print(r['boxes']) img=cv2.imread('/home/zxk/AI/coco/val2017/000000579893.jpg') bbox=service.predict(img) img=viz.draw_boxes(img,bbox['boxes']) viz.interactive_imshow(img)
def preprocess(fname): # print("start preproc mapillary") start = time.time() label_fname = fname.replace(train_img_path, train_label_path).replace(".jpg", ".png") pil_label = Image.open(label_fname) label = np.array(pil_label) instances = np.unique(label) instance_classes = [x // 256 for x in instances] if len(instances) == 0: print("no instances") pil_label.close() return None masks = np.array([label == inst for inst in instances], dtype=np.uint8) boxes1 = np.array( [get_bbox_from_segmentation_mask(mask) for mask in masks], dtype=np.float32) boxes = boxes1 # second_klass = np.array(instance_classes, dtype=np.int) second_klass = np.zeros_like(instance_classes, dtype=np.int) klass = np.ones_like(second_klass) is_crowd = np.zeros_like(second_klass) res = preproc_img(fname, boxes, klass, second_klass, is_crowd, aug) if res is None: print("davis: preproc_img returned None on", fname) pil_label.close() return None ret, params = res if add_mask: do_flip, h, w = params[1] assert do_flip in (True, False), do_flip # augment label label = np.array(pil_label.resize((w, h), Image.NEAREST)) if do_flip: label = label[:, ::-1] # create augmented masks masks = np.array([label == inst for inst in instances], dtype=np.uint8) ret.append(masks) end = time.time() elapsed = end - start # print("davis example done, elapsed:", elapsed) VISUALIZE = False if VISUALIZE: from viz import draw_annotation, draw_mask config.CLASS_NAMES = [str(idx) for idx in range(81)] im = ret[0] boxes = ret[3] draw_klass = ret[-2] viz = draw_annotation(im, boxes, draw_klass) for mask in masks: viz = draw_mask(viz, mask) tpviz.interactive_imshow(viz) pil_label.close() return ret
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
default='', type=str, help='Configurations of object detection model', nargs='+' ) args = parser.parse_args() if args.config: cfg.update_args(args.config) obj_detector = TensorPackDetector('/root/datasets/figmarcnn/checkpoint') img = cv2.imread('/root/datasets/img-folder/a.png', cv2.IMREAD_COLOR) results = obj_detector.detect(img, rgb=False) final = draw_final_outputs(img, results) # image contain boxes,labels and scores viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz) ''' --image /root/datasets/myimage/8.jpeg --cam 0 --obj_model two-stage --obj_ckpt /root/datasets/figmarcnn/checkpoint --obj_config DATA.BASEDIR=/root/datasets/COCO/DIR
def collect_samples(model, model_path, nr_visualize=100, output_dir='output_patch_samples'): """ Visualize some intermediate results (proposals, raw predictions) inside the pipeline. """ df = get_train_dataflow() df.reset_state() pred = OfflinePredictor( PredictConfig(model=model, session_init=SmartInit(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals/boxes'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals/scores'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_scores', 'output/boxes', 'output/scores', 'output/labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df), nr_visualize): img, gt_boxes, gt_labels = dp['image'], dp['gt_boxes'], dp[ 'gt_labels'] rpn_boxes, rpn_scores, all_scores, \ final_boxes, final_scores, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) ratios = [10, 10] #[top 20% as background, bottom 20% as background] bg_ind, fg_ind = custom.find_bg_and_fg_proposals(all_scores, ratios=ratios) bg_viz = draw_predictions(img, rpn_boxes[bg_ind], all_scores[bg_ind]) fg_viz = draw_predictions(img, rpn_boxes[fg_ind], all_scores[fg_ind]) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_scores[good_proposals_ind]) results = [ DetectionResult(*args) for args in zip(final_boxes, final_scores, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches([gt_viz, bg_viz, fg_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite('{}/{:03d}.png'.format(output_dir, idx), viz) pbar.update()
else: raise Exception("Unsupported dataset: {}".format(args.dataset)) print('Start to visualize dataset: {}'.format(args.dataset)) print("Type 'x' to stop.") while True: ind = random.randint(0, len(ds) - 1) img, sample = ds[ind] print("Visualizing image {}".format(sample["img"].split("/")[-1])) if multi_bbox_per_image: people = sample["people"] else: people = [sample] for person in people: x, y, w, h = person["bbox"] display_str = [ "{}/{}".format(k, v) for k, v in person["attrs"].items() ] draw_bounding_box_on_image(img, y, x, (y + h), (x + w), display_str_list=display_str, thickness=3, use_normalized_coordinates=False) # Convert pil image to opencv format for display control image_bgr = pil_to_cv_image(img) interactive_imshow(image_bgr)