def simple_test(self, img, img_meta, rescale=False):
x = self.extract_feat(img)
semantic_pred = self.semantic_head(x)
seg_inds = torch.cat([torch.arange(1, 12), torch.arange(13, 26), torch.arange(27, 29), torch.arange(31, 45),
torch.arange(46, 66), torch.arange(67, 68), torch.arange(70, 71),
torch.arange(72, 83), torch.arange(84, 91)])
seg_feats = semantic_pred.softmax(dim=1)
seg_feats = seg_feats[:, seg_inds, :, :].contiguous()
x = self.fuse_neck(x, seg_feats)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_meta, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels in bbox_list
]
return bbox_results[0]
def simple_test(self, img, img_meta, proposals=None, rescale=False):
"""Test without augmentation."""
assert self.with_bbox, "Bbox head must be implemented."
x = self.extract_feat(img)
proposal_list = self.simple_test_rpn(
x, img_meta, self.test_cfg.rpn) if proposals is None else proposals
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
# masks
segm_results, aligned_masks = self.simple_test_mask(
x,
img_meta,
det_bboxes,
det_labels,
rescale=rescale,
return_aligned_masks=True)
# panoptic
if self.with_semantic:
semantic_pred, _ = self.semantic_head(x)
semantic_results = self.simple_test_semantic(semantic_pred,
img_meta,
rescale=rescale)
assert self.with_srm
if self.with_srm:
srm_results = self.simple_test_srm(aligned_masks,
det_labels)
aux_results = dict(srm_results=srm_results)
return bbox_results, segm_results, semantic_results, aux_results
else:
return bbox_results, segm_results, semantic_results
else:
return bbox_results, segm_results
def simple_test(self, img, img_meta, rescale=False):
if self.with_neck:
x = self.neck(img)
outs = self.bbox_head(x)
#for out in outs:
# for t in out:
# print(t.size())
# print(t)
#print("over")
#exit()
bbox_inputs = outs + (img_meta, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels in bbox_list
]
return bbox_results[0]
def simple_test(self, img, img_meta, rescale=False):
print(img.shape)
print('single test')
if img.shape[1] > 3:
n = img.shape[1] // 3
img = img.view(n, 3, img.shape[2], img.shape[3])
# print(((img[0]==img[1]).sum().float()/3)/(img.shape[-1]*img.shape[-2]))
#0.1864
# print(img.shape)
# torch.Size([2, 256, 48, 156])
# torch.Size([2, 256, 24, 78])
# torch.Size([2, 256, 12, 39])
# torch.Size([2, 256, 6, 20])
# torch.Size([2, 256, 3, 10])
x = self.extract_feat(img)
if self.agg_check:
x = self.agg.forward_test(x)
# agg_load=np.load('/home/ld/RepPoints/offset/agg_st_support/2/agg_f.npy')
# agg=torch.from_numpy(agg_load).to(img.device)
# print('agg check in single stage',(x[0]==agg).all())
# load=[]
# for i in range(len(x)):
# # print(x[i].shape)
# if i==0:
# load.append(agg)
# else:
# load.append(x[i])
# x=tuple(load)
outs = self.bbox_head(x)
index = self.index
index = True
bbox_inputs = outs + (img_meta, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs, index=index)
if index:
box_loc = bbox_list[0][2]
bbox_list = [bbox_list[0][:2]]
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels in bbox_list
]
if index:
return bbox_results[0], box_loc
else:
return bbox_results[0]
def aug_test(self, imgs, img_metas, rescale=False):
"""Test function with test time augmentation.
Args:
imgs (list[Tensor]): the outer list indicates test-time
augmentations and inner Tensor should have a shape NxCxHxW,
which contains all images in the batch.
img_metas (list[list[dict]]): the outer list indicates test-time
augs (multiscale, flip, etc.) and the inner list indicates
images in a batch. each dict has image information.
rescale (bool, optional): Whether to rescale the results.
Defaults to False.
Returns:
list[ndarray]: bbox results of each class
"""
# recompute feats to save memory
feats = self.extract_feats(imgs)
aug_bboxes = []
aug_scores = []
for x, img_meta in zip(feats, img_metas):
# only one image in the batch
outs = self.bbox_head(x)
bbox_inputs = outs + (img_meta, self.test_cfg, False, False)
det_bboxes, det_scores = self.bbox_head.get_bboxes(*bbox_inputs)[0]
aug_bboxes.append(det_bboxes)
aug_scores.append(det_scores)
# after merging, bboxes will be rescaled to the original image size
merged_bboxes, merged_scores = self.merge_aug_results(
aug_bboxes, aug_scores, img_metas)
det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores,
self.test_cfg.score_thr,
self.test_cfg.nms,
self.test_cfg.max_per_img)
if rescale:
_det_bboxes = det_bboxes
else:
_det_bboxes = det_bboxes.clone()
_det_bboxes[:, :4] *= det_bboxes.new_tensor(
img_metas[0][0]['scale_factor'])
bbox_results = bbox2result(_det_bboxes, det_labels,
self.bbox_head.num_classes)
return bbox_results
def postprocess(self,
det_bboxes,
det_labels,
det_masks,
img_meta,
rescale=False):
num_classes = self.bbox_head.num_classes
if rescale:
scale_factor = img_meta[0]['scale_factor']
if isinstance(det_bboxes, torch.Tensor):
det_bboxes[:, :4] /= det_bboxes.new_tensor(scale_factor)
else:
det_bboxes[:, :4] /= np.asarray(scale_factor)
bbox_results = bbox2result(det_bboxes, det_labels, num_classes)
return bbox_results
def simple_test(self,
img,
img_metas,
proposals=None,
rescale=False,
return_levels=True):
"""Test without augmentation."""
assert self.with_bbox, 'Bbox head must be implemented.'
x = self.extract_feat(img)
if proposals is None:
proposal_list = self.simple_test_rpn(x, img_metas,
self.test_cfg.rpn)
else:
proposal_list = proposals
if not return_levels:
det_bboxes, det_labels = self.simple_test_bboxes(
x,
img_metas,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
else:
det_bboxes, det_labels, det_levels = self.simple_test_bboxes(
x,
img_metas,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale,
return_levels=True)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
segm_results = self.simple_test_mask(x,
img_metas,
det_bboxes,
det_labels,
rescale=rescale)
return bbox_results, segm_results
def simple_test(self,
x,
proposal_list,
img_metas,
proposals=None,
rescale=False,
postprocess=True):
"""Test without augmentation."""
assert self.with_bbox, 'Bbox head must be implemented.'
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_metas,
proposal_list,
self.test_cfg,
rescale=False)
# pack rois into bboxes
grid_rois = bbox2roi([det_bboxes[:, :4]])
grid_feats = self.grid_roi_extractor(
x[:len(self.grid_roi_extractor.featmap_strides)], grid_rois)
if grid_rois.shape[0] != 0:
self.grid_head.test_mode = True
grid_pred = self.grid_head(grid_feats)
det_bboxes = self.grid_head.get_bboxes(det_bboxes,
grid_pred['fused'],
img_metas)
if rescale:
scale_factor = img_metas[0]['scale_factor']
if not isinstance(scale_factor, (float, torch.Tensor)):
scale_factor = det_bboxes.new_tensor(scale_factor)
det_bboxes[:, :4] /= scale_factor
else:
det_bboxes = torch.Tensor([])
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
segm_results = self.simple_test_mask(x,
img_metas,
det_bboxes,
det_labels,
rescale=rescale)
return bbox_results, segm_results
def simple_test(self, img, img_metas, rescale=False):
"""Test function without test time augmentation."""
x = self.extract_feat(img)
cls_score, bbox_pred, coeff_pred = self.bbox_head(x)
bbox_inputs = (cls_score, bbox_pred,
coeff_pred) + (img_metas, self.test_cfg, rescale)
det_bboxes, det_labels, det_coeffs = self.bbox_head.get_bboxes(
*bbox_inputs)
bbox_results = [
bbox2result(det_bbox, det_label, self.bbox_head.num_classes)
for det_bbox, det_label in zip(det_bboxes, det_labels)
]
num_imgs = len(img_metas)
scale_factors = tuple(meta['scale_factor'] for meta in img_metas)
if all(det_bbox.shape[0] == 0 for det_bbox in det_bboxes):
segm_results = [[[] for _ in range(self.mask_head.num_classes)]
for _ in range(num_imgs)]
else:
# if det_bboxes is rescaled to the original image size, we need to
# rescale it back to the testing scale to obtain RoIs.
if rescale and not isinstance(scale_factors[0], float):
scale_factors = [
torch.from_numpy(scale_factor).to(det_bboxes[0].device)
for scale_factor in scale_factors
]
_bboxes = [
det_bboxes[i][:, :4] *
scale_factors[i] if rescale else det_bboxes[i][:, :4]
for i in range(len(det_bboxes))
]
mask_preds = self.mask_head(x[0], det_coeffs, _bboxes, img_metas)
# apply mask post-processing to each image individually
segm_results = []
for i in range(num_imgs):
if det_bboxes[i].shape[0] == 0:
segm_results.append(
[[] for _ in range(self.mask_head.num_classes)])
else:
segm_result = self.mask_head.get_seg_masks(
mask_preds[i], det_labels[i], img_metas[i], rescale)
segm_results.append(segm_result)
return list(zip(bbox_results, segm_results))
def simple_test(self, img, img_metas, rescale=False):
"""Test function without test time augmentation.
Args:
imgs (list[torch.Tensor]): List of multiple images
img_metas (list[dict]): List of image information.
rescale (bool, optional): Whether to rescale the results.
Defaults to False.
Returns:
np.ndarray: proposals
"""
x = self.extract_feat(img)
outs = self.bbox_head(x)
bbox_list, bbox_list_tail = self.bbox_head.get_bboxes(*outs,
img_metas,
rescale=rescale)
for bboxes, labels in bbox_list:
det_bboxes = bboxes
det_labels = labels
if self.labels is not None:
inds = []
for label in self.labels:
inds.append(
torch.nonzero(det_labels == label,
as_tuple=False).squeeze(1))
inds = torch.cat(inds)
det_bboxes = det_bboxes[inds]
det_labels = det_labels[inds]
for bboxes, labels in bbox_list_tail:
det_bboxes_tail = bboxes
det_labels_tail = labels
# print(torch.max(det_labels_tail))
if self.labels_tail is not None:
inds = []
for label in self.labels_tail:
inds.append(
torch.nonzero(det_labels_tail == label,
as_tuple=False).squeeze(1))
inds = torch.cat(inds)
det_bboxes_tail = det_bboxes_tail[inds]
det_labels_tail = det_labels_tail[inds]
det_bboxes = torch.cat((det_bboxes, det_bboxes_tail))
det_labels = torch.cat((det_labels, det_labels_tail))
return bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
def simple_test(self,
img,
img_meta,
proposals=None,
rescale=False,
**kwargs):
"""Test without augmentation."""
assert self.with_bbox, "Bbox head must be implemented."
# x = self.extract_feat(img)
if self.dfn_balance is None:
x = self.extract_feat(img)
elif self.dfn_balance.init_weight == 0:
x, x2 = self.extract_defect_feat(img)
if x2 == 0 and self.with_neck:
x = self.neck(x)
else:
x, x2 = self.extract_defect_feat(img)
if x2 == 0:
return x2
if proposals is None:
proposal_list = self.simple_test_rpn(x, img_meta,
self.test_cfg.rpn)
else:
proposal_list = proposals
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
segm_results = self.simple_test_mask(x,
img_meta,
det_bboxes,
det_labels,
rescale=rescale)
return bbox_results, segm_results
def regress_and_classify(self, img, tracklets):
cfg = self.model.cfg
device = next(self.model.parameters()).device
test_pipeline = [LoadImage()] + cfg.data.test.pipeline[1:]
test_pipeline = Compose(test_pipeline)
data = dict(img=img)
data = test_pipeline(data)
data = scatter(collate([data], samples_per_gpu=1), [device])[0]
proposals = np.array([[
*(tracklet.last_detection.box[:]), tracklet.last_detection.score
] for tracklet in tracklets])
proposals[:, 0:4] = proposals[:, 0:4] * data['img_meta'][0][0][
'scale_factor']
proposals_tensor = torch.tensor(proposals).cuda(device)
with torch.no_grad():
x = self.model.extract_feat(data['img'][0])
# Here I re-implement BBoxTestMixin.simple_test_bboxes().
# It seems that the bboxes shouldn't have been rescaled when calling get_det_bboxes()?
rois = bbox2roi([proposals_tensor])
roi_feats = self.model.bbox_roi_extractor(
x[:len(self.model.bbox_roi_extractor.featmap_strides)], rois)
if self.model.with_shared_head:
roi_feats = self.model.shared_head(roi_feats)
cls_score, bbox_pred = self.model.bbox_head(roi_feats)
bboxes, scores = self.model.bbox_head.get_det_bboxes(
rois,
cls_score,
bbox_pred,
data['img_meta'][0][0]['img_shape'],
data['img_meta'][0][0]['scale_factor'],
# I mean here
rescale=True,
cfg=None)
bboxes = bboxes.view(-1, 81, 4)
bboxes = torch.cat((bboxes[:, 1, :], scores[:, 1:2]), dim=1)
labels = torch.tensor([0] * bboxes.shape[0])
bbox_results = bbox2result(bboxes, labels,
self.model.bbox_head.num_classes)[0]
return bbox_results
def simple_test(self, img, img_metas, rescale=False):
"""Test function without test time augmentation.
Args:
imgs (list[torch.Tensor]): List of multiple images
img_metas (list[dict]): List of image information.
rescale (bool, optional): Whether to rescale the results.
Defaults to False.
Returns:
list[list[np.ndarray]]: BBox results of each image and classes.
The outer list corresponds to each image. The inner list
corresponds to each class.
"""
x = self.extract_feat(img)
outs = self.bbox_head(x)
#print(len(outs))
if torch.onnx.is_in_onnx_export():
print('single_stage.py in-onnx-export')
print(outs.__class__)
cls_score, bbox_pred, kps_pred = outs
for c in cls_score:
print(c.shape)
for c in bbox_pred:
print(c.shape)
#print(outs[0].shape, outs[1].shape)
if self.bbox_head.use_kps:
for c in kps_pred:
print(c.shape)
return (cls_score, bbox_pred, kps_pred)
else:
return (cls_score, bbox_pred)
#return outs
bbox_list = self.bbox_head.get_bboxes(*outs,
img_metas,
rescale=rescale)
# skip post-processing when exporting to ONNX
#if torch.onnx.is_in_onnx_export():
# return bbox_list
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels in bbox_list
]
return bbox_results
def simple_test(self, img, img_meta, proposals=None, rescale=False):
"""Test without augmentation."""
assert self.with_bbox, "Bbox head must be implemented."
x = self.extract_feat(img)
proposal_list = self.simple_test_rpn(
x, img_meta, self.test_cfg.rpn) if proposals is None else proposals
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
return bbox_results
def simple_test(self, img, img_metas, proposals=None, rescale=False):
x = self.extract_feat(img)
outs = self.bbox_head(x)
if isinstance(x[0], dict): x = [x[i]['fm'] for i in range(len(x))]
down_ratios = get_down_ratios(img, outs, self.box_head_stack_nums)
det_bboxes, det_labels = self.bbox_head.get_bboxes(
*outs, img_metas, down_ratios, rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
segm_results = self.roi_head.simple_test(x,
det_bboxes,
det_labels,
img_metas,
rescale=rescale)
return bbox_results, segm_results
def simple_test(self, img, img_metas, rescale=False):
"""Test function without test-time augmentation."""
feat = self.extract_feat(img)
det_bboxes, det_labels, det_coeffs = self.bbox_head.simple_test(
feat, img_metas, rescale=rescale)
bbox_results = [
bbox2result(det_bbox, det_label, self.bbox_head.num_classes)
for det_bbox, det_label in zip(det_bboxes, det_labels)
]
segm_results = self.mask_head.simple_test(feat,
det_bboxes,
det_labels,
det_coeffs,
img_metas,
rescale=rescale)
return list(zip(bbox_results, segm_results))
def simple_test(self, img, img_meta, proposals=None, rescale=False):
"""Test without augmentation."""
assert self.with_bbox, "Bbox head must be implemented."
x = self.extract_feat(img)
semantic_pred = self.semantic_head(x)
semantic_pred = semantic_pred.softmax(dim=1)
# N, C, H, W = seg_feats.size()
seg_inds = torch.cat([
torch.arange(1, 12),
torch.arange(13, 26),
torch.arange(27, 29),
torch.arange(31, 45),
torch.arange(46, 66),
torch.arange(67, 68),
torch.arange(70, 71),
torch.arange(72, 83),
torch.arange(84, 91)
])
if self.bg_seg:
seg_inds = torch.cat([seg_inds, torch.arange(92, 183)])
seg_feats = semantic_pred[:, seg_inds, :, :].contiguous()
if self.augneck:
x = self.fuse_neck(x, seg_feats)
proposal_list = self.simple_test_rpn(
x, img_meta, self.test_cfg.rpn) if proposals is None else proposals
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
segm_results = self.simple_test_mask(x,
img_meta,
det_bboxes,
det_labels,
rescale=rescale)
return bbox_results, segm_results
def aug_test(self, imgs, img_metas, rescale=False):
# recompute feats to save memory
feats = self.extract_feats(imgs)
aug_bboxes = []
aug_scores = []
aug_masks = []
aug_points = []
for x, img_meta in zip(feats, img_metas):
# only one image in the batch
# TODO more flexible
outs = self.bbox_head(x, test=True)
bbox_inputs = outs + (img_meta, self.test_cfg, False, False)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
det_bbox, det_points, det_masks, det_labels = bbox_list[0]
aug_bboxes.append(det_bbox)
aug_scores.append(det_labels)
aug_masks.append(det_masks)
aug_points.append(det_points)
# after merging, bboxes will be rescaled to the original image size
merged_bboxes, merged_scores, merged_points, merged_masks = self.merge_aug_results(
aug_bboxes, aug_scores, aug_points, aug_masks, img_metas)
cfg = self.test_cfg
det_bboxes, det_pts, det_masks, det_labels = multiclass_nms_pts(
merged_bboxes, merged_points, merged_scores, merged_masks, cfg.score_thr, cfg.nms, cfg.max_per_img)
if rescale:
_det_bboxes = det_bboxes
else:
_det_bboxes = det_bboxes.clone()
_det_bboxes[:, :4] *= img_metas[0][0]['scale_factor']
bbox_results = bbox2result(_det_bboxes, det_labels,
self.bbox_head.num_classes)
pts_results = pts2result(det_pts, det_labels, self.bbox_head.num_classes)
ori_shape = img_metas[0][0]['ori_shape']
scale_factor = img_metas[0][0]['scale_factor']
rle_results = self.get_seg_masks(det_masks[:, :-1], det_pts[:, :-1], _det_bboxes, det_labels, self.test_cfg,
ori_shape, scale_factor, rescale)
return (bbox_results, rle_results), pts_results
def simple_test(self, img, img_meta, in_dict=None, rescale=False):
x = self.extract_feat(img) # [[1*1, c1, h1, w1]*5]
out_dict = None
if self.with_temporal_module:
# During test, no reshape & permute
x, out_dict = self.temporal_module(x, in_dict=in_dict,
is_train=False)
if self.with_neck and not self.neck_first:
x = self.neck(x)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_meta, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels in bbox_list
]
return bbox_results[0], out_dict
def simple_test(self, img, img_metas, rescale=False, return_dict=True):
x = self.extract_feat(img)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_metas, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
det_result = bbox_list[0]
if return_dict:
return {
'boxes': det_result[0].cpu().numpy(),
'classes': det_result[1].cpu().numpy(),
'embed': det_result[2].cpu().numpy()
}
else:
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels, det_embeds in bbox_list
]
return bbox_results[0]
def simple_test(self,
img,
img_meta,
proposals=None,
rescale=False,
img_id=-1,
norm_cls=0):
"""Test without augmentation."""
assert self.with_bbox, "Bbox head must be implemented."
x = self.extract_feat(img)
proposal_list = self.simple_test_rpn(
x, img_meta, self.test_cfg.rpn) if proposals is None else proposals
if self.use_reweight:
det_bboxes, det_labels, scores = self.simple_test_bboxes_reweight(
x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
else:
det_bboxes, det_labels, scores = self.simple_test_bboxes(
x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
img_id,
norm_cls,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results, det_bboxes, det_labels, scores # return original bbox_results, and also returns bboxes ,labels and logits
else:
segm_results = self.simple_test_mask(x,
img_meta,
det_bboxes,
det_labels,
rescale=rescale)
return bbox_results, segm_results
def simple_test(self,
x,
proposal_list,
img_metas,
proposals=None,
rescale=False):
"""Test without augmentation."""
assert self.with_bbox, 'Bbox head must be implemented.'
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_metas,
proposal_list,
self.test_cfg,
rescale=rescale)
# det_bboxes, det_labels = self.filter_box(det_bboxes, det_labels)
if torch.onnx.is_in_onnx_export():
if self.with_mask:
segm_results = self.simple_test_mask(x,
img_metas,
det_bboxes,
det_labels,
rescale=rescale)
return det_bboxes, det_labels, segm_results
else:
return det_bboxes, det_labels
bbox_results = [
bbox2result(det_bboxes[i], det_labels[i],
self.bbox_head.num_classes)
for i in range(len(det_bboxes))
]
if not self.with_mask:
return bbox_results
else:
segm_results = self.simple_test_mask(x,
img_metas,
det_bboxes,
det_labels,
rescale=rescale)
return list(zip(bbox_results, segm_results))
def simple_test(self,
img,
img_meta,
proposals=None,
rescale=False,
out_proposal=False,
**kwargs):
"""Test without augmentation."""
assert self.with_bbox, "Bbox head must be implemented."
# TODO: support multiple images per GPU
x = self.extract_feat(img)
proposal_list = self.simple_test_rpn(
x, img_meta, self.test_cfg.rpn) if proposals is None else proposals
det_bboxes, det_labels = self.simple_test_bboxes(x,
img_meta,
proposal_list,
self.test_cfg.rcnn,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
results = (bbox_results, )
else:
segm_results = self.simple_test_mask(x,
img_meta,
det_bboxes,
det_labels,
rescale=rescale)
results = (bbox_results, segm_results)
if out_proposal:
if rescale:
img_shape = img_meta[0]['img_shape']
scale_factor = img_meta[0]['scale_factor']
proposal_list[0][:, [0, 2]].clamp_(min=0, max=img_shape[1] - 1)
proposal_list[0][:, [1, 3]].clamp_(min=0, max=img_shape[0] - 1)
proposal_list[0][:, :4] /= scale_factor
proposal_list = proposal_list[0].cpu().numpy()
results = results + (proposal_list, )
return results
def simple_test(self, img, img_metas, rescale=False):
x = self.extract_feat(img)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_metas, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
# bbox_results = [
# bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
# for det_bboxes, det_labels in bbox_list
# ]
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels, aa in bbox_list
]
segm_results = [
aa
for det_bboxes, det_labels, aa in bbox_list
]
# aa= bbox_list[0][0][:,-1]>0.5
return bbox_results[0], segm_results[0]
def aug_test(self,
imgs_l,
img_meta,
rescale=False,
gt_bboxes=None,
gt_labels=None,
gt_masks=None,
idx=None):
img = imgs_l[0][0]
img_n = img.squeeze().cpu().numpy()
img_n = np.transpose(img_n, [1, 2, 0])
img_n -= img_n.min()
img_n /= abs(img_n).max()
img_n *= 255.0
ms_results = []
bboxes = []
labels = []
for i in [0]:
#for i in [0, 2, 4, 6, 8]:
imgs = torch.cat(imgs_l[i:i + 2])
x = self.extract_feat(imgs)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_meta[i:i + 2], self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
ms_results.append(bbox_list)
bboxes.append(bbox_list[0][0])
labels.append(bbox_list[0][1])
detections = torch.cat(bboxes) #.cpu().numpy()
labels = torch.cat(labels) #.cpu().numpy()
bbox_list = [(detections, labels)]
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes + 1)
for det_bboxes, det_labels in bbox_list
]
#print("aug results size ", len(bbox_results[0]))
#print("aug resulsts is ", bbox_results[0])
return bbox_results[0]
def simple_test(self, img, img_meta, rescale=False):
x = self.extract_feat(img)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_meta, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes_keypoints(*bbox_inputs)
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_keypoints, det_labels in bbox_list
]
keypoint_results = [
keypoint2result(det_keypoints, det_labels,
self.bbox_head.num_classes)
for det_bboxes, det_keypoints, det_labels in bbox_list
]
# 为了保持mmdetection评估的统一性，只返回bbox_results,
# keypoint_results使用类局部变量保存 权宜之计，无法进行batch测试时
self.keypoint_results = keypoint_results[0]
return bbox_results[0]
def simple_test(self, img, img_meta, proposals=None, rescale=False):
"""Test without augmentation."""
with torch.no_grad():
x = self.extract_feat(img)
# two-stream rpn
rpn_outs = self.simple_test_rpn(x, img_meta, self.test_cfg.text_rpn, self.test_cfg.char_rpn) \
if proposals is None else proposals
# text line proposals
text_proposal_list = rpn_outs[0]
# character proposals
char_proposal_list = rpn_outs[1]
# text detection module
text_det_bboxes, text_det_labels = self.simple_test_text_bboxes(
x, img_meta, text_proposal_list, self.test_cfg.text_rcnn, rescale=rescale)
rects = self.simple_test_text_mask(x, img_meta, text_det_bboxes, text_det_labels, rescale=rescale)
# character-based recognition module
char_det_bboxes, char_det_labels = self.simple_test_char_bboxes(
x, img_meta, char_proposal_list, self.test_cfg.char_rcnn, rescale=rescale)
char_bbox_results = bbox2result(char_det_bboxes, char_det_labels, self.char_bbox_head.num_classes)
# match-assemble algorithm
texts, text_scores = self.get_text_content(rects, char_det_bboxes, char_det_labels, self.label2char)
# re-scoring
tokens = self.get_token(self.bert_tokenizer, texts).to(x[0].device)
segments = x[0].new_zeros((tokens.size(0), tokens.size(1)), dtype=torch.long)
x_nlp = self.bert_model(tokens, token_type_ids=segments)[0]
outputs = self.lang_model(x_nlp)
cls_scores = outputs[0]
cls_scores = F.softmax(cls_scores, dim=1)
cls_scores[cls_scores < self.test_cfg.ignore_thr] = 0
scores = ((1 - self.lm_cfg.lang_score_weight) * text_det_bboxes[:, 4] +
self.lm_cfg.lang_score_weight * cls_scores[:, 1]).cpu().numpy()
# nms
rects, scores, inds = poly_nms(rects, scores, self.test_cfg.poly_iou, 0.0, return_ind=True)
texts = [texts[i] for i in inds]
return rects, scores, char_bbox_results, texts
async def async_simple_test(self,
x,
proposal_list,
img_metas,
proposals=None,
rescale=False):
"""Async test without augmentation."""
assert self.with_bbox, 'Bbox head must be implemented.'
det_bboxes, det_labels = await self.async_test_bboxes(x,
img_metas,
proposal_list,
self.test_cfg,
rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
seq_results = None
if self.with_seq:
seq_results = await self.async_test_seq(
x,
img_metas,
det_bboxes,
det_labels,
rescale=rescale,
mask_test_cfg=self.test_cfg.get('seq'))
if not self.with_mask:
if seq_results:
return bbox_results, seq_results
else:
return bbox_results
else:
segm_results = await self.async_test_mask(
x,
img_metas,
det_bboxes,
det_labels,
rescale=rescale,
mask_test_cfg=self.test_cfg.get('mask'))
if seq_results:
return bbox_results, segm_results, seq_results
else:
return bbox_results, segm_results
def temporal_test(self, img, img_meta, seq_len, rescale=False):
x = self.extract_feat(img) # [[1*1, c1, h1, w1]*4]
out_dict = None
if self.with_temporal_module:
x_seq = [v.view([seq_len, 1, *v.shape[1:]]) for v in x]
x, out_dict = self.temporal_module(x_seq,
in_dict=None,
is_train=True)
if self.with_neck and not self.neck_first:
x = self.neck(x)
outs = self.bbox_head(x)
bbox_inputs = outs + (img_meta, self.test_cfg, rescale)
bbox_list = self.bbox_head.get_bboxes(*bbox_inputs)
bbox_results = [
bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes)
for det_bboxes, det_labels in bbox_list
]
return bbox_results, out_dict
def simple_test(self,
x,
proposal_list,
img_metas,
proposals=None,
rescale=False):
"""Test without augmentation."""
assert self.with_bbox, 'Bbox head must be implemented.'
det_bboxes, det_labels = self.simple_test_bboxes(
x, img_metas, proposal_list, self.test_cfg, rescale=rescale)
bbox_results = bbox2result(det_bboxes, det_labels,
self.bbox_head.num_classes)
if not self.with_mask:
return bbox_results
else:
segm_results = self.simple_test_mask(
x, img_metas, det_bboxes, det_labels, rescale=rescale)
return bbox_results, segm_results
