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