(rois, roi_indices, std, bboxes, labels)
return rois, roi_indices, gt_locs, gt_labels
Loss function for Head (pre).

    This function processes RoIs for :func:`bbox_head_loss_post`.

    Args:
        rois (iterable of arrays): An iterable of arrays of
            shape :math:`(R_l, 4)`, where :math:`R_l` is the number
            of RoIs in the :math:`l`-th feature map.
        roi_indices (iterable of arrays): An iterable of arrays of
            shape :math:`(R_l,)`.
        std (tuple of floats): Two coefficients used for encoding
            bounding boxes.
        bboxes (list of arrays): A list of arrays whose shape is
            :math:`(R_n, 4)`, where :math:`R_n` is the number of
            ground truth bounding boxes.
        labels (list of arrays): A list of arrays whose shape is
            :math:`(R_n,)`.

     Returns:
         tuple of four lists:
         :obj:`rois`, :obj:`roi_indices`, :obj:`gt_locs`, and :obj:`gt_labels`.

          * **rois**: A list of arrays of shape :math:`(R'_l, 4)`, \
              where :math:`R'_l` is the number of RoIs in the :math:`l`-th \
              feature map.
          * **roi_indices**: A list of arrays of shape :math:`(R'_l,)`.
          * **gt_locs**: A list of arrays of shape :math:`(R'_l, 4) \
              indicating the bounding boxes of ground truth.
          * **roi_indices**: A list of arrays of shape :math:`(R'_l,)` \
              indicating the classes of ground truth.
Loss function for Head (pre).
Loss function for Head ( pre ) .
def bbox_head_loss_pre(rois, roi_indices, std, bboxes, labels):
    """Loss function for Head (pre).

    This function processes RoIs for :func:`bbox_head_loss_post`.

    Args:
        rois (iterable of arrays): An iterable of arrays of
            shape :math:`(R_l, 4)`, where :math:`R_l` is the number
            of RoIs in the :math:`l`-th feature map.
        roi_indices (iterable of arrays): An iterable of arrays of
            shape :math:`(R_l,)`.
        std (tuple of floats): Two coefficients used for encoding
            bounding boxes.
        bboxes (list of arrays): A list of arrays whose shape is
            :math:`(R_n, 4)`, where :math:`R_n` is the number of
            ground truth bounding boxes.
        labels (list of arrays): A list of arrays whose shape is
            :math:`(R_n,)`.

     Returns:
         tuple of four lists:
         :obj:`rois`, :obj:`roi_indices`, :obj:`gt_locs`, and :obj:`gt_labels`.

          * **rois**: A list of arrays of shape :math:`(R'_l, 4)`, \
              where :math:`R'_l` is the number of RoIs in the :math:`l`-th \
              feature map.
          * **roi_indices**: A list of arrays of shape :math:`(R'_l,)`.
          * **gt_locs**: A list of arrays of shape :math:`(R'_l, 4) \
              indicating the bounding boxes of ground truth.
          * **roi_indices**: A list of arrays of shape :math:`(R'_l,)` \
              indicating the classes of ground truth.
    """

    thresh = 0.5
    batchsize_per_image = 512
    fg_ratio = 0.25

    xp = cuda.get_array_module(*rois)

    n_level = len(rois)
    roi_levels = xp.hstack(
        xp.array((l,) * len(rois[l])) for l in range(n_level)).astype(np.int32)
    rois = xp.vstack(rois).astype(np.float32)
    roi_indices = xp.hstack(roi_indices).astype(np.int32)

    rois_yx = (rois[:, 2:] + rois[:, :2]) / 2
    rois_hw = rois[:, 2:] - rois[:, :2]
    indices = np.unique(cuda.to_cpu(roi_indices))

    gt_locs = xp.empty_like(rois)
    gt_labels = xp.empty_like(roi_indices)
    for i in indices:
        mask = roi_indices == i

        if len(bboxes[i]) > 0:
            iou = utils.bbox_iou(rois[mask], bboxes[i])
            gt_index = iou.argmax(axis=1)

            gt_loc = bboxes[i][gt_index].copy()
        else:
            gt_loc = xp.empty_like(rois[mask])
        # tlbr -> yxhw
        gt_loc[:, 2:] -= gt_loc[:, :2]
        gt_loc[:, :2] += gt_loc[:, 2:] / 2
        # offset
        gt_loc[:, :2] = (gt_loc[:, :2] - rois_yx[mask]) / \
            rois_hw[mask] / std[0]
        gt_loc[:, 2:] = xp.log(gt_loc[:, 2:] / rois_hw[mask]) / std[1]

        if len(bboxes[i]) > 0:
            gt_label = labels[i][gt_index] + 1
            gt_label[iou.max(axis=1) < thresh] = 0
        else:
            gt_label = xp.zeros(int(mask.sum()), dtype=np.int32)

        fg_index = xp.where(gt_label > 0)[0]
        n_fg = int(batchsize_per_image * fg_ratio)
        if len(fg_index) > n_fg:
            gt_label[choice(fg_index, size=len(fg_index) - n_fg)] = -1

        bg_index = xp.where(gt_label == 0)[0]
        n_bg = batchsize_per_image - int((gt_label > 0).sum())
        if len(bg_index) > n_bg:
            gt_label[choice(bg_index, size=len(bg_index) - n_bg)] = -1

        gt_locs[mask] = gt_loc
        gt_labels[mask] = gt_label

    mask = gt_labels >= 0
    rois = rois[mask]
    roi_indices = roi_indices[mask]
    roi_levels = roi_levels[mask]
    gt_locs = gt_locs[mask]
    gt_labels = gt_labels[mask]

    masks = [roi_levels == l for l in range(n_level)]
    rois = [rois[m] for m in masks]
    roi_indices = [roi_indices[m] for m in masks]
    gt_locs = [gt_locs[m] for m in masks]
    gt_labels = [gt_labels[m] for m in masks]

    return rois, roi_indices, gt_locs, gt_labels
def bbox_head_loss_pre ( rois , roi_indices , std , bboxes , labels ) : thresh = 0.5 batchsize_per_image = 512 fg_ratio = 0.25 xp = cuda . get_array_module ( * rois ) n_level = len ( rois ) roi_levels = xp . hstack ( xp . array ( ( l , ) * len ( rois [ l ] ) ) for l in range ( n_level ) ) . astype ( np . int32 ) rois = xp . vstack ( rois ) . astype ( np . float32 ) roi_indices = xp . hstack ( roi_indices ) . astype ( np . int32 ) rois_yx = ( rois [ : , 2 : ] + rois [ : , : 2 ] ) / 2 rois_hw = rois [ : , 2 : ] - rois [ : , : 2 ] indices = np . unique ( cuda . to_cpu ( roi_indices ) ) gt_locs = xp . empty_like ( rois ) gt_labels = xp . empty_like ( roi_indices ) for i in indices : mask = roi_indices == i if len ( bboxes [ i ] ) > 0 : iou = utils . bbox_iou ( rois [ mask ] , bboxes [ i ] ) gt_index = iou . argmax ( axis = 1 ) gt_loc = bboxes [ i ] [ gt_index ] . copy ( ) else : gt_loc = xp . empty_like ( rois [ mask ] ) # tlbr -> yxhw gt_loc [ : , 2 : ] -= gt_loc [ : , : 2 ] gt_loc [ : , : 2 ] += gt_loc [ : , 2 : ] / 2 # offset gt_loc [ : , : 2 ] = ( gt_loc [ : , : 2 ] - rois_yx [ mask ] ) / rois_hw [ mask ] / std [ 0 ] gt_loc [ : , 2 : ] = xp . log ( gt_loc [ : , 2 : ] / rois_hw [ mask ] ) / std [ 1 ] if len ( bboxes [ i ] ) > 0 : gt_label = labels [ i ] [ gt_index ] + 1 gt_label [ iou . max ( axis = 1 ) < thresh ] = 0 else : gt_label = xp . zeros ( int ( mask . sum ( ) ) , dtype = np . int32 ) fg_index = xp . where ( gt_label > 0 ) [ 0 ] n_fg = int ( batchsize_per_image * fg_ratio ) if len ( fg_index ) > n_fg : gt_label [ choice ( fg_index , size = len ( fg_index ) - n_fg ) ] = - 1 bg_index = xp . where ( gt_label == 0 ) [ 0 ] n_bg = batchsize_per_image - int ( ( gt_label > 0 ) . sum ( ) ) if len ( bg_index ) > n_bg : gt_label [ choice ( bg_index , size = len ( bg_index ) - n_bg ) ] = - 1 gt_locs [ mask ] = gt_loc gt_labels [ mask ] = gt_label mask = gt_labels >= 0 rois = rois [ mask ] roi_indices = roi_indices [ mask ] roi_levels = roi_levels [ mask ] gt_locs = gt_locs [ mask ] gt_labels = gt_labels [ mask ] masks = [ roi_levels == l for l in range ( n_level ) ] rois = [ rois [ m ] for m in masks ] roi_indices = [ roi_indices [ m ] for m in masks ] gt_locs = [ gt_locs [ m ] for m in masks ] gt_labels = [ gt_labels [ m ] for m in masks ] return rois , roi_indices , gt_locs , gt_labels