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