def loss(self,
match_score,
ids,
id_weights,
reduce=True):
losses = dict()
if self.dynamic:
n = len(match_score)
x_n = [s.size(0) for s in match_score]
ids = torch.split(ids, x_n, dim=0)
loss_match = 0.
match_acc = 0.
n_total = 0
batch_size = len(ids)
for score, cur_ids, cur_weights in zip(match_score, ids, id_weights):
valid_idx = torch.nonzero(cur_weights).squeeze()
if len(valid_idx.size()) == 0: continue
n_valid = valid_idx.size(0)
n_total += n_valid
loss_match += weighted_cross_entropy(
score, cur_ids, cur_weights, reduce=reduce)
match_acc += accuracy(torch.index_select(score, 0, valid_idx),
torch.index_select(cur_ids, 0, valid_idx)) * n_valid
losses['loss_match'] = loss_match / n
if n_total > 0:
losses['match_acc'] = match_acc / n_total
else:
if match_score is not None:
valid_idx = torch.nonzero(cur_weights).squeeze()
losses['loss_match'] = weighted_cross_entropy(
match_score, ids, id_weights, reduce=reduce)
losses['match_acc'] = accuracy(torch.index_select(match_score, 0, valid_idx),
torch.index_select(ids, 0, valid_idx))
return losses
def loss(self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduce=True,
img_meta_2=None,
img_meta_3=None):
losses = dict()
if cls_score is not None:
if img_meta_3 is not None:
losses['loss_cls_3'] = weighted_cross_entropy(cls_score,
labels,
label_weights,
reduce=reduce)
losses['acc_3'] = accuracy(cls_score, labels)
elif img_meta_2 is not None:
losses['loss_cls_2'] = weighted_cross_entropy(cls_score,
labels,
label_weights,
reduce=reduce)
losses['acc_2'] = accuracy(cls_score, labels)
else:
losses['loss_cls'] = weighted_cross_entropy(cls_score,
labels,
label_weights,
reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
pos_inds = labels > 0
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 6)[pos_inds]
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
6)[pos_inds, labels[pos_inds]]
if img_meta_3 is not None:
losses['loss_reg_3'] = weighted_smoothl1(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
elif img_meta_2 is not None:
losses['loss_reg_2'] = weighted_smoothl1(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
else:
losses['loss_reg'] = weighted_smoothl1(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
return losses
def loss(self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduce=True):
losses = dict()
if cls_score is not None:
losses['rbbox_loss_cls'] = self.loss_cls(cls_score,
labels,
label_weights,
reduce=reduce)
losses['rbbox_acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
pos_inds = labels > 0
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 8)[pos_inds]
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
8)[pos_inds, labels[pos_inds]]
losses['rbbox_loss_bbox'] = self.loss_bbox(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
return losses
def loss(
self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduce=True,
):
losses = dict()
if cls_score is not None:
losses["loss_cls"] = weighted_cross_entropy(cls_score,
labels,
label_weights,
reduce=reduce)
losses["acc"] = accuracy(cls_score, labels)
if bbox_pred is not None:
pos_inds = labels > 0
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 4)[pos_inds]
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
4)[pos_inds, labels[pos_inds]]
losses["loss_reg"] = weighted_smoothl1(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0),
)
return losses
def loss(self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
mix_inds=None,
reduce=True):
losses = dict()
if cls_score is not None:
losses['loss_cls'] = weighted_cross_entropy(cls_score,
labels,
label_weights,
mix_inds=mix_inds,
reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
losses['loss_reg'] = weighted_smoothl1(
bbox_pred,
bbox_targets,
bbox_weights,
mix_inds=mix_inds,
avg_factor=bbox_targets.size(0))
return losses
def loss(self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduce=True):
losses = dict()
if cls_score is not None:
losses['loss_cls'] = self.cls_loss_func(cls_score,
labels,
label_weights,
reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
if labels.dim() == 1:
pos_inds = labels > 0
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0),
4)[pos_inds]
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
4)[pos_inds,
labels[pos_inds]]
loss = weighted_smoothl1(pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
else:
x = torch.nonzero(labels > 0)
if x.numel() == 0:
loss = 0
else:
sampled_pos_inds_subset, labels_pos = x[:, 0], x[:, 1]
if self.reg_class_agnostic:
map_inds = torch.tensor([0, 1, 2, 3],
device=bbox_pred.device)
else:
map_inds = 4 * labels_pos[:, None] + torch.tensor(
[0, 1, 2, 3], device=bbox_pred.device)
sampled_box_regression = bbox_pred[
sampled_pos_inds_subset[:, None], map_inds]
sampled_box_target = bbox_targets[sampled_pos_inds_subset]
sampled_bbox_weights = bbox_weights[
sampled_pos_inds_subset]
loss = weighted_smoothl1(sampled_box_regression,
sampled_box_target,
sampled_bbox_weights,
avg_factor=bbox_targets.size(0))
losses['loss_reg'] = loss
return losses
def loss(self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduce=True):
losses = dict()
if cls_score is not None:
losses['loss_cls'] = weighted_cross_entropy(cls_score,
labels,
label_weights,
reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
return losses
def loss(self,
cls_score,
bbox_pred,
proposals,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduce=True):
losses = dict()
if cls_score is not None:
losses['rbbox_loss_cls'] = self.loss_cls(cls_score,
labels,
label_weights,
reduce=reduce)
losses['rbbox_acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
pos_inds = labels > 0
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 8)[pos_inds]
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
8)[pos_inds, labels[pos_inds]]
with torch.no_grad():
pred_bbox = delta2bbox_APE(proposals, bbox_pred,
self.target_means, self.target_stds)
gt_obbs = delta2bbox_APE(proposals, bbox_targets,
self.target_means, self.target_stds)
# overlaps = rbbox_overlaps_cy_warp(pred_bbox.cpu().numpy(), gt_obbs)
# overlaps = overlaps.diag().reshape(-1,1).float()
# overlaps = overlaps.clamp(1e-4, 1.0)
# iou_factor = -1*torch.log(overlaps)
losses['rbbox_loss_bbox'] = self.loss_bbox(
pos_bbox_pred,
bbox_targets[pos_inds],
pred_bbox[pos_inds],
gt_obbs[pos_inds],
# iou_factor[pos_inds])
bbox_weights[pos_inds])
# bbox_weights[pos_inds,:1].reshape(-1,1))
return losses
def loss(self, cls_score, bbox_pred, A_pred, A_gt, labels, label_weights, bbox_targets,
bbox_weights, reduce=True):
losses = dict()
if cls_score is not None:
losses['loss_cls'] = weighted_cross_entropy(
cls_score, labels, label_weights, reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
losses['loss_reg'] = weighted_smoothl1(
bbox_pred,
bbox_targets,
bbox_weights,
avg_factor=bbox_targets.size(0))
if A_pred:
assert len(A_pred) == len(A_gt)
assert A_pred[0].size() == A_gt[0].size()
num_a_pred = len(A_pred)
for i in range(num_a_pred):
losses['loss_adj' + str(i)] = F.mse_loss(A_pred[i], A_gt[i].detach())
return losses
def loss(self,
match_score,
shift,
IoUs2,
distances_xy,
ids,
id_weights,
reduce=True):
losses = dict()
if self.dynamic:
n = len(match_score)
x_n = [s.size(0) for s in match_score]
ids = torch.split(ids, x_n, dim=0)
loss_match = 0.
match_acc = 0.
n_total = 0
batch_size = len(ids)
for score, cur_ids, cur_weights in zip(match_score, ids,
id_weights):
valid_idx = torch.nonzero(cur_weights).squeeze()
valid_cls = torch.index_select(cur_ids, 0, valid_idx)
nonzero_ids = valid_cls.clone()
nonzero_ids[nonzero_ids > 0] = 1
#loss_iou = torch.sum((1-IoUs[valid_idx , valid_cls])*nonzero_ids)
#loss_iou = loss_iou/(torch.sum(nonzero_ids)+1e-7)
#print(valid_idx)
valid_iou = IoUs2[valid_idx, valid_cls]
distance_mean = torch.zeros(2,
device=torch.cuda.current_device())
for match_cls in valid_cls.unique():
if match_cls == 0:
continue
valid_iou[(valid_cls == match_cls) & (
valid_iou != valid_iou[valid_cls == match_cls][0])] = 0
valid_iou[valid_iou < 0.7] = 0
valid_xy = distances_xy[:, valid_idx, valid_cls]
#dif_x = valid_xy[0]-shift[0][0]
#dif_y = valid_xy[1]-shift[0][1]
#distance_mean = torch.sum(torch.sqrt(dif_x*dif_x + dif_y*dif_y) * valid_iou / (torch.sum(valid_iou)+1e-7))
if len(valid_idx.size()) == 0: continue
n_valid = valid_idx.size(0)
n_total += n_valid
loss_match += weighted_cross_entropy(score,
cur_ids,
cur_weights,
reduce=reduce)
match_acc += accuracy(torch.index_select(score, 0, valid_idx),
valid_cls) * n_valid
losses['loss_match'] = loss_match / n
if n_total > 0:
losses['match_acc'] = match_acc / n_total
else:
print('not dynamic')
if match_score is not None:
valid_idx = torch.nonzero(cur_weights).squeeze()
losses['loss_match'] = weighted_cross_entropy(match_score,
ids,
id_weights,
reduce=reduce)
losses['match_acc'] = accuracy(
torch.index_select(match_score, 0, valid_idx),
torch.index_select(ids, 0, valid_idx))
return losses
def loss(self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
reduction=True):
losses = dict()
if cls_score is not None:
losses['rbbox_loss_cls'] = self.loss_cls(
cls_score, labels, label_weights)
losses['rbbox_acc'] = accuracy(cls_score, labels)
if bbox_pred is not None:
pos_inds = labels > 0
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 5)[pos_inds]
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
5)[pos_inds, labels[pos_inds]]
losses['rbbox_loss_bbox'] = self.loss_bbox(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
# ###########################################################
from mmdet.MARK import PRINT_RBBOX_HEAD_RS_LOSS
if PRINT_RBBOX_HEAD_RS_LOSS:
if torch.sum(pos_inds) > 0:
pos_inds = labels > 0
# pos_inds = pos_inds[0:min(len(pos_inds), 10)]
pred_score = cls_score[pos_inds].softmax(1)
pred_score, pred_label = torch.max(pred_score, dim=1)
# 前景标签
pred_f_indices = pred_label != 0
# from EXP_CONCONFIG.MARK import PRINT_RBBOX_HEAD
# PRINT_RBBOX_HEAD = True
pos_loss = self.loss_cls(
cls_score[pos_inds], labels[pos_inds], label_weights[pos_inds])
pos_acc = accuracy(cls_score[pos_inds], labels[pos_inds])
if torch.sum(pred_f_indices) > 0:
print('#'*80)
print('pred_score:', pred_score[pred_f_indices].detach().cpu().numpy())
print('pred_label:', pred_label[pred_f_indices].detach().cpu().numpy())
print('gt_label:', labels[pos_inds][pred_f_indices].detach().cpu().numpy())
print('pos loss: %.2f' % float(pos_loss),
' || pos acc: %.2f' % float(pos_acc))
print('total_loss:', float(losses['rbbox_loss_cls']))
print('total_acc:', float(losses['rbbox_acc']))
print('%d, %d' % (int(torch.sum(pos_inds)), len(cls_score)))
print(torch.sum(label_weights))
print('#'*80)
# ###########################################################
return losses
def loss(
self,
cls_score,
bbox_pred,
labels,
label_weights,
bbox_targets,
bbox_weights,
proposal_bboxes, # added by Shengkai Wu
reduce=True):
"""
:param cls_score: tensor of shape (batch*num_samples, num_classes),num_samples = num_pos+num_neg;
store the classification scores;
:param bbox_pred: tensor of shape (batch*num_samples, 4) or (batch*num_samples, num_classes*4)/
if use_iou_prediction is True, (batch*num_samples, 5) or (batch*num_samples, num_classes*5)
:param labels: tensor of shape (batch*num_samples), contain labels for the positives
and 0 for negatives;
:param label_weights: tensor of shape (batch*num_samples), 1 for all the elements;
:param bbox_targets: tensor of shape (batch*num_samples, 4), parametrized coordinates of
ground truth boxes for positives and 0 for negatives;
:param bbox_weights: tensor of shape (batch*num_samples, 4), 1 for positives and 0 for
negatives;
:param proposal_bboxes: tensor of shape (batch*num_samples, 4), coordinates of positive proposals
and 0 for negatives.
:param reduce:
:return:
"""
losses = dict()
# the original implementation of mmdetection
# if cls_score is not None:
# losses['loss_cls'] = self.loss_cls(
# cls_score, labels, label_weights, reduce=reduce)
# losses['acc'] = accuracy(cls_score, labels)
# if bbox_pred is not None:
# pos_inds = labels > 0
# if self.reg_class_agnostic:
# pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 4)[pos_inds]
# else:
# pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
# 4)[pos_inds, labels[pos_inds]]
# losses['loss_bbox'] = self.loss_bbox(
# pos_bbox_pred,
# bbox_targets[pos_inds],
# bbox_weights[pos_inds],
# avg_factor=bbox_targets.size(0))
# add by Shengkai Wu, modified from the original implementation of mmdetection.
# pos_inds = labels > 0
# another way to get the pos_inds
pos_inds = (labels > 0).nonzero().view(-1)
if self.reg_class_agnostic:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0),
4)[pos_inds] # (num_pos, 4)
# print('test')
else:
pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1,
4)[pos_inds,
labels[pos_inds]] # (num_pos, 4)
# print("test: bbox_head")
# compute the iou between predicted boxes and corresponding ground truth
# boxes for positives. The shape of iou is (batch*num_pos)
IoU_balanced_Cls = self.IoU_balanced_Cls
IoU_balanced_Loc = self.IoU_balanced_Loc
if IoU_balanced_Cls or IoU_balanced_Loc:
# ignoring target_mean and target_std will result in wrong target_box and pred_box and thus wrong
# iou.
pred_box = delta2bbox(proposal_bboxes[pos_inds], pos_bbox_pred,
self.target_means, self.target_stds)
target_box = delta2bbox(proposal_bboxes[pos_inds],
bbox_targets[pos_inds], self.target_means,
self.target_stds)
iou = bbox_overlaps(target_box, pred_box,
is_aligned=True) # (num_pos)
# iou = bbox_overlaps(target_box, proposal_bboxes[pos_inds], is_aligned=True)
if bbox_pred is not None:
if IoU_balanced_Loc:
# print('the size of bbox_weights is ', bbox_weights[pos_inds].size())
losses['loss_bbox'] = self.loss_bbox(
pos_bbox_pred,
bbox_targets[pos_inds],
iou,
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
else:
# print('the size of bbox_weights is ', bbox_weights[pos_inds].size())
losses['loss_bbox'] = self.loss_bbox(
pos_bbox_pred,
bbox_targets[pos_inds],
bbox_weights[pos_inds],
avg_factor=bbox_targets.size(0))
if cls_score is not None:
if IoU_balanced_Cls:
iou_extended = bbox_pred.new_zeros(bbox_pred.size(0))
iou_extended[pos_inds] = iou
losses['loss_cls'] = self.loss_cls(cls_score,
labels,
label_weights,
iou_extended,
reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
else:
losses['loss_cls'] = self.loss_cls(cls_score,
labels,
label_weights,
reduce=reduce)
losses['acc'] = accuracy(cls_score, labels)
return losses
