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