def get_bboxes(self,
rois,
cls_score,
bbox_pred,
img_shape,
scale_factor,
rescale=False,
cfg=None):
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
if bbox_pred is not None:
bboxes = self.bbox_coder.decode(rois[:, 1:],
bbox_pred,
max_shape=img_shape)
else:
bboxes = rois[:, 1:].clone()
if img_shape is not None:
bboxes[:, [0, 2]].clamp_(min=0, max=img_shape[1])
bboxes[:, [1, 3]].clamp_(min=0, max=img_shape[0])
if rescale and bboxes.size(0) > 0:
if isinstance(scale_factor, float):
bboxes /= scale_factor
else:
scale_factor = bboxes.new_tensor(scale_factor)
###########################
rbbox_scale_factor = scale_factor.new_zeros(5)
rbbox_scale_factor[0:4] = scale_factor
rbbox_scale_factor[4] = 1
scale_factor = rbbox_scale_factor
###########################
bboxes = (bboxes.view(bboxes.size(0), -1, 5) /
scale_factor).view(bboxes.size()[0], -1)
if cfg is None:
return bboxes, scores
else:
######################################################################
pad_scores = scores.new_zeros(len(scores), self.num_classes + 1)
# pad zero in first column
pad_scores[:, 1:self.num_classes + 1] = scores[:,
0:self.num_classes]
pad_scores[:, 0] = scores[:, -1]
# pad zero at 0 -> 5
pad_bboxes = bboxes.new_zeros(len(bboxes),
(self.num_classes + 1) * 5)
pad_bboxes[:, 5:(self.num_classes + 1) * 5] = bboxes
######################################################################
det_bboxes, det_labels = multiclass_nms_rbbox(
pad_bboxes, pad_scores, cfg.score_thr, cfg.nms,
cfg.max_per_img)
return det_bboxes, det_labels
def get_det_bboxes(self,
rois,
cls_score,
bbox_pred,
img_shape,
scale_factor,
rescale=False,
cfg=None):
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
# TODO: check and simplify it
if rois.size(1) == 5:
obbs = hbb2obb_v2(rois[:, 1:])
elif rois.size(1) == 6:
obbs = rois[:, 1:]
else:
print('strange size')
import pdb
pdb.set_trace()
if bbox_pred is not None:
# bboxes = delta2dbbox(rois[:, 1:], bbox_pred, self.target_means,
# self.target_stds, img_shape)
if self.with_module:
dbboxes = delta2dbbox(obbs, bbox_pred, self.target_means,
self.target_stds, img_shape)
else:
dbboxes = delta2dbbox_v3(obbs, bbox_pred, self.target_means,
self.target_stds, img_shape)
else:
# bboxes = rois[:, 1:]
dbboxes = obbs
# TODO: add clip here
if rescale:
# bboxes /= scale_factor
# dbboxes[:, :4] /= scale_factor
dbboxes[:, 0::5] /= scale_factor
dbboxes[:, 1::5] /= scale_factor
dbboxes[:, 2::5] /= scale_factor
dbboxes[:, 3::5] /= scale_factor
# if cfg is None:
# c_device = dbboxes.device
#
# det_bboxes, det_labels = Pesudomulticlass_nms_rbbox(dbboxes, scores,
# 0.05,
# 1000)
#
# return det_bboxes, det_labels
# else:
c_device = dbboxes.device
det_bboxes, det_labels = multiclass_nms_rbbox(dbboxes, scores,
cfg.score_thr, cfg.nms,
cfg.max_per_img)
# det_bboxes = torch.from_numpy(det_bboxes).to(c_device)
# det_labels = torch.from_numpy(det_labels).to(c_device)
return det_bboxes, det_labels
def get_bboxes_single(self,
cls_scores,
bbox_preds,
mlvl_anchors,
img_shape,
scale_factor,
cfg,
rescale=False):
assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
mlvl_bboxes = []
mlvl_scores = []
for cls_score, bbox_pred, anchors in zip(cls_scores, bbox_preds,
mlvl_anchors):
assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
cls_score = cls_score.permute(1, 2,
0).reshape(-1, self.cls_out_channels)
if self.use_sigmoid_cls:
scores = cls_score.sigmoid()
else:
scores = cls_score.softmax(-1)
bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 5)
nms_pre = cfg.get('nms_pre', -1)
if nms_pre > 0 and scores.shape[0] > nms_pre:
if self.use_sigmoid_cls:
max_scores, _ = scores.max(dim=1)
else:
max_scores, _ = scores[:, 1:].max(dim=1)
_, topk_inds = max_scores.topk(nms_pre)
anchors = anchors[topk_inds, :]
bbox_pred = bbox_pred[topk_inds, :]
scores = scores[topk_inds, :]
rbbox_ex_anchors = hbb2obb_v2(anchors)
if self.with_module:
bboxes = delta2dbbox(rbbox_ex_anchors, bbox_pred,
self.target_means, self.target_stds,
img_shape)
else:
bboxes = delta2dbbox_v3(rbbox_ex_anchors, bbox_pred,
self.target_means, self.target_stds,
img_shape)
mlvl_bboxes.append(bboxes)
mlvl_scores.append(scores)
mlvl_bboxes = torch.cat(mlvl_bboxes)
if rescale:
# mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
mlvl_bboxes[:, :4] /= mlvl_bboxes[:, :4].new_tensor(scale_factor)
mlvl_scores = torch.cat(mlvl_scores)
if self.use_sigmoid_cls:
padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
mlvl_scores = torch.cat([padding, mlvl_scores], dim=1)
# det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores,
# cfg.score_thr, cfg.nms,
# cfg.max_per_img)
det_bboxes, det_labels = multiclass_nms_rbbox(mlvl_bboxes, mlvl_scores,
cfg.score_thr, cfg.nms,
cfg.max_per_img)
return det_bboxes, det_labels
def get_det_rbboxes(self,
rrois,
cls_score,
rbbox_pred,
img_shape,
scale_factor,
rescale=False,
cfg=None):
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
if rbbox_pred is not None:
# bboxes = delta2dbbox(rois[:, 1:], bbox_pred, self.target_means,
# self.target_stds, img_shape)
dbboxes = delta2dbbox_v2(rrois[:, 1:], rbbox_pred, self.target_means,
self.target_stds, img_shape)
else:
# bboxes = rois[:, 1:]
dbboxes = rrois[:, 1:]
# TODO: add clip here
if rescale:
# bboxes /= scale_factor
# dbboxes[:, :4] /= scale_factor
dbboxes[:, 0::5] /= scale_factor
dbboxes[:, 1::5] /= scale_factor
dbboxes[:, 2::5] /= scale_factor
dbboxes[:, 3::5] /= scale_factor
# ###########################################################
from mmdet.MARK import PRINT_RBBOX_HEAD_RS_LOSS
if PRINT_RBBOX_HEAD_RS_LOSS:
# pos_inds = pos_inds[0:min(len(pos_inds), 10)]
pred_score = scores
pred_score, pred_label = torch.max(pred_score, dim=1)
# 前景标签
pred_f_indices = pred_label != 0
if torch.sum(pred_f_indices) > 0:
print('#' * 80)
print('for pred score: ', pred_score[pred_f_indices])
print('#' * 80)
# ###########################################################
if cfg is None:
return dbboxes, scores
else:
c_device = dbboxes.device
det_bboxes, det_labels = multiclass_nms_rbbox(dbboxes, scores,
cfg.score_thr, cfg.nms,
cfg.max_per_img)
# det_bboxes = torch.from_numpy(det_bboxes).to(c_device)
# det_labels = torch.from_numpy(det_labels).to(c_device)
return det_bboxes, det_labels
def get_bboxes_single(self,
cls_score_list,
bbox_pred_list,
mlvl_anchors,
img_shape,
scale_factor,
cfg,
rescale=False):
"""
Transform outputs for a single batch item into labeled boxes.
"""
assert len(cls_score_list) == len(bbox_pred_list) == len(mlvl_anchors)
mlvl_bboxes = []
mlvl_scores = []
for cls_score, bbox_pred, anchors in zip(cls_score_list,
bbox_pred_list, mlvl_anchors):
assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
cls_score = cls_score.permute(1, 2,
0).reshape(-1, self.cls_out_channels)
if self.use_sigmoid_cls:
scores = cls_score.sigmoid()
else:
scores = cls_score.softmax(-1)
bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 5)
# anchors = rect2rbox(anchors)
nms_pre = cfg.get('nms_pre', -1)
if nms_pre > 0 and scores.shape[0] > nms_pre:
# Get maximum scores for foreground classes.
if self.use_sigmoid_cls:
max_scores, _ = scores.max(dim=1)
else:
max_scores, _ = scores[:, 1:].max(dim=1)
_, topk_inds = max_scores.topk(nms_pre)
anchors = anchors[topk_inds, :]
bbox_pred = bbox_pred[topk_inds, :]
scores = scores[topk_inds, :]
bboxes = delta2bbox_rotated(anchors, bbox_pred, self.target_means,
self.target_stds, img_shape)
mlvl_bboxes.append(bboxes)
mlvl_scores.append(scores)
mlvl_bboxes = torch.cat(mlvl_bboxes)
if rescale:
mlvl_bboxes[..., :4] /= mlvl_bboxes.new_tensor(scale_factor)
mlvl_scores = torch.cat(mlvl_scores)
if self.use_sigmoid_cls:
# Add a dummy background class to the front when using sigmoid
padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
mlvl_scores = torch.cat([padding, mlvl_scores], dim=1)
det_bboxes, det_labels = multiclass_nms_rbbox(mlvl_bboxes, mlvl_scores,
cfg.score_thr, cfg.nms,
cfg.max_per_img)
return det_bboxes, det_labels
def get_det_rbboxes(self,
rrois,
cls_score,
rbbox_pred,
img_shape,
scale_factor,
rescale=False,
cfg=None):
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
if rbbox_pred is not None:
# bboxes = delta2dbbox(rois[:, 1:], bbox_pred, self.target_means,
# self.target_stds, img_shape)
dbboxes = delta2dbbox_v2(rrois[:,
1:], rbbox_pred, self.target_means,
self.target_stds, img_shape)
else:
# bboxes = rois[:, 1:]
dbboxes = rrois[:, 1:]
# TODO: add clip here
# dbboxes[:, 4::5] = np.pi / 2
if rescale:
# bboxes /= scale_factor
# dbboxes[:, :4] /= scale_factor
dbboxes[:, 0::5] /= scale_factor
dbboxes[:, 1::5] /= scale_factor
dbboxes[:, 2::5] /= scale_factor
dbboxes[:, 3::5] /= scale_factor
if cfg is None:
return dbboxes, scores
else:
c_device = dbboxes.device
det_bboxes, det_labels = multiclass_nms_rbbox(
dbboxes, scores, cfg.score_thr, cfg.nms, cfg.max_per_img)
# det_bboxes = torch.from_numpy(det_bboxes).to(c_device)
# det_labels = torch.from_numpy(det_labels).to(c_device)
return det_bboxes, det_labels
def aug_test(self, imgs, img_metas, proposals=None, rescale=None):
# raise NotImplementedError
# import pdb; pdb.set_trace()
proposal_list = self.aug_test_rpn_rotate(
self.extract_feats(imgs), img_metas, self.test_cfg.rpn)
rcnn_test_cfg = self.test_cfg.rcnn
aug_rbboxes = []
aug_rscores = []
for x, img_meta in zip(self.extract_feats(imgs), img_metas):
# only one image in the batch
img_shape = img_meta[0]['img_shape']
scale_factor = img_meta[0]['scale_factor']
flip = img_meta[0]['flip']
proposals = bbox_mapping(proposal_list[0][:, :4], img_shape,
scale_factor, flip)
angle = img_meta[0]['angle']
# print('img shape: ', img_shape)
if angle != 0:
try:
proposals = bbox_rotate_mapping(proposal_list[0][:, :4], img_shape,
angle)
except:
import pdb; pdb.set_trace()
rois = bbox2roi([proposals])
# recompute feature maps to save GPU memory
roi_feats = self.bbox_roi_extractor(
x[:len(self.bbox_roi_extractor.featmap_strides)], rois)
if self.with_shared_head:
roi_feats = self.shared_head(roi_feats)
cls_score, bbox_pred = self.bbox_head(roi_feats)
bbox_label = cls_score.argmax(dim=1)
rrois = self.bbox_head.regress_by_class_rbbox(roi2droi(rois), bbox_label,
bbox_pred,
img_meta[0])
rrois_enlarge = copy.deepcopy(rrois)
rrois_enlarge[:, 3] = rrois_enlarge[:, 3] * self.rbbox_roi_extractor.w_enlarge
rrois_enlarge[:, 4] = rrois_enlarge[:, 4] * self.rbbox_roi_extractor.h_enlarge
rbbox_feats = self.rbbox_roi_extractor(
x[:len(self.rbbox_roi_extractor.featmap_strides)], rrois_enlarge)
if self.with_shared_head_rbbox:
rbbox_feats = self.shared_head_rbbox(rbbox_feats)
rcls_score, rbbox_pred = self.rbbox_head(rbbox_feats)
rbboxes, rscores = self.rbbox_head.get_det_rbboxes(
rrois,
rcls_score,
rbbox_pred,
img_shape,
scale_factor,
rescale=rescale,
cfg=None)
aug_rbboxes.append(rbboxes)
aug_rscores.append(rscores)
merged_rbboxes, merged_rscores = merge_rotate_aug_bboxes(
aug_rbboxes, aug_rscores, img_metas, rcnn_test_cfg
)
det_rbboxes, det_rlabels = multiclass_nms_rbbox(
merged_rbboxes, merged_rscores, rcnn_test_cfg.score_thr,
rcnn_test_cfg.nms, rcnn_test_cfg.max_per_img)
if rescale:
_det_rbboxes = det_rbboxes
else:
_det_rbboxes = det_rbboxes.clone()
_det_rbboxes[:, :4] *= img_metas[0][0]['scale_factor']
rbbox_results = dbbox2result(_det_rbboxes, det_rlabels,
self.rbbox_head.num_classes)
return rbbox_results
def _get_bboxes_single(self,
cls_score_list,
bbox_pred_list,
mlvl_anchors,
img_shape,
scale_factor,
cfg,
rescale=False,
with_nms=True):
"""Transform outputs for a single batch item into bbox predictions.
Args:
cls_score_list (list[Tensor]): Box scores for a single scale level
Has shape (num_anchors * num_classes, H, W).
bbox_pred_list (list[Tensor]): Box energies / deltas for a single
scale level with shape (num_anchors * 4, H, W).
mlvl_anchors (list[Tensor]): Box reference for a single scale level
with shape (num_total_anchors, 4).
img_shape (tuple[int]): Shape of the input image,
(height, width, 3).
scale_factor (ndarray): Scale factor of the image arange as
(w_scale, h_scale, w_scale, h_scale).
cfg (mmcv.Config): Test / postprocessing configuration,
if None, test_cfg would be used.
rescale (bool): If True, return boxes in original image space.
Default: False.
with_nms (bool): If True, do nms before return boxes.
Default: True.
Returns:
Tensor: Labeled boxes in shape (n, 5), where the first 4 columns
are bounding box positions (tl_x, tl_y, br_x, br_y) and the
5-th column is a score between 0 and 1.
"""
cfg = self.test_cfg if cfg is None else cfg
assert len(cls_score_list) == len(bbox_pred_list) == len(mlvl_anchors)
mlvl_bboxes = []
mlvl_scores = []
for cls_score, bbox_pred, anchors in zip(cls_score_list,
bbox_pred_list, mlvl_anchors):
assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
cls_score = cls_score.permute(1, 2,
0).reshape(-1, self.cls_out_channels)
if self.use_sigmoid_cls:
scores = cls_score.sigmoid()
else:
scores = cls_score.softmax(-1)
bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 5)
nms_pre = cfg.get('nms_pre', -1)
if nms_pre > 0 and scores.shape[0] > nms_pre:
if self.use_sigmoid_cls:
max_scores, _ = scores.max(dim=1)
else:
# remind that we set FG labels to [0, num_class-1]
# since mmdet v2.0
# BG cat_id: num_class
max_scores, _ = scores[:, :-1].max(dim=1)
_, topk_inds = max_scores.topk(nms_pre)
anchors = anchors[topk_inds, :]
bbox_pred = bbox_pred[topk_inds, :]
scores = scores[topk_inds, :]
bboxes = self.bbox_coder.decode(anchors,
bbox_pred,
max_shape=img_shape)
mlvl_bboxes.append(bboxes)
mlvl_scores.append(scores)
mlvl_bboxes = torch.cat(mlvl_bboxes)
if rescale:
mlvl_bboxes[:, :4] /= mlvl_bboxes[:, :4].new_tensor(scale_factor)
# mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
mlvl_scores = torch.cat(mlvl_scores)
if self.use_sigmoid_cls:
padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
# mlvl_scores = torch.cat([mlvl_scores, padding], dim=1)
mlvl_scores = torch.cat([padding, mlvl_scores], dim=1)
if with_nms:
# det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores,
# cfg.score_thr, cfg.nms,
# cfg.max_per_img)
det_bboxes, det_labels = multiclass_nms_rbbox(
mlvl_bboxes, mlvl_scores, cfg.score_thr, cfg.nms,
cfg.max_per_img)
else:
raise Exception
return det_bboxes, det_labels
def get_det_bboxes(self,
rois,
cls_score,
bbox_pred,
img_shape,
scale_factor,
rescale=False,
cfg=None):
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
# TODO: check and simplify it
if rois.size(1) == 5:
obbs = hbb2obb_v2(rois[:, 1:])
elif rois.size(1) == 6:
obbs = rois[:, 1:]
else:
print('strange size')
import pdb
pdb.set_trace()
if bbox_pred is not None:
# bboxes = delta2dbbox(rois[:, 1:], bbox_pred, self.target_means,
# self.target_stds, img_shape)
if self.with_module:
dbboxes = delta2dbbox(obbs, bbox_pred, self.target_means,
self.target_stds, img_shape)
else:
dbboxes = delta2dbbox_v3(obbs, bbox_pred, self.target_means,
self.target_stds, img_shape)
else:
# bboxes = rois[:, 1:]
dbboxes = obbs
# TODO: add clip here
if rescale:
# bboxes /= scale_factor
# dbboxes[:, :4] /= scale_factor
dbboxes[:, 0::5] /= scale_factor
dbboxes[:, 1::5] /= scale_factor
dbboxes[:, 2::5] /= scale_factor
dbboxes[:, 3::5] /= scale_factor
# if cfg is None:
# c_device = dbboxes.device
#
# det_bboxes, det_labels = Pesudomulticlass_nms_rbbox(dbboxes, scores,
# 0.05,
# 1000)
#
# return det_bboxes, det_labels
# else:
c_device = dbboxes.device
det_bboxes, det_labels = multiclass_nms_rbbox(dbboxes, scores,
cfg.score_thr, cfg.nms,
cfg.max_per_img)
# det_bboxes = torch.from_numpy(det_bboxes).to(c_device)
# det_labels = torch.from_numpy(det_labels).to(c_device)
# ###########################################################
from mmdet.MARK import PRINT_RBBOX_HEAD_RS_LOSS
if PRINT_RBBOX_HEAD_RS_LOSS:
# pos_inds = pos_inds[0:min(len(pos_inds), 10)]
pred_score = scores
pred_score, pred_label = torch.max(pred_score, dim=1)
# 前景标签
pred_f_indices = pred_label != 0
if torch.sum(pred_f_indices) > 0:
print('#' * 80)
print('for pred score: ', pred_score[pred_f_indices])
print('#' * 80)
# ###########################################################
return det_bboxes, det_labels
