def forward(self, node_preds, edge_preds, gts): node_gts, edge_gts = [], [] for gt in gts: node_gts.append(gt[:, 0]) edge_gts.append(gt[:, 1:].contiguous().view(-1)) node_gts = torch.cat(node_gts).long() edge_gts = torch.cat(edge_gts).long() node_valids = torch.nonzero(node_gts != self.ignore).view(-1) edge_valids = torch.nonzero(edge_gts != -1).view(-1) return dict( loss_node=self.node_weight * self.loss_node(node_preds, node_gts), loss_edge=self.edge_weight * self.loss_edge(edge_preds, edge_gts), acc_node=accuracy(node_preds[node_valids], node_gts[node_valids]), acc_edge=accuracy(edge_preds[edge_valids], edge_gts[edge_valids]))
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if cls_score is not None: # avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) # if cls_score.numel() > 0: # losses['loss_cls'] = self.loss_cls( # cls_score, # labels, # label_weights, # avg_factor=avg_factor, # reduction_override=reduction_override) # losses['acc'] = accuracy(cls_score, labels) # Original label_weights is 1 for each roi. new_labels, new_weights, new_avgfactors = self._remap_labels( labels) new_preds = self._slice_preds(cls_score) num_bins = len(new_labels) for i in range(num_bins): losses['loss_cls_bin{}'.format(i)] = self.loss_bins[i]( new_preds[i], new_labels[i].long(), new_weights[i], avg_factor=new_avgfactors[i], reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred.sum() * 0 return losses
def loss(self, cls_score, bbox_pred, dist, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None, img_metas=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred[pos_inds].sum() # embedding loss for repmet ''' if dist is not None: mask_label = torch.eye(self.num_classes + 1)[labels.long(),:].to(labels.device) gt_dist = torch.masked_select(dist, mask_label.bool()) neg_dist = torch.masked_select(dist, ~mask_label.bool()) neg_dist = neg_dist.reshape(labels.shape[0], self.num_classes) neg_dist = torch.min(neg_dist, dim = 1)[0] embedding_dist = gt_dist + self.alpha - neg_dist embedding_dist = torch.masked_select(embedding_dist, embedding_dist.ge(0)) embedding_loss = torch.sum(embedding_dist) / embedding_dist.shape[0] losses['loss_embedding'] = embedding_loss ''' return losses
def loss_labels(self, outputs, targets, indices, num_boxes, log=True): """Classification loss (NLL) targets dicts must contain the key "labels" containing a tensor of dim [nb_target_boxes] """ assert 'pred_logits' in outputs src_logits = outputs['pred_logits'] idx = self._get_src_permutation_idx(indices) target_classes_o = torch.cat( [t["labels"][J] for t, (_, J) in zip(targets, indices)]) target_classes = torch.full(src_logits.shape[:2], self.num_classes, dtype=torch.int64, device=src_logits.device) target_classes[idx] = target_classes_o loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight) losses = {'loss_ce': loss_ce} if log: # TODO this should probably be a separate loss, not hacked in this one here losses['class_error'] = 100 - accuracy(src_logits[idx], target_classes_o)[0] return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: if self.loss_cls_type == "CBLoss": # fg_inds = (labels >= 0) & (labels < self.num_classes) # fg_labels = labels[fg_inds] unique_labels, count = torch.unique(labels, return_counts=True) samples_per_class = torch.zeros(self.num_classes + 1, dtype=torch.int64).cuda() samples_per_class[unique_labels] = count losses['loss_cls'] = self.loss_cls(labels, cls_score, samples_per_class, self.num_classes + 1) else: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] # print("pos_bbox_pred:", pos_bbox_pred) # print("pos_bbox_targets:", bbox_targets[pos_inds.type(torch.bool)]) losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred.sum() * 0 return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: loss_cls_ = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) if isinstance(loss_cls_, dict): losses.update(loss_cls_) else: losses['loss_cls'] = loss_cls_ if self.custom_activation: acc_ = self.loss_cls.get_accuracy(cls_score, labels) losses.update(acc_) else: losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: # When the regression loss (e.g. `IouLoss`, # `GIouLoss`, `DIouLoss`) is applied directly on # the decoded bounding boxes, it decodes the # already encoded coordinates to absolute format. bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred[pos_inds].sum() return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, gt_bboxes=None, img_metas=None, stage=None, reduction_override=None): # # rank, _ = get_dist_info() # # if self.if_save_image and rank == 0 and self.iteration % self.save_interval == 0: if 1: roi_loss_save_images(img_metas, cls_score, bbox_pred, rois, labels, gt_bboxes, self.bbox_coder, stage) losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred[pos_inds].sum() return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # print('bg ind are ') # print(bg_class_ind) # print('labels are') # print(np.unique(labels.cpu())) # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred.sum() * 0 return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bucket_cls_preds, bucket_offset_preds = bbox_pred bucket_cls_targets, bucket_offset_targets = bbox_targets bucket_cls_weights, bucket_offset_weights = bbox_weights # edge cls bucket_cls_preds = bucket_cls_preds.view(-1, self.side_num) bucket_cls_targets = bucket_cls_targets.view(-1, self.side_num) bucket_cls_weights = bucket_cls_weights.view(-1, self.side_num) losses['loss_bbox_cls'] = self.loss_bbox_cls( bucket_cls_preds, bucket_cls_targets, bucket_cls_weights, avg_factor=bucket_cls_targets.size(0), reduction_override=reduction_override) losses['loss_bbox_reg'] = self.loss_bbox_reg( bucket_offset_preds, bucket_offset_targets, bucket_offset_weights, avg_factor=bucket_offset_targets.size(0), reduction_override=reduction_override) return losses
def loss(self, cls_score, bbox_pred, dist, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None, img_metas=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: #大类别分类 cls_score_all = [] for class_index in range(self.num_classes): cls_score_all.append( torch.max(cls_score[:, class_index * 2:(class_index + 1) * 2], dim=1)[0].unsqueeze(1)) cls_score_all.append(cls_score[:, cls_score.shape[1] - 1].unsqueeze(1)) cls_score_all = torch.cat(cls_score_all, dim=1).to(labels.device) losses['loss_cls'] = self.loss_cls( cls_score_all, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score_all, labels) #风格分类 proposal_num_per_pic = 512 styles = torch.zeros(labels.shape[0] // proposal_num_per_pic) for i, meta in enumerate(img_metas): pic = meta['filename'].split('.')[0].split('/')[-1] styles[i] = int(self.file_to_style[pic]) style_labels, cls_score_style = [], [] for proposal in range(labels.shape[0]): if labels[proposal] != 19: # 当前proposal所属的风格 # 每个pic512个proposal style_index = proposal // 512 cur_style = styles[style_index] style_labels.append(cur_style.unsqueeze(0)) cls_score_style.append( cls_score[proposal] [labels[proposal]:labels[proposal] + 2].unsqueeze(0)) style_labels = torch.cat(style_labels, dim=0).to(cls_score.device).long() cls_score_style = torch.cat(cls_score_style, dim=0).to(cls_score.device) label_weights = torch.ones(style_labels.shape[0]).to( cls_score.device) avg_factor = max( torch.sum(label_weights > 0).float().item(), 1.) losses['loss_cls_style'] = self.loss_cls( cls_score_style, style_labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred[pos_inds].sum() return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # print(pos_inds) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 5)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 5)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) # print(pos_bbox_pred, # bbox_targets[pos_inds.type(torch.bool)], # bbox_weights[pos_inds.type(torch.bool)]) else: losses['loss_bbox'] = bbox_pred.sum() * 0 # ########################################################### from mmdet.MARK import PRINT_RBBOX_HEAD_RS_LOSS if torch.sum(pos_inds) > 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 != bg_class_ind # 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['loss_cls'])) 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, imgs_whwh=None, reduction_override=None, **kwargs): """"Loss function of DIIHead, get loss of all images. Args: cls_score (Tensor): Classification prediction results of all class, has shape (batch_size * num_proposals_single_image, num_classes) bbox_pred (Tensor): Regression prediction results, has shape (batch_size * num_proposals_single_image, 4), the last dimension 4 represents [tl_x, tl_y, br_x, br_y]. labels (Tensor): Label of each proposals, has shape (batch_size * num_proposals_single_image label_weights (Tensor): Classification loss weight of each proposals, has shape (batch_size * num_proposals_single_image bbox_targets (Tensor): Regression targets of each proposals, has shape (batch_size * num_proposals_single_image, 4), the last dimension 4 represents [tl_x, tl_y, br_x, br_y]. bbox_weights (Tensor): Regression loss weight of each proposals's coordinate, has shape (batch_size * num_proposals_single_image, 4), imgs_whwh (Tensor): imgs_whwh (Tensor): Tensor with\ shape (batch_size, num_proposals, 4), the last dimension means [img_width,img_height, img_width, img_height]. reduction_override (str, optional): The reduction method used to override the original reduction method of the loss. Options are "none", "mean" and "sum". Defaults to None, Returns: dict[str, Tensor]: Dictionary of loss components """ losses = dict() bg_class_ind = self.num_classes # note in spare rcnn num_gt == num_pos pos_inds = (labels >= 0) & (labels < bg_class_ind) num_pos = pos_inds.sum().float() avg_factor = reduce_mean(num_pos) if cls_score is not None: if cls_score.numel() > 0: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['pos_acc'] = accuracy(cls_score[pos_inds], labels[pos_inds]) if bbox_pred is not None: # 0~self.num_classes-1 are FG, self.num_classes is BG # do not perform bounding box regression for BG anymore. if pos_inds.any(): pos_bbox_pred = bbox_pred.reshape(bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] imgs_whwh = imgs_whwh.reshape(bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred / imgs_whwh, bbox_targets[pos_inds.type(torch.bool)] / imgs_whwh, bbox_weights[pos_inds.type(torch.bool)], avg_factor=avg_factor) losses['loss_iou'] = self.loss_iou( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=avg_factor) else: losses['loss_bbox'] = bbox_pred.sum() * 0 losses['loss_iou'] = bbox_pred.sum() * 0 return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() if bbox_pred is not None: bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred[pos_inds].sum() if cls_score is not None: avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: argspec = inspect.getargspec(self.loss_cls.forward) pos_ious = bbox_overlaps(pos_bbox_pred, bbox_targets[pos_inds.type( torch.bool)], is_aligned=True).clamp(min=1e-7) if 'pos_ious' not in argspec.args: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) else: losses['loss_cls'] = self.loss_cls( cls_score, labels, pos_ious=pos_ious, weight=label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) return losses
def loss(self, similarity_logits, track_id_targets, track_id_weights, reduction_override=None): """Calculate the loss in a batch. Args: similarity_logits (list[Tensor]): The predicted similarity_logits of each pair of key image and reference image. track_id_targets (list[Tensor]): The instance ids of Gt_labels for all proposals in a batch, each tensor in list has shape (num_proposals,). track_id_weights (list[Tensor]): Labels_weights for all proposals in a batch, each tensor in list has shape (num_proposals,). reduction_override (str, optional): The method used to reduce the loss. Options are "none", "mean" and "sum". Returns: dict[str, Tensor]: a dictionary of loss components. """ assert isinstance(similarity_logits, list) assert isinstance(track_id_targets, list) assert isinstance(track_id_weights, list) assert len(similarity_logits) == len(track_id_targets) assert len(track_id_weights) == len(track_id_targets) losses = defaultdict(list) for similarity_logit, track_id_target, track_id_weight in zip( similarity_logits, track_id_targets, track_id_weights): avg_factor = max(torch.sum(track_id_target > 0).float().item(), 1.) if similarity_logit.numel() > 0: loss_match = self.loss_match( similarity_logit, track_id_target, track_id_weight, avg_factor=avg_factor, reduction_override=reduction_override) if isinstance(loss_match, dict): for key, value in loss_match.items(): losses[key].append(value) else: losses['loss_match'].append(loss_match) valid_index = track_id_weight > 0 valid_similarity_logit = similarity_logit[valid_index] valid_track_id_target = track_id_target[valid_index] if self.custom_activation: match_accuracy = self.loss_match.get_accuracy( valid_similarity_logit, valid_track_id_target) for key, value in match_accuracy.items(): losses[key].append(value) else: losses['match_accuracy'].append( accuracy(valid_similarity_logit, valid_track_id_target)) for key, value in losses.items(): losses[key] = sum(losses[key]) / len(similarity_logits) return losses
def loss(self, cls_score, bbox_pred, fix_pred, ratio_pred, rois, labels, label_weights, bbox_targets, bbox_weights, fix_targets, fix_weights, ratio_targets, ratio_weights, reduction_override=None): losses = dict() avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: losses['loss_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['acc'] = accuracy(cls_score, labels) bg_class_ind = self.num_classes # 0~self.num_classes-1 are FG, self.num_classes is BG pos_inds = (labels >= 0) & (labels < bg_class_ind) # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred.sum() * 0 if pos_inds.any(): if self.reg_class_agnostic: pos_fix_pred = fix_pred.view(fix_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_fix_pred = fix_pred.view( fix_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_fix'] = self.loss_fix( pos_fix_pred, fix_targets[pos_inds.type(torch.bool)], fix_weights[pos_inds.type(torch.bool)], avg_factor=fix_targets.size(0), reduction_override=reduction_override) else: losses['loss_fix'] = fix_pred.sum() * 0 if pos_inds.any(): if self.reg_class_agnostic: pos_ratio_pred = ratio_pred.view(ratio_pred.size(0), 1)[pos_inds.type(torch.bool)] else: pos_ratio_pred = ratio_pred.view( ratio_pred.size(0), -1, 1)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_ratio'] = self.loss_ratio( pos_ratio_pred, ratio_targets[pos_inds.type(torch.bool)], ratio_weights[pos_inds.type(torch.bool)], avg_factor=ratio_targets.size(0), reduction_override=reduction_override) else: losses['loss_ratio'] = ratio_pred.sum() * 0 return losses
def loss(self, cls_score, bbox_pred, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() # if cls_score is not None: # avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) # if cls_score.numel() > 0: # losses['loss_cls'] = self.loss_cls( # cls_score, # labels, # label_weights, # avg_factor=avg_factor, # reduction_override=reduction_override) # pos_inds = (labels >= 0) & (labels < self.num_classes) # losses['acc'] = pos_inds.type(torch.float32).sum() # # losses['acc'] = accuracy(cls_score, labels) # if bbox_pred is not None: # bg_class_ind = self.num_classes # # 0~self.num_classes-1 are FG, self.num_classes is BG # pos_inds = (labels >= 0) & (labels < bg_class_ind) # # do not perform bounding box regression for BG anymore. # if pos_inds.any(): # if self.reg_decoded_bbox: # bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) # if self.reg_class_agnostic: # pos_bbox_pred = bbox_pred.view( # bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] # else: # pos_bbox_pred = bbox_pred.view( # bbox_pred.size(0), -1, # 4)[pos_inds.type(torch.bool), # labels[pos_inds.type(torch.bool)]] # losses['loss_bbox'] = self.loss_bbox( # pos_bbox_pred, # bbox_targets[pos_inds.type(torch.bool)], # bbox_weights[pos_inds.type(torch.bool)], # avg_factor=bbox_targets.size(0), # reduction_override=reduction_override) # else: # losses['loss_bbox'] = bbox_pred[pos_inds].sum() bg_class_ind = self.num_classes pos_inds = (labels >= 0) & (labels < bg_class_ind) if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view(-1, 4) losses['loss_bbox'] = self.loss_bbox( pos_bbox_pred[pos_inds.type(torch.bool)], bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) pos_pred_bboxes = self.bbox_coder.decode(rois[pos_inds, 1:], bbox_pred[pos_inds]) pos_target_bboxes = self.bbox_coder.decode(rois[pos_inds, 1:], bbox_targets[pos_inds]) from mmdet.core import bbox_overlaps score = label_weights.new_zeros(labels.shape) score[pos_inds] = bbox_overlaps(pos_pred_bboxes, pos_target_bboxes, is_aligned=True) avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) losses['loss_cls'] = self.loss_cls( cls_score, (labels, score), weight=label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['num'] = pos_inds.type(torch.float32).sum() losses['acc'] = accuracy(cls_score, labels) return losses
def loss(self, okpd_outs, rois, labels, label_weights, bbox_targets, bbox_weights, reduction_override=None): losses = dict() cls_score = okpd_outs[-2] bbox_pred = okpd_outs[-1] bg_class_ind = self.num_classes pos_inds = (labels >= 0) & (labels < bg_class_ind) avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) if cls_score.numel() > 0: losses['loss_okpd_cls'] = self.loss_cls( cls_score, labels, label_weights, avg_factor=avg_factor, reduction_override=reduction_override) losses['okpd_acc'] = accuracy(cls_score, labels) if bbox_pred is not None: # do not perform bounding box regression for BG anymore. if pos_inds.any(): if self.reg_decoded_bbox: bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred) if self.reg_class_agnostic: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), 4)[pos_inds.type(torch.bool)] else: pos_bbox_pred = bbox_pred.view( bbox_pred.size(0), -1, 4)[pos_inds.type(torch.bool), labels[pos_inds.type(torch.bool)]] losses['loss_okpd_bbox'] = self.loss_bbox( pos_bbox_pred, bbox_targets[pos_inds.type(torch.bool)], bbox_weights[pos_inds.type(torch.bool)], avg_factor=bbox_targets.size(0), reduction_override=reduction_override) else: losses['loss_bbox'] = bbox_pred.sum() * 0 if self.num_kp > 0: kp_max_target = torch.zeros_like(okpd_outs[0]) kp_max_target[pos_inds, ...] = 1. kp_max_wts = torch.zeros_like(okpd_outs[0]) + 0.5 fn_inds = (kp_max_target > 0.) & (okpd_outs[0] < 0.5) fp_inds = (kp_max_target < 1.) & (okpd_outs[0] > 0.5) kp_max_wts[fp_inds | fn_inds] = 1.0 Ld_loss = smooth_l1_loss(okpd_outs[0] * kp_max_wts, kp_max_target * kp_max_wts, beta=0.05) pos_mask = pos_inds.float()[:, None, None, None] kp_ch_sum_target = torch.zeros_like(okpd_outs[1]) kp_ch_sum_target[pos_inds, ...] = 1. Lu_loss = smooth_l1_loss(okpd_outs[1] * pos_mask, kp_ch_sum_target * pos_mask, beta=1.0) losses['kp_loss'] = 0.03 * (Ld_loss + Lu_loss) return losses