def init_detector(config, checkpoint=None, device='cuda:0'):
"""Initialize a detector from config file.
Args:
config (str or :obj:`mmcv.Config`): Config file path or the config
object.
checkpoint (str, optional): Checkpoint path. If left as None, the model
will not load any weights.
Returns:
nn.Module: The constructed detector.
"""
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
'but got {}'.format(type(config)))
config.model.pretrained = None
model = build_detector(config.model, test_cfg=config.test_cfg)
if checkpoint is not None:
checkpoint = load_checkpoint(model, checkpoint)
if 'CLASSES' in checkpoint['meta']:
# model.CLASSES = checkpoint['meta']['CLASSES']
model.CLASSES = get_classes('own')
else:
warnings.warn('Class names are not saved in the checkpoint\'s '
'meta data, use COCO classes by default.')
model.CLASSES = get_classes('own')
model.cfg = config # save the config in the model for convenience
model.to(device)
model.eval()
return model
def init_detector(config, checkpoint=None, device='cuda:0'):
"""Initialize a detector from config file.
Args:
config (str or :obj:`mmcv.Config`): Config file path or the config
object.
checkpoint (str, optional): Checkpoint path. If left as None, the model
will not load any weights.
Returns:
nn.Module: The constructed detector.
"""
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
f'but got {type(config)}')
config.model.pretrained = None
model = build_detector(config.model, test_cfg=config.test_cfg)
if checkpoint is not None:
map_loc = 'cpu' if device == 'cpu' else None
checkpoint = load_checkpoint(model, checkpoint, map_location=map_loc)
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
warnings.simplefilter('once')
warnings.warn('Class names are not saved in the checkpoint\'s '
'meta data, use COCO classes by default.')
model.CLASSES = get_classes('coco')
# model = MMDataParallel(model, device_ids=[0]) # 직접 추가한 코드, inference time 체크할 때 사용
model.cfg = config # save the config in the model for convenience
model.to(device)
model.eval()
return model
def show_result(self,
data,
result,
img_norm_cfg,
frame_index,
show=False,
dataset=None,
score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32) # category_id -1
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
show=show,
class_names=class_names,
wait_time=1,
out_file="output/polyp/" +
str("{:04d}".format(frame_index)) + ".png",
score_thr=score_thr)
def init_detector(config, checkpoint=None, device='cuda:0'):
"""Initialize a detector from config file.
Args:
config (str or :obj:`mmcv.Config`): Config file path or the config
object.
checkpoint (str, optional): Checkpoint path. If left as None, the model
will not load any weights.
Returns:
nn.Module: The constructed detector.
"""
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
f'but got {type(config)}')
config.model.pretrained = None
model = build_detector(config.model, test_cfg=config.test_cfg)
if checkpoint is not None:
map_loc = 'cpu' if device == 'cpu' else None
checkpoint = load_checkpoint(model, checkpoint, map_location=map_loc)
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = get_classes('coco')
model.eval()
return model
def show_result(img, result, dataset='coco', score_thr=0.3, out_file=None, font_scale=0.5):
img = mmcv.imread(img)
class_names = get_classes(dataset)
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(
0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img[mask] = img[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
write_bboxes_to_npy(bboxes, out_file)
mmcv.imshow_det_bboxes(
img.copy(),
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
show=out_file is None,
out_file=out_file,
font_scale=font_scale)
def vis_seg(data, result, img_norm_cfg, data_id, colors, score_thr, save_dir):
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
class_names = get_classes('tianchi')
for img, img_meta, cur_result in zip(imgs, img_metas, result):
if cur_result is None:
continue
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
seg_label = cur_result[0]
seg_label = seg_label.cpu().numpy().astype(np.uint8)
cate_label = cur_result[1]
cate_label = cate_label.cpu().numpy()
score = cur_result[2].cpu().numpy()
vis_inds = score > score_thr
seg_label = seg_label[vis_inds]
num_mask = seg_label.shape[0]
cate_label = cate_label[vis_inds]
cate_score = score[vis_inds]
mask_density = []
for idx in range(num_mask):
cur_mask = seg_label[idx, :, :]
cur_mask = mmcv.imresize(cur_mask, (w, h))
cur_mask = (cur_mask > 0.5).astype(np.int32)
mask_density.append(cur_mask.sum())
orders = np.argsort(mask_density)
seg_label = seg_label[orders]
cate_label = cate_label[orders]
cate_score = cate_score[orders]
seg_show = img_show.copy()
for idx in range(num_mask):
idx = -(idx+1)
cur_mask = seg_label[idx, :,:]
cur_mask = mmcv.imresize(cur_mask, (w, h))
cur_mask = (cur_mask > 0.5).astype(np.uint8)
if cur_mask.sum() == 0:
continue
color_mask = np.random.randint(
0, 256, (1, 3), dtype=np.uint8)
cur_mask_bool = cur_mask.astype(np.bool)
seg_show[cur_mask_bool] = img_show[cur_mask_bool] * 0.5 + color_mask * 0.5
cur_cate = cate_label[idx]
cur_score = cate_score[idx]
label_text = class_names[cur_cate]
#label_text += '|{:.02f}'.format(cur_score)
# center
center_y, center_x = ndimage.measurements.center_of_mass(cur_mask)
vis_pos = (max(int(center_x) - 10, 0), int(center_y))
cv2.putText(seg_show, label_text, vis_pos,
cv2.FONT_HERSHEY_COMPLEX, 0.3, (255, 255, 255)) # green
mmcv.imwrite(seg_show, '{}/{}.jpg'.format(save_dir, data_id))
def show_gt_result(self,
data,
bbox_gts,
label_gts,
img_norm_cfg,
mask_gts=None,
dataset=None,
image_dir=None,
show=False,
image_name=None):
bbox_gts = bbox_gts.data[0]
label_gts = label_gts.data[0]
if mask_gts:
mask_gts = mask_gts.data[0]
else:
mask_gts = []
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta, bbox_gt, label_gt, mask_gt in zip(
imgs, img_metas, bbox_gts, label_gts, mask_gts):
h, w, _ = img_meta['pad_shape']
img_show = img[:h, :w, :]
bboxes = bbox_gt.cpu().numpy()
# draw segmentation masks
if len(mask_gts) > 0:
segms = mask_gt
for i in range(segms.shape[0]):
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = segms[i, :, :].astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = label_gt.cpu().numpy() - 1
assert image_dir and image_name, 'image_dir and image_name can not be None'
if not osp.exists(image_dir):
os.mkdir(image_dir)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
text_color='white',
class_names=class_names,
score_thr=0,
show=show,
out_file=osp.join(image_dir, image_name))
def show_result(self,
data,
result,
img_norm_cfg,
dataset='coco',
score_thr=0.3):
img_tensor = data['img'][0]
#img_tensor_t = data['img_t'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
#imgs_t = tensor2imgs(img_tensor_t,**)
assert len(imgs) == len(img_metas)
if isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, list):
class_names = dataset
else:
raise TypeError('dataset must be a valid dataset name or a list'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
def initialize_model():
# Setup a checkpoint file to load
#checkpoint = '/Developer/3DObject/mymmdetection/waymococo_fasterrcnnr101train/epoch_60.pth'
#checkpoint = '/Developer/MyRepo/mymodels/mmmodels/HPCwaymococo_fasterrcnnr101train/epoch_25.pth'
device = 'cuda:0'
global model
global config
global model_dir
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
f'but got {type(config)}')
config.model.pretrained = None
config.model.train_cfg = None
config.model.roi_head.bbox_head.num_classes = len(classes)
model = build_detector(config.model, test_cfg=config.get('test_cfg'))
if model_dir is not None:
map_loc = 'cpu' if device == 'cpu' else None
checkpoint = load_checkpoint(model, model_dir, map_location=map_loc)
if 'CLASSES' in checkpoint.get('meta', {}):
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = get_classes('coco')
model.cfg = config # save the config in the model for convenience
model.to(device)
model.eval()
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_metas = data['img_meta'][0].data[0]
if 'img_raw' in data:
img_tensor = data['img_raw'][0]
norm_factor = {'mean': [0, 0, 0], 'std': [1, 1, 1], 'to_rgb': True}
filename = os.path.join(
'results',
data['img_meta'][0].data[0][0]['filename'].split('/')[-1])
else:
img_tensor = data['img'][0]
norm_factor = img_metas[0]['img_norm_cfg']
filename = None
imgs = tensor2imgs(img_tensor, **norm_factor)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
show=False,
out_file=filename)
def show_result(img,
result,
dataset,
score_thr=0.03,
wait_time=0,
show=True,
out_file=None):
"""Visualize the detection results on the image.
Args:
img (str or np.ndarray): Image filename or loaded image.
result (tuple[list] or list): The detection result, can be either
(bbox, segm) or just bbox.
class_names (list[str] or tuple[str]): A list of class names.
score_thr (float): The threshold to visualize the bboxes and masks.
wait_time (int): Value of waitKey param.
show (bool, optional): Whether to show the image with opencv or not.
out_file (str, optional): If specified, the visualization result will
be written to the out file instead of shown in a window.
Returns:
np.ndarray or None: If neither `show` nor `out_file` is specified, the
visualized image is returned, otherwise None is returned.
"""
# print("score阈值设置为%f"%score_thr)
class_names = get_classes(dataset)
assert isinstance(class_names, (tuple, list))
img = mmcv.imread(img)
img = img.copy()
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img[mask] = img[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
anno, img = mmcv.imshow_det_bboxes(img,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
show=show,
wait_time=wait_time,
out_file=out_file)
if not (show or out_file):
return anno, img
def show_result(
self,
data,
result,
img_norm_cfg,
dataset="coco",
score_thr=0.3,
):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data["img"][0]
img_metas = data["img_meta"][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)) or dataset is None:
class_names = dataset
else:
raise TypeError(
"dataset must be a valid dataset name or a sequence"
" of class names, not {}".format(type(dataset))
)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta["img_shape"]
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(
0, 256, (1, 3), dtype=np.uint8
)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = (
img_show[mask] * 0.5 + color_mask * 0.5
)
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(
img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
)
def det_bboxes(img,
bboxes,
labels,
score_thr=0,
bbox_color='green',
text_color='green',
thickness=2,
font_scale=0.5,
show=True,
win_name='',
wait_time=0,
out_file=None):
assert bboxes.ndim == 2
assert labels.ndim == 1
assert bboxes.shape[0] == labels.shape[0]
assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5
if score_thr > 0:
assert bboxes.shape[1] == 5
scores = bboxes[:, -1]
inds = scores > score_thr
bboxes = bboxes[inds, :]
labels = labels[inds]
bbox_color = mmcv.color_val(bbox_color)
text_color = mmcv.color_val(text_color)
ret_str = ''
for bbox, label in zip(bboxes, labels):
bbox_int = bbox.astype(np.int32)
left_top = (bbox_int[0], bbox_int[1])
right_bottom = (bbox_int[2], bbox_int[3])
cv2.rectangle(img,
left_top,
right_bottom,
bbox_color,
thickness=thickness)
label_text = str(label)
dataset_name = 'sign'
class_names = get_classes(dataset_name)
label_text = class_names[
label] if class_names is not None else 'cls {}'.format(label)
w = bbox_int[2] - bbox_int[0]
h = bbox_int[3] - bbox_int[1]
ss = ' ' + str(left_top[0]) + ',' + str(
left_top[1]) + ',' + str(w) + ',' + str(h)
if len(bbox) > 4:
cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - 2),
cv2.FONT_HERSHEY_COMPLEX_SMALL, font_scale, text_color)
ret_str += ss
if show:
mmcv.imshow(img, win_name, wait_time)
if out_file is not None:
mmcv.imwrite(img, out_file)
return ret_str
def show_result(self,
data,
result,
img_norm_cfg,
dataset=None,
score_thr=0.3,
outfile=None):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
# solve UnboundLocalError: local variable '_mlvl_bboxes' referenced before assignment
# h, w, _ = img_meta['img_shape']
h, w, _ = img_meta['ori_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
out_file=outfile)
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'].data
print(img_tensor.shape)
img_metas = data['img_meta'].data[0]
print(img_metas)
imgs = tensor2imgs(
img_tensor, **{
'mean': np.array([0.5, 0.5, 0.5]),
'std': np.array([255., 255., 255.]),
'to_rgb': False
})
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
print(segms)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
print('amsk shape', mask.shape)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
def init_detector(opts, device='cuda:0'):
config = mmcv.Config.fromfile(opts.config)
new_config = 'train_pipeline' in config or 'test_pipeline' in config
if new_config:
assert opts.in_scale is not None, "New config does not support default input scale"
# simulate old config
config.data.test.img_scale = 1
config.data.test.size_divisor = 32
if opts.in_scale is not None:
if 'ssd' in basename(opts.config):
# SSD
if opts.in_scale <= 0.2:
# too small leads to some issues
l = round(1920 * opts.in_scale)
config.data.test.img_scale = (l, l)
config.data.test.resize_keep_ratio = False
else:
config.data.test.img_scale = opts.in_scale
config.data.test.resize_keep_ratio = True
# My change
elif config.model.type == 'YoloV3':
#elif config.model.type == 'YoloV3' or config.model.type == 'YoloV3UA' :
config.data.test.in_scale = opts.in_scale
config.data.test.resize_keep_ratio = True
else:
config.data.test.img_scale = opts.in_scale
config.data.test.resize_keep_ratio = True
if opts.no_mask:
if 'mask_head' in config.model:
config.model['mask_head'] = None
config.model.pretrained = None
model = build_detector(config.model, test_cfg=config.test_cfg)
if opts.weights is not None:
if config.model.type == 'YoloV3':
if opts.weights.endswith(".weights"):
# Load darknet weights
# Check if the weights using are the same. '/data2/mengtial/ModelZoo/yolo/yolov3.weights'
model.load_darknet_weights(opts.weights)
else:
# Load checkpoint weights
model.load_state_dict(torch.load(opts.weights))
elif config.model.type == 'YoloV3UA':
model.load_weights(opts.weights)
else:
weights = load_checkpoint(model, opts.weights)
if 'CLASSES' in weights['meta']:
model.CLASSES = weights['meta']['CLASSES']
else:
model.CLASSES = get_classes('coco')
model.cfg = config
model.to(device)
model.eval()
return model
def init_detector(opts, device='cuda:0'):
config = mmcv.Config.fromfile(opts.config)
new_config = 'train_pipeline' in config or 'test_pipeline' in config
if new_config:
# simulate old config
if opts.in_scale is None:
print('Warning: using new config and fixing size_divisor to 32')
config.data.test.img_scale = config.test_pipeline[1]['img_scale']
else:
config.data.test.img_scale = 1
config.data.test.size_divisor = 32
if opts.in_scale is not None:
if 'ssd' in basename(opts.config):
# SSD
if opts.in_scale <= 0.2:
# too small leads to some issues
l = round(1920 * opts.in_scale)
config.data.test.img_scale = (l, l)
config.data.test.resize_keep_ratio = False
else:
config.data.test.img_scale = opts.in_scale
config.data.test.resize_keep_ratio = True
else:
config.data.test.img_scale = opts.in_scale
config.data.test.resize_keep_ratio = True
if opts.no_mask:
if 'roi_head' in config.model and 'mask_head' in config.model[
'roi_head']:
config.model['roi_head']['mask_head'] = None
if 'zoom_crop' in opts and opts.zoom_crop:
config.data.test.zoom_crop = {
'h': opts.zoom_crop_h,
'y': opts.zoom_crop_y,
}
else:
config.data.test.zoom_crop = None
config.model.pretrained = None
if 'action_head' in config.model:
config.model['action_head_weights'] = opts.action_head_weights
model = build_detector(config.model, test_cfg=config.test_cfg)
map_loc = 'cpu' if device == 'cpu' else None
checkpoint = load_checkpoint(model, opts.weights, map_location=map_loc)
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
warnings.simplefilter('once')
warnings.warn('Class names are not saved in the checkpoint\'s '
'meta data, use COCO classes by default.')
model.CLASSES = get_classes('coco')
model.cfg = config
model.to(device)
model.eval()
return model
def show_and_save_result(img, result, out_dir, dataset="coco", score_thr=0.3):
class_names = get_classes(dataset)
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
index = img.rfind("/")
mmcv.imshow_det_bboxes(img, bboxes, labels, class_names, score_thr, show=True, out_file=out_dir+img[index+1:])
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
print("img_meta: {}".format(img_meta))
mmcv.imshow_det_bboxes(
img_show,
bboxes,
labels,
# class_names=class_names,
class_names=[str(i) for i in range(len(class_names))],
score_thr=score_thr,
gt_bboxes=data['gt_bboxes'][0][0].numpy(),
gt_labels=(data['gt_labels'][0][0] - 1).numpy())
def parse_pkldets(input_pkl, img_dir, outdir, score_thr=0.3, dataset='cityscapes'):
dets = mmcv.load(input_pkl)
num_imgs = len(dets)
# num_class = 8
VOC_CLASSES = get_classes(dataset)
print(VOC_CLASSES)
img_names_list = os.listdir(img_dir)
for k in range(num_imgs):
print(k)
imgHeight, imgWidth = 1024, 2048
imgName = img_names_list[k]
# print(dets[k])
bbox_result, segm_result = dets[k]
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(bbox_result)
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
# labs, confs, polygons = [], [], []
ftxt = open(outdir + imgName[:-4] + '.txt', 'w')
# print(inds)
for i in inds:
img = np.zeros((imgHeight, imgWidth), np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool) # mask predicted.
# contour, hier = cv2.findContours(mask, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
# try:
# contour = np.reshape(contour[0], [-1, 2])
# except:
# print(k, i, contour, 'Segmentation Error!')
# continue
# polygon = []
# for j in range(contour.shape[0]):
# polygon.append([int(contour[j, 0]), int(contour[j, 1])])
# polygons.append(polygon) # append polygon of a instance.
img[mask] = 255 # mask as white-color.
cv2.imwrite(outdir + imgName[:-4] + str(i) + '.png', img)
# confs.append(round(float(bboxes[i, -1]), 2)) # conf predicted.
# labs.append(VOC_CLASSES[labels[i]]) # labels predicted.
# print(imgName[:-4]+str(i)+'.png')
# print(str(labelDic[VOC_CLASSES[labels[i]]]))
ftxt.write(imgName[:-4]+str(i)+'.png'+' '+str(labelDic[VOC_CLASSES[labels[i]]])+' '+str(round(float(bboxes[i, -1]), 2))+'\n')
def show_result(img, result, dataset='coco', score_thr=0.3):
class_names = get_classes(dataset)
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
img = mmcv.imread(img)
mmcv.imshow_det_bboxes(img.copy(),
bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
def run_on_onnxruntime():
config_file = '../configs/solov2/solov2_light_448_r34_fpn_8gpu_3x.py'
onnx_file = 'weights/SOLOv2_light_R34.onnx'
input_names = ['input']
# output_names = ['C0', 'C1', 'C2', 'C3', 'C4']
# output_names = ['cate_pred_0', 'cate_pred_1', 'cate_pred_2', 'cate_pred_3', 'cate_pred_4',
# 'kernel_pred_0', 'kernel_pred_1', 'kernel_pred_2', 'kernel_pred_3', 'kernel_pred_4',
# 'seg_pred'] # Origin
output_names = ['cate_pred', 'kernel_pred', 'seg_pred'] # add permute & concate
if isinstance(config_file, str):
cfg = mmcv.Config.fromfile(config_file)
elif not isinstance(config_file, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
'but got {}'.format(type(config_file)))
# 1. Preprocess
# input demo img size 427x640 --> resized 448x671 --> pad 448x672
img = 'images/demo.jpg'
# build the data pipeline
test_pipeline = [LoadImage()] + cfg.data.test.pipeline[1:]
test_pipeline = Compose(test_pipeline)
# prepare data
data = dict(img=img)
data = test_pipeline(data)
# 2. Run inference on onnxruntime
print("Load onnx model from {}.".format(onnx_file))
sess = rt.InferenceSession(onnx_file)
tic = cv2.getTickCount()
onnx_output = sess.run(output_names, {input_names[0]: data['img'][0].unsqueeze(0).cpu().numpy()})
print('-----> onnxruntime inference time: {}ms'.format((cv2.getTickCount() - tic) * 1000/ cv2.getTickFrequency()))
# 3. Get seg
# 调用pytorch定义的获取分割图和matrix nms 以及后处理
from mmdet.models.anchor_heads.solov2_head import SOLOv2Head
solov2_head = SOLOv2Head(num_classes=81,
in_channels=256,
num_grids=[40, 36, 24, 16, 12],
strides=[8, 8, 16, 32, 32],
ins_out_channels = 128,
loss_ins=cfg.model.bbox_head.loss_ins,
loss_cate=cfg.model.bbox_head.loss_cate)
cate_preds = [torch.from_numpy(x) for x in onnx_output[:1]]
kernel_preds = [torch.from_numpy(x) for x in onnx_output[1:2]]
seg_pred = torch.from_numpy(onnx_output[2])
result = solov2_head.get_seg(cate_preds, kernel_preds, seg_pred, [data['img_meta'][0].data], cfg.test_cfg, rescale=True)
show_result_ins(img, result, get_classes('coco'), score_thr=0.25, out_file="images/demo_out_onnxrt_solov2.jpg")
print('Script done!')
def nms_after_det(bboxes_list,
labels_list,
is_pretrained=False,
class_names=get_classes('coco'),
is_rcnn=True):
'''
non maximum suppress on detection result boxes
input bboxes list and labels list, return ndarray of nms result
result format: det_bboxes: [[x1, y1, x2, y2, score],...] det_labels: [0 0 0 0 1 1 1 2 2 ...]
'''
# read config file
if is_rcnn:
cfg_path = FASTER_RCNN_CONFIG
cfg = mmcv.Config.fromfile(cfg_path)
if not is_pretrained:
cfg.model.pretrained = None
# NMS
multi_bboxes = []
multi_scores = []
for i, bbox in enumerate(bboxes_list):
# only show vehicles
# if 2 <= (labels_list[i] + 1) <= 8: # vehicles
if 0 <= labels_list[
i] <= 7: # choose what to keep, now keep person and all vehicles
multi_bboxes.append(bbox[0:4])
# temp = [0 for _ in range(len(class_names))]
temp = [0 for _ in range(3)]
temp[labels_list[i] + 1] = bbox[4]
multi_scores.append(temp)
# if result is null
if not multi_scores:
return np.array([]), np.array([])
if is_rcnn:
det_bboxes, det_labels = multiclass_nms(
torch.from_numpy(np.array(multi_bboxes).astype(np.float32)),
torch.from_numpy(np.array(multi_scores).astype(np.float32)),
cfg.model.test_cfg.rcnn.score_thr, cfg.model.test_cfg.rcnn.nms,
cfg.model.test_cfg.rcnn.max_per_img)
else:
det_bboxes, det_labels = multiclass_nms(
torch.from_numpy(np.array(multi_bboxes).astype(np.float32)),
torch.from_numpy(np.array(multi_scores).astype(np.float32)),
cfg.test_cfg.score_thr, cfg.test_cfg.nms, cfg.test_cfg.max_per_img)
return det_bboxes.numpy(), det_labels.numpy()
def display_result_3d(img, result, dataset='coco', score_thr=0.3):
img_np = np.load(img)
class_names = get_classes(dataset)
bbox_result = result
bboxes = np.vstack(bbox_result)
bboxes_placeholders = [[] for i in range(0, 160)]
for bbox in bboxes:
for z_index in range(int(np.floor(bbox[4])), int(np.ceil(bbox[5])+ 1)):
bboxes_placeholders[z_index].append([bbox[0], bbox[1], bbox[2], bbox[3], bbox[6]])
for index, boxes in enumerate(bboxes_placeholders):
if len(boxes) > 0:
for box in boxes:
if box[4] > score_thr:
print('slice {} score {}'.format(index, box[4]))
def show_result(img, result, dataset='coco', score_thr=0.5, show=True):
class_names = get_classes(dataset)
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
# print(result)
# print(len(result))
labels = np.concatenate(labels)
bboxes = np.vstack(result)
img = mmcv.imread(img)
anno, img = mmcv.imshow_det_bboxes(img.copy(),
bboxes,
labels,
show=show,
class_names=class_names,
score_thr=score_thr)
return anno, img
def save_result(result, dataset='coco', score_thr=0.3):
"""Return list dict [{x1,x2,y1,y2,classe,score},...]
Args:
results:
score_thr (float): Minimum score of bboxes to be shown.
"""
class_names = get_classes(dataset)
#class_names = ["person", "plate"]
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
return det_bboxes(bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
def save_result(result, class_to_keep=[], dataset='coco', score_thr=0.3):
"""Return list dict [{x1,x2,y1,y2,classe,score},...]
Args:
results:
class_to_keep (list[str]): Classes to keep (cars, trucks...)
score_thr (float): Minimum score of bboxes to be shown.
"""
class_names = get_classes(dataset)
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
return det_bboxes(bboxes,
labels,
class_names=class_names,
class_to_keep=class_to_keep,
score_thr=score_thr)
def init_detector(config, checkpoint=None, device='cuda:0'):
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
'but got {}'.format(type(config)))
config.model.pretrained = None
model = build_recognizer(config.model, test_cfg=config.test_cfg)
if checkpoint is not None:
checkpoint = load_checkpoint(model, checkpoint)
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
warnings.warn('Class names are not saved in the checkpoint\'s '
'meta data, use COCO classes by default.')
model.CLASSES = get_classes('coco')
model.cfg = config # save the config in the model for convenience
model.to(device)
model.eval()
return model
def save_result(img, result, out_file, dataset='coco', score_thr=0.8):
class_names = get_classes(dataset)
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
img = mmcv.imread(img)
mmcv.imshow_det_bboxes(img.copy(),
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
bbox_color='red',
text_color='white',
thickness=2,
font_scale=0.8,
show=False,
out_file=out_file)
def mymm2d_init_detector(config, checkpoint=None, device='cuda:0'):
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
f'but got {type(config)}')
config.model.pretrained = None
config.model.train_cfg = None
model = build_detector(config.model, test_cfg=config.get('test_cfg'))
if checkpoint is not None:
map_loc = 'cpu' if device == 'cpu' else None
checkpoint = load_checkpoint(model, checkpoint, map_location=map_loc)
if 'CLASSES' in checkpoint.get('meta', {}):
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = get_classes('coco')
model.cfg = config # save the config in the model for convenience
model.to(device)
model.eval()
return model
