检测算法中的损失函数

深碍√TFBOYSˉ_ 2022-03-01 06:54 394阅读 0赞

  • faster rcnn训练可分为交替训练和多任务训练两种方式，后者损失的计算过程可参看train.py，

    RPN

    1.     # classification loss
    2.     rpn_cls_score = tf.reshape(self.net.get_output('rpn_cls_score_reshape'),[-1,2])
    3.     rpn_label = tf.reshape(self.net.get_output('rpn-data')[0],[-1])
    4.     rpn_cls_score = tf.reshape(tf.gather(rpn_cls_score,tf.where(tf.not_equal(rpn_label,-1))),[-1,2])
    5.     rpn_label = tf.reshape(tf.gather(rpn_label,tf.where(tf.not_equal(rpn_label,-1))),[-1])
    6.     rpn_cross_entropy = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=rpn_cls_score, labels=rpn_label))
    8.     # bounding box regression L1 loss
    9.     rpn_bbox_pred = self.net.get_output('rpn_bbox_pred')
    10.     rpn_bbox_targets = tf.transpose(self.net.get_output('rpn-data')[1],[0,2,3,1])
    11.     rpn_bbox_inside_weights = tf.transpose(self.net.get_output('rpn-data')[2],[0,2,3,1])
    12.     rpn_bbox_outside_weights = tf.transpose(self.net.get_output('rpn-data')[3],[0,2,3,1])
    14.     rpn_smooth_l1 = self._modified_smooth_l1(3.0, rpn_bbox_pred, rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights)
    15.     rpn_loss_box = tf.reduce_mean(tf.reduce_sum(rpn_smooth_l1, reduction_indices=[1, 2, 3]))
    17.     # R-CNN
    18.     # classification loss
    19.     cls_score = self.net.get_output('cls_score')
    20.     label = tf.reshape(self.net.get_output('roi-data')[1],[-1])
    21.     cross_entropy = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=cls_score, labels=label))
    23.     # bounding box regression L1 loss
    24.     bbox_pred = self.net.get_output('bbox_pred')
    25.     bbox_targets = self.net.get_output('roi-data')[2]
    26.     bbox_inside_weights = self.net.get_output('roi-data')[3]
    27.     bbox_outside_weights = self.net.get_output('roi-data')[4]
    29.     smooth_l1 = self._modified_smooth_l1(1.0, bbox_pred, bbox_targets, bbox_inside_weights, bbox_outside_weights)
    30.     loss_box = tf.reduce_mean(tf.reduce_sum(smooth_l1, reduction_indices=[1]))
    32.     # final loss
    33.     loss = cross_entropy + loss_box + rpn_cross_entropy + rpn_loss_box

  • darknet损失的计算过程可参看network.c

    void calc_network_cost(network *netp)
    {

    1. network net = *netp;
    2. int i;
    3. float sum = 0;
    4. int count = 0;
    5. for(i = 0; i < net.n; ++i){
    6.     if(net.layers[i].cost){
    7.         sum += net.layers[i].cost[0];
    8.         ++count;
    9.     }
    10. }
    11. *net.cost = sum/count;

    }

  • pytorch-yolo2的损失函数可参考该函数region_loss.py，也可参考yolo2-pytorch项目中的darknet.py(line216行for training部分)

    def forward(self, output, target):

    1.     #output : BxAs*(4+1+num_classes)*H*W
    2.     t0 = time.time()
    3.     nB = output.data.size(0)
    4.     nA = self.num_anchors
    5.     nC = self.num_classes
    6.     nH = output.data.size(2)
    7.     nW = output.data.size(3)
    9.     output   = output.view(nB, nA, (5+nC), nH, nW)#batch*anchor*(5+nc)*feature_map分辨率转换数据维度
    10.     x    = F.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([0]))).view(nB, nA, nH, nW))
    11.     y    = F.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([1]))).view(nB, nA, nH, nW))
    12.     w    = output.index_select(2, Variable(torch.cuda.LongTensor([2]))).view(nB, nA, nH, nW)
    13.     h    = output.index_select(2, Variable(torch.cuda.LongTensor([3]))).view(nB, nA, nH, nW)
    14.     conf = F.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([4]))).view(nB, nA, nH, nW)) #网络输出的检测参数的结果
    15.     cls  = output.index_select(2, Variable(torch.linspace(5,5+nC-1,nC).long().cuda()))
    16.     cls  = cls.view(nB*nA, nC, nH*nW).transpose(1,2).contiguous().view(nB*nA*nH*nW, nC) #识别类别
    17.     t1 = time.time()
    19.     pred_boxes = torch.cuda.FloatTensor(4, nB*nA*nH*nW)
    20.     grid_x = torch.linspace(0, nW-1, nW).repeat(nH,1).repeat(nB*nA, 1, 1).view(nB*nA*nH*nW).cuda()
    21.     grid_y = torch.linspace(0, nH-1, nH).repeat(nW,1).t().repeat(nB*nA, 1, 1).view(nB*nA*nH*nW).cuda()
    22.     anchor_w = torch.Tensor(self.anchors).view(nA, self.anchor_step).index_select(1, torch.LongTensor([0])).cuda()
    23.     anchor_h = torch.Tensor(self.anchors).view(nA, self.anchor_step).index_select(1, torch.LongTensor([1])).cuda()
    24.     anchor_w = anchor_w.repeat(nB, 1).repeat(1, 1, nH*nW).view(nB*nA*nH*nW)
    25.     anchor_h = anchor_h.repeat(nB, 1).repeat(1, 1, nH*nW).view(nB*nA*nH*nW)
    26.     pred_boxes[0] = x.data + grid_x
    27.     pred_boxes[1] = y.data + grid_y #相对输出feature map栅格的坐标偏移
    28.     pred_boxes[2] = torch.exp(w.data) * anchor_w
    29.     pred_boxes[3] = torch.exp(h.data) * anchor_h #相对于anchor的宽高比
    30.     pred_boxes = convert2cpu(pred_boxes.transpose(0,1).contiguous().view(-1,4)) #转换为nB*nA*nH*nW  乘以 4的二维向量
    31.     t2 = time.time()
    33.     nGT, nCorrect, coord_mask, conf_mask, cls_mask, tx, ty, tw, th, tconf,tcls = build_targets(pred_boxes, target.data, self.anchors, nA, nC, \
    34.                                                            nH, nW, self.noobject_scale, self.object_scale, self.thresh, self.seen)
    35.     cls_mask = (cls_mask == 1)
    36.     nProposals = int((conf > 0.25).sum().data[0])
    38.     tx    = Variable(tx.cuda())
    39.     ty    = Variable(ty.cuda())
    40.     tw    = Variable(tw.cuda())
    41.     th    = Variable(th.cuda())
    42.     tconf = Variable(tconf.cuda())
    43.     tcls  = Variable(tcls.view(-1)[cls_mask].long().cuda())
    45.     coord_mask = Variable(coord_mask.cuda())
    46.     conf_mask  = Variable(conf_mask.cuda().sqrt())
    47.     cls_mask   = Variable(cls_mask.view(-1, 1).repeat(1,nC).cuda())
    48.     cls        = cls[cls_mask].view(-1, nC)  
    50.     t3 = time.time()
    52.     loss_x = self.coord_scale * nn.MSELoss(size_average=False)(x*coord_mask, tx*coord_mask)/2.0
    53.     loss_y = self.coord_scale * nn.MSELoss(size_average=False)(y*coord_mask, ty*coord_mask)/2.0
    54.     loss_w = self.coord_scale * nn.MSELoss(size_average=False)(w*coord_mask, tw*coord_mask)/2.0
    55.     loss_h = self.coord_scale * nn.MSELoss(size_average=False)(h*coord_mask, th*coord_mask)/2.0
    56.     loss_conf = nn.MSELoss(size_average=False)(conf*conf_mask, tconf*conf_mask)/2.0 #边界框的置信度
    57.     loss_cls = self.class_scale * nn.CrossEntropyLoss(size_average=False)(cls, tcls) #分类结果
    58.     loss = loss_x + loss_y + loss_w + loss_h + loss_conf + loss_cls

  • PyTorch-YOLOv3的损失函数可参考models.py文件

    Get outputs

    1.     x = torch.sigmoid(prediction[..., 0])  # Center x
    2.     y = torch.sigmoid(prediction[..., 1])  # Center y
    3.     w = prediction[..., 2]  # Width
    4.     h = prediction[..., 3]  # Height
    5.     pred_conf = torch.sigmoid(prediction[..., 4])  # Conf
    6.     pred_cls = torch.sigmoid(prediction[..., 5:])  # Cls pred.
    8.     # Calculate offsets for each grid
    9.     grid_x = torch.arange(nG).repeat(nG, 1).view([1, 1, nG, nG]).type(FloatTensor)
    10.     grid_y = torch.arange(nG).repeat(nG, 1).t().view([1, 1, nG, nG]).type(FloatTensor)
    11.     scaled_anchors = FloatTensor([(a_w / stride, a_h / stride) for a_w, a_h in self.anchors])
    12.     anchor_w = scaled_anchors[:, 0:1].view((1, nA, 1, 1))
    13.     anchor_h = scaled_anchors[:, 1:2].view((1, nA, 1, 1))
    15.     # Add offset and scale with anchors
    16.     pred_boxes = FloatTensor(prediction[..., :4].shape)
    17.     pred_boxes[..., 0] = x.data + grid_x
    18.     pred_boxes[..., 1] = y.data + grid_y
    19.     pred_boxes[..., 2] = torch.exp(w.data) * anchor_w
    20.     pred_boxes[..., 3] = torch.exp(h.data) * anchor_h
    22.     # Training
    23.     if targets is not None:
    25.         if x.is_cuda:
    26.             self.mse_loss = self.mse_loss.cuda()
    27.             self.bce_loss = self.bce_loss.cuda()
    28.             self.ce_loss = self.ce_loss.cuda()
    30.         nGT, nCorrect, mask, conf_mask, tx, ty, tw, th, tconf, tcls = build_targets(
    31.             pred_boxes=pred_boxes.cpu().data,
    32.             pred_conf=pred_conf.cpu().data,
    33.             pred_cls=pred_cls.cpu().data,
    34.             target=targets.cpu().data,
    35.             anchors=scaled_anchors.cpu().data,
    36.             num_anchors=nA,
    37.             num_classes=self.num_classes,
    38.             grid_size=nG,
    39.             ignore_thres=self.ignore_thres,
    40.             img_dim=self.image_dim,
    41.         )
    43.         nProposals = int((pred_conf > 0.5).sum().item())
    44.         recall = float(nCorrect / nGT) if nGT else 1
    45.         precision = float(nCorrect / nProposals)
    47.         # Handle masks
    48.         mask = Variable(mask.type(ByteTensor))
    49.         conf_mask = Variable(conf_mask.type(ByteTensor))
    51.         # Handle target variables
    52.         tx = Variable(tx.type(FloatTensor), requires_grad=False)
    53.         ty = Variable(ty.type(FloatTensor), requires_grad=False)
    54.         tw = Variable(tw.type(FloatTensor), requires_grad=False)
    55.         th = Variable(th.type(FloatTensor), requires_grad=False)
    56.         tconf = Variable(tconf.type(FloatTensor), requires_grad=False)
    57.         tcls = Variable(tcls.type(LongTensor), requires_grad=False)
    59.         # Get conf mask where gt and where there is no gt
    60.         conf_mask_true = mask
    61.         conf_mask_false = conf_mask - mask
    63.         # Mask outputs to ignore non-existing objects
    64.         loss_x = self.mse_loss(x[mask], tx[mask])
    65.         loss_y = self.mse_loss(y[mask], ty[mask])
    66.         loss_w = self.mse_loss(w[mask], tw[mask])
    67.         loss_h = self.mse_loss(h[mask], th[mask])
    68.         loss_conf = self.bce_loss(pred_conf[conf_mask_false], tconf[conf_mask_false]) + self.bce_loss(
    69.             pred_conf[conf_mask_true], tconf[conf_mask_true]
    70.         )
    71.         loss_cls = (1 / nB) * self.ce_loss(pred_cls[mask], torch.argmax(tcls[mask], 1))
    72.         loss = loss_x + loss_y + loss_w + loss_h + loss_conf + loss_cls

  • ssd.pytorch的损失函数可参考文件multibox_loss.py

    Localization Loss (Smooth L1)

    1.     # Shape: [batch,num_priors,4]
    2.     pos_idx = pos.unsqueeze(pos.dim()).expand_as(loc_data)
    3.     loc_p = loc_data[pos_idx].view(-1, 4)
    4.     loc_t = loc_t[pos_idx].view(-1, 4)
    5.     loss_l = F.smooth_l1_loss(loc_p, loc_t, size_average=False)
    7.     # Compute max conf across batch for hard negative mining
    8.     batch_conf = conf_data.view(-1, self.num_classes)
    9.     loss_c = log_sum_exp(batch_conf) - batch_conf.gather(1, conf_t.view(-1, 1))
    11.     # Hard Negative Mining
    12.     loss_c[pos] = 0  # filter out pos boxes for now
    13.     loss_c = loss_c.view(num, -1)
    14.     _, loss_idx = loss_c.sort(1, descending=True)
    15.     _, idx_rank = loss_idx.sort(1)
    16.     num_pos = pos.long().sum(1, keepdim=True)
    17.     num_neg = torch.clamp(self.negpos_ratio*num_pos, max=pos.size(1)-1)
    18.     neg = idx_rank < num_neg.expand_as(idx_rank)
    20.     # Confidence Loss Including Positive and Negative Examples
    21.     pos_idx = pos.unsqueeze(2).expand_as(conf_data)
    22.     neg_idx = neg.unsqueeze(2).expand_as(conf_data)
    23.     conf_p = conf_data[(pos_idx+neg_idx).gt(0)].view(-1, self.num_classes)
    24.     targets_weighted = conf_t[(pos+neg).gt(0)]
    25.     loss_c = F.cross_entropy(conf_p, targets_weighted, size_average=False)
    27.     # Sum of losses: L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N
    29.     N = num_pos.data.sum()
    30.     loss_l /= N
    31.     loss_c /= N
    32.     return loss_l, loss_c

参考文献：

  1. https://github.com/smallcorgi/Faster-RCNN_TF
  2. https://github.com/pjreddie/darknet
  3. https://github.com/marvis/pytorch-yolo2
  4. https://github.com/longcw/yolo2-pytorch
  5. https://github.com/eriklindernoren/PyTorch-YOLOv3
  6. https://github.com/amdegroot/ssd.pytorch

发表评论

表情：
评论列表 （有 0 条评论，394人围观）

还没有评论，来说两句吧...

相关阅读