def forward(self, feat, proposals):
ms_scores = []
rois = proposals
for i in range(self.num_stages):
bbox_results = self._bbox_forward(i, feat, rois)
ms_scores.append(bbox_results['cls_score'])
bbox_pred = bbox_results['bbox_pred']
if i < self.num_stages - 1:
bbox_label = bbox_results['cls_score'].argmax(dim=1)
rois = self.regress_by_class(i, rois, bbox_label, bbox_pred)
### bbox_head.get_boxes
cls_score = sum(ms_scores) / self.num_stages
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1)
bbox_head = self.bbox_head[-1]
bboxes = delta2bbox(rois, bbox_pred, bbox_head.bbox_coder.means,
bbox_head.bbox_coder.stds)
num_bboxes = bboxes.shape[0]
scores = scores.unsqueeze(0)
bboxes = bboxes.view(1, num_bboxes, -1, 4)
bboxes = bboxes.repeat(1, 1, bbox_head.num_classes, 1)
bboxes_ext = bboxes.new_zeros((1, num_bboxes, 1, 4))
bboxes = torch.cat([bboxes, bboxes_ext], 2)
num_detections, det_boxes, det_scores, det_classes = self.rcnn_nms(
scores, bboxes, num_bboxes, self.test_cfg.max_per_img)
return num_detections, det_boxes, det_scores, det_classes
def forward(self, feat, proposals):
batch_size = proposals.shape[0]
num_proposals = proposals.shape[1]
rois_pad = mm2trt_util.arange_by_input(proposals, 0).unsqueeze(1)
rois_pad = rois_pad.repeat(1, num_proposals).view(-1, 1)
proposals = proposals.view(-1, 4)
rois = torch.cat([rois_pad, proposals], dim=1)
roi_feats = self.bbox_roi_extractor(
feat[:len(self.bbox_roi_extractor.featmap_strides)], rois)
if self.shared_head is not None:
roi_feats = self.shared_head(roi_feats)
# rcnn
cls_score, bbox_pred = self.bbox_head(roi_feats)
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1)
bboxes = delta2bbox(proposals, bbox_pred,
self.bbox_head.bbox_coder.means,
self.bbox_head.bbox_coder.stds)
scores = scores.view(batch_size, num_proposals, -1)
bboxes = bboxes.view(batch_size, num_proposals, -1, 4)
num_bboxes = bboxes.shape[1]
bboxes_ext = bboxes[:, :, 0:1, :] * 0
bboxes = torch.cat([bboxes, bboxes_ext], 2)
num_detections, det_boxes, det_scores, det_classes = self.rcnn_nms(
scores, bboxes, num_bboxes, self.test_cfg.max_per_img)
return num_detections, det_boxes, det_scores, det_classes
def forward(self, feat, proposals):
zeros = proposals.new_zeros([proposals.shape[0], 1])
rois = torch.cat([zeros, proposals], dim=1)
bbox_cls_feats = self.bbox_roi_extractor(
feat[:self.bbox_roi_extractor.num_inputs], rois)
bbox_reg_feats = self.bbox_roi_extractor(
feat[:self.bbox_roi_extractor.num_inputs],
rois,
roi_scale_factor=self.reg_roi_scale_factor)
if self.shared_head is not None:
bbox_cls_feats = self.shared_head(bbox_cls_feats)
bbox_reg_feats = self.shared_head(bbox_reg_feats)
# rcnn
cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats)
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1)
bboxes = delta2bbox(proposals, bbox_pred,
self.bbox_head.bbox_coder.means,
self.bbox_head.bbox_coder.stds)
num_bboxes = bboxes.shape[0]
scores = scores.unsqueeze(0)
bboxes = bboxes.view(1, num_bboxes, -1, 4)
bboxes_ext = bboxes.new_zeros((1, num_bboxes, 1, 4))
bboxes = torch.cat([bboxes, bboxes_ext], 2)
num_detections, det_boxes, det_scores, det_classes = self.rcnn_nms(
scores, bboxes, num_bboxes, self.test_cfg.max_per_img)
return num_detections, det_boxes, det_scores, det_classes
def regress_by_class(self, stage, rois, label, bbox_pred):
bbox_head = self.bbox_head[stage]
reg_class_agnostic = bbox_head.reg_class_agnostic
if not reg_class_agnostic:
label = label * 4
inds = torch.stack((label, label + 1, label + 2, label + 3), 1)
bbox_pred = torch.gather(bbox_pred, 1, inds)
means = bbox_head.bbox_coder.means
stds = bbox_head.bbox_coder.stds
new_rois = delta2bbox(rois, bbox_pred, means, stds)
return new_rois
def forward(self, feat, proposals):
ms_scores = []
batch_size = proposals.shape[0]
num_proposals = proposals.shape[1]
rois_pad = mm2trt_util.arange_by_input(proposals, 0).unsqueeze(1)
rois_pad = rois_pad.repeat(1, num_proposals).view(-1, 1)
proposals = proposals.view(-1, 4)
rois = proposals
for i in range(self.num_stages):
bbox_results = self._bbox_forward(
i, feat, torch.cat([rois_pad, rois], dim=1))
ms_scores.append(bbox_results['cls_score'])
bbox_pred = bbox_results['bbox_pred']
if i < self.num_stages - 1:
bbox_label = bbox_results['cls_score'].argmax(dim=1)
rois = self.regress_by_class(i, rois, bbox_label, bbox_pred)
### bbox_head.get_boxes
cls_score = sum(ms_scores) / self.num_stages
if isinstance(cls_score, list):
cls_score = sum(cls_score) / float(len(cls_score))
scores = F.softmax(cls_score, dim=1)
bbox_head = self.bbox_head[-1]
bboxes = delta2bbox(rois, bbox_pred, bbox_head.bbox_coder.means,
bbox_head.bbox_coder.stds)
scores = scores.view(batch_size, num_proposals, -1)
bboxes = bboxes.view(batch_size, num_proposals, -1, 4)
bboxes = bboxes.repeat(1, 1, bbox_head.num_classes, 1)
bboxes_ext = bboxes[:, :, 0:1, :] * 0
bboxes = torch.cat([bboxes, bboxes_ext], 2)
num_bboxes = bboxes.shape[1]
num_detections, det_boxes, det_scores, det_classes = self.rcnn_nms(
scores, bboxes, num_bboxes, self.test_cfg.max_per_img)
return num_detections, det_boxes, det_scores, det_classes
def delta2bbox_custom_func(cls_scores, bbox_preds, anchors,
min_num_bboxes, num_classes, use_sigmoid_cls,
target_mean, target_std, input_x=None):
rpn_cls_score = cls_scores.squeeze(0)
rpn_bbox_pred = bbox_preds.squeeze(0)
anchors = anchors.squeeze(0)
# rpn_cls_score = rpn_cls_score.permute(0, 2, 3, 1)
rpn_cls_score = rpn_cls_score.permute(1, 2, 0)
if use_sigmoid_cls:
# rpn_cls_score = rpn_cls_score.reshape(-1)
scores = rpn_cls_score.sigmoid()
else:
rpn_cls_score = rpn_cls_score.reshape(-1, num_classes)
scores = rpn_cls_score.softmax(dim=1)
rpn_bbox_pred = rpn_bbox_pred.permute(1, 2, 0).reshape(-1, 4)
# anchors = mlvl_anchors[idx]
img_meta = None
if input_x is not None:
height, width = input_x.shape[2:]
img_meta = (height, width)
proposals = delta2bbox(anchors, rpn_bbox_pred, target_mean,
target_std, img_meta)
scores = scores.contiguous().view(1,-1, num_classes)
proposals = proposals.view(1, -1, 4)
if scores.shape[1]<min_num_bboxes:
pad_size = min_num_bboxes-scores.shape[1]
scores = torch.nn.functional.pad(scores, [0, 0, 0, pad_size, 0, 0], mode='constant', value=0)
proposals = torch.nn.functional.pad(proposals, [0, 0, 0, pad_size, 0, 0], mode='constant', value=0)
proposals = proposals.view(1, -1, 1, 4)
return scores, proposals
def bbox_target_single_tsd(
pos_bboxes,
neg_bboxes,
pos_gt_bboxes,
pos_gt_labels,
rois,
delta_c,
delta_r,
cls_score_,
bbox_pred_,
TSD_cls_score_,
TSD_bbox_pred_,
cfg,
reg_classes=1,
cls_pc_margin=0.2,
loc_pc_margin=0.2,
target_means=[0.0, 0.0, 0.0, 0.0],
target_stds=[1.0, 1.0, 1.0, 1.0],
):
num_pos = pos_bboxes.size(0)
num_neg = neg_bboxes.size(0)
num_samples = num_pos + num_neg
labels = pos_bboxes.new_zeros(num_samples, dtype=torch.long)
label_weights = pos_bboxes.new_zeros(num_samples)
bbox_targets = pos_bboxes.new_zeros(num_samples, 4)
bbox_weights = pos_bboxes.new_zeros(num_samples, 4)
TSD_labels = pos_bboxes.new_zeros(num_samples, dtype=torch.long)
TSD_label_weights = pos_bboxes.new_zeros(num_samples)
TSD_bbox_targets = pos_bboxes.new_zeros(num_samples, 4)
TSD_bbox_weights = pos_bboxes.new_zeros(num_samples, 4)
# generte P_r according to delta_r and rois
w = rois[:, 3] - rois[:, 1] + 1
h = rois[:, 4] - rois[:, 2] + 1
scale = 0.1
rois_r = rois.new_zeros(rois.shape[0], rois.shape[1])
rois_r[:, 0] = rois[:, 0]
rois_r[:, 1] = rois[:, 1] + delta_r[:, 0] * scale * w
rois_r[:, 2] = rois[:, 2] + delta_r[:, 1] * scale * h
rois_r[:, 3] = rois[:, 3] + delta_r[:, 0] * scale * w
rois_r[:, 4] = rois[:, 4] + delta_r[:, 1] * scale * h
TSD_pos_rois = rois_r[:num_pos]
pos_rois = rois[:num_pos]
pc_cls_loss = rois.new_zeros(1)
pc_loc_loss = rois.new_zeros(1)
if num_pos > 0:
labels[:num_pos] = pos_gt_labels
TSD_labels[:num_pos] = pos_gt_labels
pos_weight = 1.0 if cfg.pos_weight <= 0 else cfg.pos_weight
label_weights[:num_pos] = pos_weight
TSD_label_weights[:num_pos] = pos_weight
pos_bbox_targets = bbox2delta(pos_bboxes, pos_gt_bboxes, target_means,
target_stds)
TSD_pos_bbox_targets = bbox2delta(TSD_pos_rois[:, 1:], pos_gt_bboxes,
target_means, target_stds)
bbox_targets[:num_pos, :] = pos_bbox_targets
bbox_weights[:num_pos, :] = 1
TSD_bbox_targets[:num_pos, :] = TSD_pos_bbox_targets
TSD_bbox_weights[:num_pos, :] = 1
# compute PC for TSD
# 1. compute the PC for classification
cls_score_soft = F.softmax(cls_score_, dim=1)
TSD_cls_score_soft = F.softmax(TSD_cls_score_, dim=1)
cls_pc_margin = (torch.tensor(cls_pc_margin).to(
labels.device).to(dtype=cls_score_soft.dtype))
cls_pc_margin = torch.min(
1 - cls_score_soft[np.arange(len(TSD_labels)), labels],
cls_pc_margin).detach()
pc_cls_loss = F.relu(
-(TSD_cls_score_soft[np.arange(len(TSD_labels)), TSD_labels] -
cls_score_soft[np.arange(len(TSD_labels)), labels].detach() -
cls_pc_margin))
# 2. compute the PC for localization
N = bbox_pred_.shape[0]
bbox_pred_ = bbox_pred_.view(N, -1, 4)
TSD_bbox_pred_ = TSD_bbox_pred_.view(N, -1, 4)
sibling_head_bboxes = delta2bbox(
pos_bboxes,
bbox_pred_[np.arange(num_pos), labels[:num_pos]],
means=target_means,
stds=target_stds,
)
TSD_head_bboxes = delta2bbox(
TSD_pos_rois[:, 1:],
TSD_bbox_pred_[np.arange(num_pos), TSD_labels[:num_pos]],
means=target_means,
stds=target_stds,
)
ious, gious = iou_overlaps(sibling_head_bboxes, pos_gt_bboxes)
TSD_ious, TSD_gious = iou_overlaps(TSD_head_bboxes, pos_gt_bboxes)
loc_pc_margin = torch.tensor(loc_pc_margin).to(
ious.device).to(dtype=ious.dtype)
loc_pc_margin = torch.min(1 - ious.detach(), loc_pc_margin).detach()
pc_loc_loss = F.relu(-(TSD_ious - ious.detach() - loc_pc_margin))
if num_neg > 0:
label_weights[-num_neg:] = 1.0
TSD_label_weights[-num_neg:] = 1.0
return (
labels,
label_weights,
bbox_targets,
bbox_weights,
TSD_labels,
TSD_label_weights,
TSD_bbox_targets,
TSD_bbox_weights,
pc_cls_loss,
pc_loc_loss,
)