def run_dataset(self): """ Read the data from dataset and calculate the accurary of the inference model. """ dataset = get_dataset(self.args) input_names = self.predictor.get_input_names() input_handle = self.predictor.get_input_handle(input_names[0]) output_names = self.predictor.get_output_names() output_handle = self.predictor.get_output_handle(output_names[0]) intersect_area_all = 0 pred_area_all = 0 label_area_all = 0 total_time = 0 progbar_val = progbar.Progbar(target=len(dataset), verbose=1) for idx, (img, label) in enumerate(dataset): data = np.array([img]) input_handle.reshape(data.shape) input_handle.copy_from_cpu(data) start_time = time.time() self.predictor.run() end_time = time.time() total_time += (end_time - start_time) pred = output_handle.copy_to_cpu() pred = self._postprocess(pred) pred = paddle.to_tensor(pred, dtype='int64') label = paddle.to_tensor(label, dtype="int32") if pred.shape != label.shape: label = paddle.unsqueeze(label, 0) label = F.interpolate(label, pred.shape[-2:]) label = paddle.squeeze(label, 0) intersect_area, pred_area, label_area = metrics.calculate_area( pred, label, dataset.num_classes, ignore_index=dataset.ignore_index) intersect_area_all = intersect_area_all + intersect_area pred_area_all = pred_area_all + pred_area label_area_all = label_area_all + label_area progbar_val.update(idx + 1) class_iou, miou = metrics.mean_iou(intersect_area_all, pred_area_all, label_area_all) class_acc, acc = metrics.accuracy(intersect_area_all, pred_area_all) kappa = metrics.kappa(intersect_area_all, pred_area_all, label_area_all) logger.info( "[EVAL] #Images: {} mIoU: {:.4f} Acc: {:.4f} Kappa: {:.4f} ".format( len(dataset), miou, acc, kappa)) logger.info("[EVAL] Class IoU: \n" + str(np.round(class_iou, 4))) logger.info("[EVAL] Class Acc: \n" + str(np.round(class_acc, 4))) logger.info("[EVAL] Average time: %.3f ms/img" % (total_time / len(dataset)) * 1000)
def collect_dynamic_shape(args): if not is_support_collecting(): logger.error("The Paddle does not support collecting dynamic shape, " \ "please reinstall the PaddlePaddle (latest gpu version).") # prepare config cfg = DeployConfig(args.config) pred_cfg = PredictConfig(cfg.model, cfg.params) pred_cfg.enable_use_gpu(1000, 0) pred_cfg.collect_shape_range_info(args.dynamic_shape_path) # create predictor predictor = create_predictor(pred_cfg) input_names = predictor.get_input_names() input_handle = predictor.get_input_handle(input_names[0]) # get images img_path_list, _ = get_image_list(args.image_path) if not isinstance(img_path_list, (list, tuple)): img_path_list = [img_path_list] logger.info(f"The num of images is {len(img_path_list)} \n") # collect progbar_val = progbar.Progbar(target=len(img_path_list)) for idx, img_path in enumerate(img_path_list): data = np.array([cfg.transforms(img_path)[0]]) input_handle.reshape(data.shape) input_handle.copy_from_cpu(data) try: predictor.run() except: logger.info( "Fail to collect dynamic shape. Usually, the error is out of " "GPU memory, for the model and image are too large.\n") del predictor if os.path.exists(args.dynamic_shape_path): os.remove(args.dynamic_shape_path) progbar_val.update(idx + 1) logger.info(f"The dynamic shape is save in {args.dynamic_shape_path}")
def predict(model, model_path, transforms, image_list, image_dir=None, trimap_list=None, save_dir='output'): """ predict and visualize the image_list. Args: model (nn.Layer): Used to predict for input image. model_path (str): The path of pretrained model. transforms (transforms.Compose): Preprocess for input image. image_list (list): A list of image path to be predicted. image_dir (str, optional): The root directory of the images predicted. Default: None. trimap_list (list, optional): A list of trimap of image_list. Default: None. save_dir (str, optional): The directory to save the visualized results. Default: 'output'. """ utils.utils.load_entire_model(model, model_path) model.eval() nranks = paddle.distributed.get_world_size() local_rank = paddle.distributed.get_rank() if nranks > 1: img_lists = partition_list(image_list, nranks) trimap_lists = partition_list( trimap_list, nranks) if trimap_list is not None else None else: img_lists = [image_list] trimap_lists = [trimap_list] if trimap_list is not None else None logger.info("Start to predict...") progbar_pred = progbar.Progbar(target=len(img_lists[0]), verbose=1) preprocess_cost_averager = TimeAverager() infer_cost_averager = TimeAverager() postprocess_cost_averager = TimeAverager() batch_start = time.time() with paddle.no_grad(): for i, im_path in enumerate(img_lists[local_rank]): preprocess_start = time.time() trimap = trimap_lists[local_rank][ i] if trimap_list is not None else None data = preprocess(img=im_path, transforms=transforms, trimap=trimap) preprocess_cost_averager.record(time.time() - preprocess_start) infer_start = time.time() alpha_pred = model(data) infer_cost_averager.record(time.time() - infer_start) postprocess_start = time.time() alpha_pred = reverse_transform(alpha_pred, data['trans_info']) alpha_pred = (alpha_pred.numpy()).squeeze() alpha_pred = (alpha_pred * 255).astype('uint8') # get the saved name if image_dir is not None: im_file = im_path.replace(image_dir, '') else: im_file = os.path.basename(im_path) if im_file[0] == '/' or im_file[0] == '\\': im_file = im_file[1:] save_path = os.path.join(save_dir, im_file) mkdir(save_path) save_alpha_pred(alpha_pred, save_path, trimap=trimap) postprocess_cost_averager.record(time.time() - postprocess_start) preprocess_cost = preprocess_cost_averager.get_average() infer_cost = infer_cost_averager.get_average() postprocess_cost = postprocess_cost_averager.get_average() if local_rank == 0: progbar_pred.update(i + 1, [('preprocess_cost', preprocess_cost), ('infer_cost cost', infer_cost), ('postprocess_cost', postprocess_cost)]) preprocess_cost_averager.reset() infer_cost_averager.reset() postprocess_cost_averager.reset() return alpha_pred
def evaluate(model, eval_dataset, aug_eval=False, scales=1.0, flip_horizontal=True, flip_vertical=False, is_slide=False, stride=None, crop_size=None, num_workers=0, print_detail=True): """ Launch evalution. Args: model(nn.Layer): A sementic segmentation model. eval_dataset (paddle.io.Dataset): Used to read and process validation datasets. aug_eval (bool, optional): Whether to use mulit-scales and flip augment for evaluation. Default: False. scales (list|float, optional): Scales for augment. It is valid when `aug_eval` is True. Default: 1.0. flip_horizontal (bool, optional): Whether to use flip horizontally augment. It is valid when `aug_eval` is True. Default: True. flip_vertical (bool, optional): Whether to use flip vertically augment. It is valid when `aug_eval` is True. Default: False. is_slide (bool, optional): Whether to evaluate by sliding window. Default: False. stride (tuple|list, optional): The stride of sliding window, the first is width and the second is height. It should be provided when `is_slide` is True. crop_size (tuple|list, optional): The crop size of sliding window, the first is width and the second is height. It should be provided when `is_slide` is True. num_workers (int, optional): Num workers for data loader. Default: 0. print_detail (bool, optional): Whether to print detailed information about the evaluation process. Default: True. Returns: float: The mIoU of validation datasets. float: The accuracy of validation datasets. """ model.eval() nranks = paddle.distributed.ParallelEnv().nranks local_rank = paddle.distributed.ParallelEnv().local_rank if nranks > 1: # Initialize parallel environment if not done. if not paddle.distributed.parallel.parallel_helper._is_parallel_ctx_initialized( ): paddle.distributed.init_parallel_env() batch_sampler = paddle.io.DistributedBatchSampler(eval_dataset, batch_size=1, shuffle=False, drop_last=False) loader = paddle.io.DataLoader( eval_dataset, batch_sampler=batch_sampler, num_workers=num_workers, return_list=True, ) total_iters = len(loader) intersect_area_all = 0 pred_area_all = 0 label_area_all = 0 if print_detail: logger.info( "Start evaluating (total_samples={}, total_iters={})...".format( len(eval_dataset), total_iters)) progbar_val = progbar.Progbar(target=total_iters, verbose=1) reader_cost_averager = TimeAverager() batch_cost_averager = TimeAverager() batch_start = time.time() with paddle.no_grad(): for iter, (im, label) in enumerate(loader): reader_cost_averager.record(time.time() - batch_start) label = label.astype('int64') ori_shape = label.shape[-2:] if aug_eval: pred = infer.aug_inference( model, im, ori_shape=ori_shape, transforms=eval_dataset.transforms.transforms, scales=scales, flip_horizontal=flip_horizontal, flip_vertical=flip_vertical, is_slide=is_slide, stride=stride, crop_size=crop_size) else: pred = infer.inference( model, im, ori_shape=ori_shape, transforms=eval_dataset.transforms.transforms, is_slide=is_slide, stride=stride, crop_size=crop_size) intersect_area, pred_area, label_area = metrics.calculate_area( pred, label, eval_dataset.num_classes, ignore_index=eval_dataset.ignore_index) # Gather from all ranks if nranks > 1: intersect_area_list = [] pred_area_list = [] label_area_list = [] paddle.distributed.all_gather(intersect_area_list, intersect_area) paddle.distributed.all_gather(pred_area_list, pred_area) paddle.distributed.all_gather(label_area_list, label_area) # Some image has been evaluated and should be eliminated in last iter if (iter + 1) * nranks > len(eval_dataset): valid = len(eval_dataset) - iter * nranks intersect_area_list = intersect_area_list[:valid] pred_area_list = pred_area_list[:valid] label_area_list = label_area_list[:valid] for i in range(len(intersect_area_list)): intersect_area_all = intersect_area_all + intersect_area_list[ i] pred_area_all = pred_area_all + pred_area_list[i] label_area_all = label_area_all + label_area_list[i] else: intersect_area_all = intersect_area_all + intersect_area pred_area_all = pred_area_all + pred_area label_area_all = label_area_all + label_area batch_cost_averager.record(time.time() - batch_start, num_samples=len(label)) batch_cost = batch_cost_averager.get_average() reader_cost = reader_cost_averager.get_average() if local_rank == 0 and print_detail: progbar_val.update(iter + 1, [('batch_cost', batch_cost), ('reader cost', reader_cost)]) reader_cost_averager.reset() batch_cost_averager.reset() batch_start = time.time() class_iou, miou = metrics.mean_iou(intersect_area_all, pred_area_all, label_area_all) class_acc, acc = metrics.accuracy(intersect_area_all, pred_area_all) kappa = metrics.kappa(intersect_area_all, pred_area_all, label_area_all) if print_detail: logger.info( "[EVAL] #Images={} mIoU={:.4f} Acc={:.4f} Kappa={:.4f} ".format( len(eval_dataset), miou, acc, kappa)) logger.info("[EVAL] Class IoU: \n" + str(np.round(class_iou, 4))) logger.info("[EVAL] Class Acc: \n" + str(np.round(class_acc, 4))) return miou, acc
def predict(model, model_path, transforms, image_list, image_dir=None, save_dir='output', aug_pred=False, scales=1.0, flip_horizontal=True, flip_vertical=False, is_slide=False, stride=None, crop_size=None, custom_color=None): """ predict and visualize the image_list. Args: model (nn.Layer): Used to predict for input image. model_path (str): The path of pretrained model. transforms (transform.Compose): Preprocess for input image. image_list (list): A list of image path to be predicted. image_dir (str, optional): The root directory of the images predicted. Default: None. save_dir (str, optional): The directory to save the visualized results. Default: 'output'. aug_pred (bool, optional): Whether to use mulit-scales and flip augment for predition. Default: False. scales (list|float, optional): Scales for augment. It is valid when `aug_pred` is True. Default: 1.0. flip_horizontal (bool, optional): Whether to use flip horizontally augment. It is valid when `aug_pred` is True. Default: True. flip_vertical (bool, optional): Whether to use flip vertically augment. It is valid when `aug_pred` is True. Default: False. is_slide (bool, optional): Whether to predict by sliding window. Default: False. stride (tuple|list, optional): The stride of sliding window, the first is width and the second is height. It should be provided when `is_slide` is True. crop_size (tuple|list, optional): The crop size of sliding window, the first is width and the second is height. It should be provided when `is_slide` is True. custom_color (list, optional): Save images with a custom color map. Default: None, use paddleseg's default color map. """ utils.utils.load_entire_model(model, model_path) model.eval() nranks = paddle.distributed.get_world_size() local_rank = paddle.distributed.get_rank() if nranks > 1: img_lists = partition_list(image_list, nranks) else: img_lists = [image_list] added_saved_dir = os.path.join(save_dir, 'added_prediction') pred_saved_dir = os.path.join(save_dir, 'pseudo_color_prediction') logger.info("Start to predict...") progbar_pred = progbar.Progbar(target=len(img_lists[0]), verbose=1) color_map = visualize.get_color_map_list(256, custom_color=custom_color) with paddle.no_grad(): for i, im_path in enumerate(img_lists[local_rank]): data = preprocess(im_path, transforms) if aug_pred: pred, _ = infer.aug_inference(model, data['img'], trans_info=data['trans_info'], scales=scales, flip_horizontal=flip_horizontal, flip_vertical=flip_vertical, is_slide=is_slide, stride=stride, crop_size=crop_size) else: pred, _ = infer.inference(model, data['img'], trans_info=data['trans_info'], is_slide=is_slide, stride=stride, crop_size=crop_size) pred = paddle.squeeze(pred) pred = pred.numpy().astype('uint8') # get the saved name if image_dir is not None: im_file = im_path.replace(image_dir, '') else: im_file = os.path.basename(im_path) if im_file[0] == '/' or im_file[0] == '\\': im_file = im_file[1:] # save added image added_image = utils.visualize.visualize(im_path, pred, color_map, weight=0.6) added_image_path = os.path.join(added_saved_dir, im_file) mkdir(added_image_path) cv2.imwrite(added_image_path, added_image) # save pseudo color prediction pred_mask = utils.visualize.get_pseudo_color_map(pred, color_map) pred_saved_path = os.path.join( pred_saved_dir, os.path.splitext(im_file)[0] + ".png") mkdir(pred_saved_path) pred_mask.save(pred_saved_path) progbar_pred.update(i + 1)
def evaluate(model, eval_dataset, num_workers=0, print_detail=True, save_img=True): """ Launch evalution. Args: model(nn.Layer): A sementic segmentation model. eval_dataset (paddle.io.Dataset): Used to read and process validation datasets. num_workers (int, optional): Num workers for data loader. Default: 0. print_detail (bool, optional): Whether to print detailed information about the evaluation process. Default: True. Returns: float: The mIoU of validation datasets. float: The accuracy of validation datasets. """ logger.info('Validating') evaluator = Eval(eval_dataset.NUM_CLASSES) evaluator.reset() model.eval() nranks = paddle.distributed.ParallelEnv().nranks local_rank = paddle.distributed.ParallelEnv().local_rank if nranks > 1: # Initialize parallel environment if not done. if not paddle.distributed.parallel.parallel_helper._is_parallel_ctx_initialized( ): paddle.distributed.init_parallel_env() batch_sampler = paddle.io.DistributedBatchSampler( eval_dataset, batch_size=1, shuffle=False, drop_last=True) loader = paddle.io.DataLoader( eval_dataset, batch_sampler=batch_sampler, num_workers=num_workers, return_list=True, ) progbar_val = progbar.Progbar( target=len(loader), verbose=0 if nranks < 2 else 2) reader_cost_averager = TimeAverager() batch_cost_averager = TimeAverager() batch_start = time.time() with paddle.no_grad(): for idx, (x, y, _, item) in enumerate(loader): reader_cost_averager.record(time.time() - batch_start) # Forward y = y.astype('int64') pred = model(x) # 1, c, h, w if len(pred) > 1: pred = pred[0] # Convert to numpy label = y.squeeze(axis=1).numpy() # argpred = np.argmax(pred.numpy(), axis=1) # 1, 1, H, W if save_img: save_imgs(argpred, item, './output/') # Add to evaluator evaluator.add_batch(label, argpred) batch_cost_averager.record( time.time() - batch_start, num_samples=len(label)) batch_cost = batch_cost_averager.get_average() reader_cost = reader_cost_averager.get_average() if local_rank == 0 and print_detail and idx % 10 == 0: progbar_val.update(idx + 1, [('batch_cost', batch_cost), ('reader cost', reader_cost)]) reader_cost_averager.reset() batch_cost_averager.reset() batch_start = time.time() PA = evaluator.pixel_accuracy() MPA = evaluator.mean_pixel_accuracy() MIoU = evaluator.mean_iou() FWIoU = evaluator.fwiou() PC = evaluator.mean_precision() logger.info( 'PA1:{:.3f}, MPA1:{:.3f}, MIoU1:{:.3f}, FWIoU1:{:.3f}, PC:{:.3f}'. format(PA, MPA, MIoU, FWIoU, PC)) return PA, MPA, MIoU, FWIoU
def predict(model, model_path, image_list, transforms, thing_list, label_divisor, stuff_area, ignore_index, image_dir=None, save_dir='output', threshold=0.1, nms_kernel=7, top_k=200): """ predict and visualize the image_list. Args: model (nn.Layer): Used to predict for input image. model_path (str): The path of pretrained model. image_list (list): A list of image path to be predicted. transforms (transform.Compose): Preprocess for input image. thing_list (list): A List of thing class id. label_divisor (int): An Integer, used to convert panoptic id = semantic id * label_divisor + instance_id. stuff_area (int): An Integer, remove stuff whose area is less tan stuff_area. ignore_index (int): Specifies a value that is ignored. image_dir (str, optional): The root directory of the images predicted. Default: None. save_dir (str, optional): The directory to save the visualized results. Default: 'output'. threshold(float, optional): Threshold applied to center heatmap score. Defalut: 0.1. nms_kernel(int, optional): NMS max pooling kernel size. Default: 7. top_k(int, optional): Top k centers to keep. Default: 200. """ paddleseg.utils.utils.load_entire_model(model, model_path) model.eval() nranks = paddle.distributed.get_world_size() local_rank = paddle.distributed.get_rank() if nranks > 1: img_lists = partition_list(image_list, nranks) else: img_lists = [image_list] semantic_save_dir = os.path.join(save_dir, 'semantic') instance_save_dir = os.path.join(save_dir, 'instance') panoptic_save_dir = os.path.join(save_dir, 'panoptic') colormap = utils.cityscape_colormap() logger.info("Start to predict...") progbar_pred = progbar.Progbar(target=len(img_lists[0]), verbose=1) with paddle.no_grad(): for i, im_path in enumerate(img_lists[local_rank]): ori_im = cv2.imread(im_path) ori_shape = ori_im.shape[:2] im, _ = transforms(ori_im) im = im[np.newaxis, ...] im = paddle.to_tensor(im) semantic, semantic_softmax, instance, panoptic, ctr_hmp = infer.inference( model=model, im=im, transforms=transforms.transforms, thing_list=thing_list, label_divisor=label_divisor, stuff_area=stuff_area, ignore_index=ignore_index, threshold=threshold, nms_kernel=nms_kernel, top_k=top_k, ori_shape=ori_shape) semantic = semantic.squeeze().numpy() instance = instance.squeeze().numpy() panoptic = panoptic.squeeze().numpy() im_file = get_save_name(im_path, image_dir) # visual semantic segmentation results save_path = os.path.join(semantic_save_dir, im_file) mkdir(save_path) utils.visualize_semantic(semantic, save_path=save_path, colormap=colormap) # Save added image for semantic segmentation results save_path_ = add_info_to_save_path(save_path, 'add') utils.visualize_semantic(semantic, save_path=save_path_, colormap=colormap, image=ori_im) # panoptic to semantic ins_mask = panoptic > label_divisor pan_to_sem = panoptic.copy() pan_to_sem[ins_mask] = pan_to_sem[ins_mask] // label_divisor save_path_ = add_info_to_save_path(save_path, 'panoptic_to_semantic') utils.visualize_semantic(pan_to_sem, save_path=save_path_, colormap=colormap) save_path_ = add_info_to_save_path(save_path, 'panoptic_to_semantic_added') utils.visualize_semantic(pan_to_sem, save_path=save_path_, colormap=colormap, image=ori_im) # vusual instance segmentation results pan_to_ins = panoptic.copy() ins_mask = pan_to_ins > label_divisor pan_to_ins[~ins_mask] = 0 save_path = os.path.join(instance_save_dir, im_file) mkdir(save_path) utils.visualize_instance(pan_to_ins, save_path=save_path) # Save added image for instance segmentation results save_path_ = add_info_to_save_path(save_path, 'added') utils.visualize_instance(pan_to_ins, save_path=save_path_, image=ori_im) # visual panoptic segmentation results save_path = os.path.join(panoptic_save_dir, im_file) mkdir(save_path) utils.visualize_panoptic(panoptic, save_path=save_path, label_divisor=label_divisor, colormap=colormap, ignore_index=ignore_index) # Save added image for panoptic segmentation results save_path_ = add_info_to_save_path(save_path, 'added') utils.visualize_panoptic(panoptic, save_path=save_path_, label_divisor=label_divisor, colormap=colormap, image=ori_im, ignore_index=ignore_index) progbar_pred.update(i + 1)
def predict(model, model_path, transforms, image_list, image_dir=None, save_dir='output', aug_pred=False, scales=1.0, flip_horizontal=True, flip_vertical=False, is_slide=False, stride=None, crop_size=None): """ predict and visualize the image_list. Args: model (nn.Layer): Used to predict for input image. model_path (str): The path of pretrained model. transforms (transform.Compose): Preprocess for input image. image_list (list): A list of images to be predicted. image_dir (str): The directory of the images to be predicted. Default: None. save_dir (str): The directory to save the visualized results. Default: 'output'. """ para_state_dict = paddle.load(model_path) model.set_dict(para_state_dict) model.eval() added_saved_dir = os.path.join(save_dir, 'added_prediction') pred_saved_dir = os.path.join(save_dir, 'pseudo_color_prediction') logger.info("Start to predict...") progbar_pred = progbar.Progbar(target=len(image_list), verbose=1) for i, im_path in enumerate(image_list): im = cv2.imread(im_path) ori_shape = im.shape[:2] im, _ = transforms(im) im = im[np.newaxis, ...] im = paddle.to_tensor(im) if aug_pred: pred = infer.aug_inference(model, im, ori_shape=ori_shape, transforms=transforms.transforms, scales=scales, flip_horizontal=flip_horizontal, flip_vertical=flip_vertical, is_slide=is_slide, stride=stride, crop_size=crop_size) else: pred = infer.inference(model, im, ori_shape=ori_shape, transforms=transforms.transforms, is_slide=is_slide, stride=stride, crop_size=crop_size) pred = paddle.squeeze(pred) pred = pred.numpy().astype('uint8') # get the saved name if image_dir is not None: im_file = im_path.replace(image_dir, '') else: im_file = os.path.basename(im_path) if im_file[0] == '/': im_file = im_file[1:] # save added image added_image = utils.visualize.visualize(im_path, pred, weight=0.6) added_image_path = os.path.join(added_saved_dir, im_file) mkdir(added_image_path) cv2.imwrite(added_image_path, added_image) # save pseudo color prediction pred_mask = utils.visualize.get_pseudo_color_map(pred) pred_saved_path = os.path.join(pred_saved_dir, im_file.rsplit(".")[0] + ".png") mkdir(pred_saved_path) pred_mask.save(pred_saved_path) # pred_im = utils.visualize(im_path, pred, weight=0.0) # pred_saved_path = os.path.join(pred_saved_dir, im_file) # mkdir(pred_saved_path) # cv2.imwrite(pred_saved_path, pred_im) progbar_pred.update(i + 1)
def predict(model, model_path, val_dataset, image_list, image_dir=None, save_dir='output', custom_color=None): """ predict and visualize the image_list. Args: model (nn.Layer): Used to predict for input image. model_path (str): The path of pretrained model. val_dataset (paddle.io.Dataset): Used to read validation information. image_list (list): A list of image path to be predicted. image_dir (str, optional): The root directory of the images predicted. Default: None. save_dir (str, optional): The directory to save the visualized results. Default: 'output'. custom_color (list, optional): Save images with a custom color map. Default: None, use paddleseg's default color map. """ utils.utils.load_entire_model(model, model_path) model.eval() nranks = paddle.distributed.get_world_size() local_rank = paddle.distributed.get_rank() if nranks > 1: img_lists = partition_list(image_list, nranks) else: img_lists = [image_list] added_saved_dir = os.path.join(save_dir, 'added_prediction') pred_saved_dir = os.path.join(save_dir, 'pseudo_color_prediction') transforms = val_dataset.transforms cut_height = val_dataset.cut_height postprocessor = tusimple_processor.TusimpleProcessor( num_classes=val_dataset.num_classes, cut_height=cut_height, save_dir=save_dir) logger.info("Start to predict...") progbar_pred = progbar.Progbar(target=len(img_lists[0]), verbose=1) color_map = visualize.get_color_map_list(256, custom_color=custom_color) with paddle.no_grad(): for i, im_path in enumerate(img_lists[local_rank]): im = cv2.imread(im_path) ori_shape = im.shape[:2] im, _ = transforms(im) im = im[np.newaxis, ...] im = paddle.to_tensor(im) pred = infer.inference(model, im, ori_shape=ori_shape, transforms=transforms.transforms) # get lane points postprocessor.predict(pred[1], im_path) pred = paddle.squeeze(pred[0]) pred = pred.numpy().astype('uint8') # get the saved name if image_dir is not None: im_file = im_path.replace(image_dir, '') else: im_file = os.path.basename(im_path) if im_file[0] == '/' or im_file[0] == '\\': im_file = im_file[1:] # save added image added_image = utils.visualize.visualize(im_path, pred, color_map, weight=0.6) added_image_path = os.path.join(added_saved_dir, im_file) mkdir(added_image_path) cv2.imwrite(added_image_path, added_image) # save pseudo color prediction pred_mask = utils.visualize.get_pseudo_color_map(pred, color_map) pred_saved_path = os.path.join( pred_saved_dir, os.path.splitext(im_file)[0] + ".png") mkdir(pred_saved_path) pred_mask.save(pred_saved_path) # pred_im = utils.visualize(im_path, pred, weight=0.0) # pred_saved_path = os.path.join(pred_saved_dir, im_file) # mkdir(pred_saved_path) # cv2.imwrite(pred_saved_path, pred_im) progbar_pred.update(i + 1)
def predictEnsembleThree(model, model_1, model_crop, model_path, model_path_1, model_path_crop, transforms, transforms_crop, image_list, image_dir=None, save_dir='output', aug_pred=False, scales=1.0, flip_horizontal=True, flip_vertical=False, is_slide=False, stride=None, crop_size=None): """ predict and visualize the image_list. Args: model (nn.Layer): Used to predict for input image. model_path (str): The path of pretrained model. transforms (transform.Compose): Preprocess for input image. image_list (list): A list of image path to be predicted. image_dir (str, optional): The root directory of the images predicted. Default: None. save_dir (str, optional): The directory to save the visualized results. Default: 'output'. aug_pred (bool, optional): Whether to use mulit-scales and flip augment for predition. Default: False. scales (list|float, optional): Scales for augment. It is valid when `aug_pred` is True. Default: 1.0. flip_horizontal (bool, optional): Whether to use flip horizontally augment. It is valid when `aug_pred` is True. Default: True. flip_vertical (bool, optional): Whether to use flip vertically augment. It is valid when `aug_pred` is True. Default: False. is_slide (bool, optional): Whether to predict by sliding window. Default: False. stride (tuple|list, optional): The stride of sliding window, the first is width and the second is height. It should be provided when `is_slide` is True. crop_size (tuple|list, optional): The crop size of sliding window, the first is width and the second is height. It should be provided when `is_slide` is True. """ utils.utils.load_entire_model(model, model_path) model.eval() utils.utils.load_entire_model(model_1, model_path_1) model_1.eval() utils.utils.load_entire_model(model_crop, model_path_crop) model_crop.eval() nranks = paddle.distributed.get_world_size() local_rank = paddle.distributed.get_rank() if nranks > 1: img_lists = partition_list(image_list, nranks) else: img_lists = [image_list] added_saved_dir = os.path.join(save_dir, 'added_prediction') pred_saved_dir = os.path.join(save_dir, 'pseudo_color_prediction') logger.info("Start to predict...") progbar_pred = progbar.Progbar(target=len(img_lists[0]), verbose=1) with paddle.no_grad(): for i, im_path in enumerate(img_lists[local_rank]): im_origin = cv2.imread(im_path) ori_shape = im_origin.shape[:2] im, _ = transforms(im_origin) im = im[np.newaxis, ...] im = paddle.to_tensor(im) ims, _ = transforms_crop(im_origin) im1 = ims[:, 540:540 + 720, 320:320 + 1280] im2 = ims[:, 540:540 + 720, 960:960 + 1280] im3 = ims[:, 540:540 + 720, 1600:1600 + 1280] im1 = im1[np.newaxis, ...] im1 = paddle.to_tensor(im1) im2 = im2[np.newaxis, ...] im2 = paddle.to_tensor(im2) im3 = im3[np.newaxis, ...] im3 = paddle.to_tensor(im3) ims_ = [im1, im2, im3] if aug_pred: pred = infer_ensemble.aug_inference( model, model_1, im, ori_shape=ori_shape, transforms=transforms.transforms, scales=scales, flip_horizontal=flip_horizontal, flip_vertical=flip_vertical, is_slide=is_slide, stride=stride, crop_size=crop_size) else: pred = infer_ensemble.inference( model, model_1, im, ori_shape=ori_shape, transforms=transforms.transforms, is_slide=is_slide, stride=stride, crop_size=crop_size) preds = [] for ii in range(3): im_ = ims_[ii] if aug_pred: pred_crop = infer_crop.aug_inference( model, im_, ori_shape=ori_shape, transforms=transforms.transforms, scales=scales, flip_horizontal=flip_horizontal, flip_vertical=flip_vertical, is_slide=is_slide, stride=stride, crop_size=crop_size) else: pred_crop = infer_crop.inference( model, im_, ori_shape=ori_shape, transforms=transforms.transforms, is_slide=is_slide, stride=stride, crop_size=crop_size) preds.append(pred_crop) left_ensem = (preds[0][:, :, :, 640:1280] + preds[1][:, :, :, 0:640]) / 2 right_ensem = (preds[1][:, :, :, 640:1280] + preds[2][:, :, :, 0:640]) / 2 pred_ensem = paddle.concat([ preds[0][:, :, :, 0:640], left_ensem, right_ensem, preds[2][:, :, :, 640:1280] ], axis=3) logit = F.interpolate(pred_ensem, (432, 768), mode='bilinear') pred_logit = pred.clone() pred_logit[:, :, 324:756, 576:1344] = logit pred = pred + pred_logit pred = F.interpolate(pred, ori_shape, mode='bilinear') pred = paddle.argmax(pred, axis=1, keepdim=True, dtype='int32') pred = paddle.squeeze(pred) pred = pred.numpy().astype('uint8') # get the saved name if image_dir is not None: im_file = im_path.replace(image_dir, '') else: im_file = os.path.basename(im_path) if im_file[0] == '/': im_file = im_file[1:] # save added image added_image = utils.visualize.visualize(im_path, pred, weight=0.6) added_image_path = os.path.join(added_saved_dir, im_file) mkdir(added_image_path) cv2.imwrite(added_image_path, added_image) # save pseudo color prediction pred_mask = utils.visualize.get_pseudo_color_map(pred) pred_saved_path = os.path.join(pred_saved_dir, im_file.rsplit(".")[0] + ".png") mkdir(pred_saved_path) pred_mask.save(pred_saved_path) # pred_im = utils.visualize(im_path, pred, weight=0.0) # pred_saved_path = os.path.join(pred_saved_dir, im_file) # mkdir(pred_saved_path) # cv2.imwrite(pred_saved_path, pred_im) progbar_pred.update(i + 1)
def evaluate(model, eval_dataset, num_workers=0, is_view=False, save_dir='output', print_detail=True): """ Launch evalution. Args: model(nn.Layer): A sementic segmentation model. eval_dataset (paddle.io.Dataset): Used to read and process validation datasets. num_workers (int, optional): Num workers for data loader. Default: 0. is_view (bool, optional): Whether to visualize results. Default: False. save_dir (str, optional): The directory to save the json or visualized results. Default: 'output'. print_detail (bool, optional): Whether to print detailed information about the evaluation process. Default: True. Returns: float: The acc of validation datasets. float: The fp of validation datasets. float: The fn of validation datasets. """ model.eval() local_rank = paddle.distributed.ParallelEnv().local_rank loader = paddle.io.DataLoader( eval_dataset, batch_size=4, drop_last=False, num_workers=num_workers, return_list=True, ) postprocessor = tusimple_processor.TusimpleProcessor( num_classes=eval_dataset.num_classes, cut_height=eval_dataset.cut_height, test_gt_json=eval_dataset.test_gt_json, save_dir=save_dir, ) total_iters = len(loader) if print_detail: logger.info( "Start evaluating (total_samples: {}, total_iters: {})...".format( len(eval_dataset), total_iters)) progbar_val = progbar.Progbar(target=total_iters, verbose=1) reader_cost_averager = TimeAverager() batch_cost_averager = TimeAverager() batch_start = time.time() with paddle.no_grad(): for iter, (im, label, im_path) in enumerate(loader): reader_cost_averager.record(time.time() - batch_start) label = label.astype('int64') ori_shape = None time_start = time.time() pred = infer.inference( model, im, ori_shape=ori_shape, transforms=eval_dataset.transforms.transforms) time_end = time.time() postprocessor.dump_data_to_json(pred[1], im_path, run_time=time_end - time_start, is_dump_json=True, is_view=is_view) batch_cost_averager.record(time.time() - batch_start, num_samples=len(label)) batch_cost = batch_cost_averager.get_average() reader_cost = reader_cost_averager.get_average() if local_rank == 0 and print_detail: progbar_val.update(iter + 1, [('batch_cost', batch_cost), ('reader cost', reader_cost)]) reader_cost_averager.reset() batch_cost_averager.reset() batch_start = time.time() acc, fp, fn, eval_result = postprocessor.bench_one_submit(local_rank) if print_detail: logger.info(eval_result) return acc, fp, fn
def evaluate(model, eval_dataset, aug_eval=False, scales=1.0, flip_horizontal=True, flip_vertical=False, is_slide=False, stride=None, crop_size=None, num_workers=0): model.eval() nranks = paddle.distributed.ParallelEnv().nranks local_rank = paddle.distributed.ParallelEnv().local_rank if nranks > 1: # Initialize parallel environment if not done. if not paddle.distributed.parallel.parallel_helper._is_parallel_ctx_initialized( ): paddle.distributed.init_parallel_env() batch_sampler = paddle.io.DistributedBatchSampler( eval_dataset, batch_size=1, shuffle=False, drop_last=False) loader = paddle.io.DataLoader( eval_dataset, batch_sampler=batch_sampler, num_workers=num_workers, return_list=True, ) total_iters = len(loader) intersect_area_all = 0 pred_area_all = 0 label_area_all = 0 logger.info("Start evaluating (total_samples={}, total_iters={})...".format( len(eval_dataset), total_iters)) progbar_val = progbar.Progbar(target=total_iters, verbose=1) timer = Timer() for iter, (im, label) in enumerate(loader): reader_cost = timer.elapsed_time() label = label.astype('int64') ori_shape = label.shape[-2:] if aug_eval: pred = infer.aug_inference( model, im, ori_shape=ori_shape, transforms=eval_dataset.transforms.transforms, scales=scales, flip_horizontal=flip_horizontal, flip_vertical=flip_vertical, is_slide=is_slide, stride=stride, crop_size=crop_size) else: pred = infer.inference( model, im, ori_shape=ori_shape, transforms=eval_dataset.transforms.transforms, is_slide=is_slide, stride=stride, crop_size=crop_size) intersect_area, pred_area, label_area = metrics.calculate_area( pred, label, eval_dataset.num_classes, ignore_index=eval_dataset.ignore_index) # Gather from all ranks if nranks > 1: intersect_area_list = [] pred_area_list = [] label_area_list = [] paddle.distributed.all_gather(intersect_area_list, intersect_area) paddle.distributed.all_gather(pred_area_list, pred_area) paddle.distributed.all_gather(label_area_list, label_area) # Some image has been evaluated and should be eliminated in last iter if (iter + 1) * nranks > len(eval_dataset): valid = len(eval_dataset) - iter * nranks intersect_area_list = intersect_area_list[:valid] pred_area_list = pred_area_list[:valid] label_area_list = label_area_list[:valid] for i in range(len(intersect_area_list)): intersect_area_all = intersect_area_all + intersect_area_list[i] pred_area_all = pred_area_all + pred_area_list[i] label_area_all = label_area_all + label_area_list[i] else: intersect_area_all = intersect_area_all + intersect_area pred_area_all = pred_area_all + pred_area label_area_all = label_area_all + label_area batch_cost = timer.elapsed_time() timer.restart() if local_rank == 0: progbar_val.update(iter + 1, [('batch_cost', batch_cost), ('reader cost', reader_cost)]) class_iou, miou = metrics.mean_iou(intersect_area_all, pred_area_all, label_area_all) class_acc, acc = metrics.accuracy(intersect_area_all, pred_area_all) kappa = metrics.kappa(intersect_area_all, pred_area_all, label_area_all) logger.info("[EVAL] #Images={} mIoU={:.4f} Acc={:.4f} Kappa={:.4f} ".format( len(eval_dataset), miou, acc, kappa)) logger.info("[EVAL] Class IoU: \n" + str(np.round(class_iou, 4))) logger.info("[EVAL] Class Acc: \n" + str(np.round(class_acc, 4))) return miou, acc
def evaluate(model, eval_dataset, threshold=0.1, nms_kernel=7, top_k=200, num_workers=0, print_detail=True): """ Launch evaluation. Args: model(nn.Layer): A sementic segmentation model. eval_dataset (paddle.io.Dataset): Used to read and process validation datasets. threshold (float, optional): Threshold applied to center heatmap score. Defalut: 0.1. nms_kernel (int, optional): NMS max pooling kernel size. Default: 7. top_k (int, optional): Top k centers to keep. Default: 200. num_workers (int, optional): Num workers for data loader. Default: 0. print_detail (bool, optional): Whether to print detailed information about the evaluation process. Default: True. Returns: dict: Panoptic evaluation results which includes PQ, RQ, SQ for all, each class, Things and stuff. dict: Semantic evaluation results which includes mIoU, fwIoU, mACC and pACC. dict: Instance evaluation results which includes mAP and mAP50, and also AP and AP50 for each class. """ model.eval() nranks = paddle.distributed.ParallelEnv().nranks local_rank = paddle.distributed.ParallelEnv().local_rank if nranks > 1: # Initialize parallel environment if not done. if not paddle.distributed.parallel.parallel_helper._is_parallel_ctx_initialized( ): paddle.distributed.init_parallel_env() batch_sampler = paddle.io.DistributedBatchSampler(eval_dataset, batch_size=1, shuffle=False, drop_last=False) loader = paddle.io.DataLoader( eval_dataset, batch_sampler=batch_sampler, num_workers=num_workers, return_list=True, ) total_iters = len(loader) semantic_metric = SemanticEvaluator(eval_dataset.num_classes, ignore_index=eval_dataset.ignore_index) instance_metric_AP50 = InstanceEvaluator( eval_dataset.num_classes, overlaps=0.5, thing_list=eval_dataset.thing_list) instance_metric_AP = InstanceEvaluator(eval_dataset.num_classes, overlaps=list( np.arange(0.5, 1.0, 0.05)), thing_list=eval_dataset.thing_list) panoptic_metric = PanopticEvaluator( num_classes=eval_dataset.num_classes, thing_list=eval_dataset.thing_list, ignore_index=eval_dataset.ignore_index, label_divisor=eval_dataset.label_divisor) if print_detail: logger.info( "Start evaluating (total_samples={}, total_iters={})...".format( len(eval_dataset), total_iters)) progbar_val = progbar.Progbar(target=total_iters, verbose=1) reader_cost_averager = TimeAverager() batch_cost_averager = TimeAverager() batch_start = time.time() with paddle.no_grad(): for iter, data in enumerate(loader): reader_cost_averager.record(time.time() - batch_start) im = data[0] raw_semantic_label = data[1] # raw semantic label. raw_instance_label = data[2] raw_panoptic_label = data[3] ori_shape = raw_semantic_label.shape[-2:] semantic, semantic_softmax, instance, panoptic, ctr_hmp = infer.inference( model=model, im=im, transforms=eval_dataset.transforms.transforms, thing_list=eval_dataset.thing_list, label_divisor=eval_dataset.label_divisor, stuff_area=eval_dataset.stuff_area, ignore_index=eval_dataset.ignore_index, threshold=threshold, nms_kernel=nms_kernel, top_k=top_k, ori_shape=ori_shape) semantic = semantic.squeeze().numpy() semantic_softmax = semantic_softmax.squeeze().numpy() instance = instance.squeeze().numpy() panoptic = panoptic.squeeze().numpy() ctr_hmp = ctr_hmp.squeeze().numpy() raw_semantic_label = raw_semantic_label.squeeze().numpy() raw_instance_label = raw_instance_label.squeeze().numpy() raw_panoptic_label = raw_panoptic_label.squeeze().numpy() # update metric for semantic, instance, panoptic semantic_metric.update(semantic, raw_semantic_label) gts = instance_metric_AP.convert_gt_map(raw_semantic_label, raw_instance_label) # print([i[0] for i in gts]) preds = instance_metric_AP.convert_pred_map( semantic_softmax, panoptic) # print([(i[0], i[1]) for i in preds ]) ignore_mask = raw_semantic_label == eval_dataset.ignore_index instance_metric_AP.update(preds, gts, ignore_mask=ignore_mask) instance_metric_AP50.update(preds, gts, ignore_mask=ignore_mask) panoptic_metric.update(panoptic, raw_panoptic_label) batch_cost_averager.record(time.time() - batch_start, num_samples=len(im)) batch_cost = batch_cost_averager.get_average() reader_cost = reader_cost_averager.get_average() if local_rank == 0: progbar_val.update(iter + 1, [('batch_cost', batch_cost), ('reader cost', reader_cost)]) reader_cost_averager.reset() batch_cost_averager.reset() batch_start = time.time() semantic_results = semantic_metric.evaluate() panoptic_results = panoptic_metric.evaluate() instance_results = OrderedDict() ins_ap = instance_metric_AP.evaluate() ins_ap50 = instance_metric_AP50.evaluate() instance_results['ins_seg'] = OrderedDict() instance_results['ins_seg']['mAP'] = ins_ap['ins_seg']['mAP'] instance_results['ins_seg']['AP'] = ins_ap['ins_seg']['AP'] instance_results['ins_seg']['mAP50'] = ins_ap50['ins_seg']['mAP'] instance_results['ins_seg']['AP50'] = ins_ap50['ins_seg']['AP'] if print_detail: logger.info(panoptic_results) print() logger.info(semantic_results) print() logger.info(instance_results) print() pq = panoptic_results['pan_seg']['All']['pq'] miou = semantic_results['sem_seg']['mIoU'] map = instance_results['ins_seg']['mAP'] map50 = instance_results['ins_seg']['mAP50'] logger.info( "PQ: {:.4f}, mIoU: {:.4f}, mAP: {:.4f}, mAP50: {:.4f}".format( pq, miou, map, map50)) return panoptic_results, semantic_results, instance_results