里程碑式成果Faster RCNN复现难？我们试了一下 | 附完整代码

‍
{    "version": "3.4.1",    "flags": {},    "shapes": [        {            "label": "dog",            "line_color": null,            "fill_color": null,            "points": [                [                    7,                    144                ],                [                    307,                    588                ]            ],            "shape_type": "rectangle"        },        ......        {            "label": "dog",            "line_color": null,            "fill_color": null,            "points": [                [                    756,                    130                ],                [                    974,                    507                ]            ],            "shape_type": "rectangle"        }    ],    "lineColor": [        0,        255,        0,        128    ],    "fillColor": [        255,        0,        0,        128    ],    "imagePath": "timg.jpeg",    "imageData": "此处为base64编码过得图像数据"}

class Dataset:    def __init__(self, opt):        self.opt = opt        self.db = DatasetClass(opt.data_dir)        #定义原始数据的来源如果是自定义数据可以尝试设置数据的列表，然后利用一个通用的读取器来读取数据        self.tsf = Transform(opt.min_size, opt.max_size)
    def __getitem__(self, idx):        image, bboxlist, classlist= self.db.getdata(idx)        img, bbox, label, scale = self.tsf((image, bboxlist, classlist))#对原始数据的变换操作        # TODO: check whose stride is negative to fix this instead copy all        # some of the strides of a given numpy array are negative.        return img.copy(), bbox.copy(), label.copy(), scale
    def __len__(self):        return len(self.db)

if self.num_workers > 0:            # worker_init_fn是worker初始化函数            self.worker_init_fn = loader.worker_init_fn            # index_queue 索引队列 每个worker进程对应一个:             self.index_queues = [multiprocessing.Queue() for _ in range(self.num_workers)]            # worker 队列索引            self.worker_queue_idx = 0            # worker_result_queue 进程间通信            # multiprocessing.SimpleQueue是multiprocessing.Queue([maxsize])的简化，只有三个方法------empty(), get(), put()            self.worker_result_queue = multiprocessing.SimpleQueue()            # batches_outstanding            # 当前已经准备好的 batch 的数量（可能有些正在准备中）            # 当为 0 时， 说明， dataset 中已经没有剩余数据了。            # 初始值为 0, 在 self._put_indices() 中 +1,在 self.__next__ 中-1            self.batches_outstanding = 0            self.worker_pids_set = False            # shutdown为True是关闭worker            self.shutdown = False            # send_idx, rcvd_idx——发送索引，接收索引            # send_idx 用来记录 这次要放 index_queue 中 batch 的 idx            self.send_idx = 0            # rcvd_idx 用来记录 这次要从 data_queue 中取出 的 batch 的 idx            self.rcvd_idx = 0            # 因为多进程，可能会导致 data_queue 中的batch乱序            # 用这个来保证 batch 的返回是按照send_idx升序出去的。            self.reorder_dict = {}
            # 创建num_workers个worker进程来处理            self.workers = [                multiprocessing.Process(                    target=_worker_loop,                    args=(self.dataset, self.index_queues[i],                          self.worker_result_queue, self.collate_fn, base_seed + i,                          self.worker_init_fn, i))                for i in range(self.num_workers)]
            # 这里暂不分析CUDA或者timeout的情况            if self.pin_memory or self.timeout > 0:                ...            else:                # data_queue就是self.worker_result_queue(MultiProcessing.SimpleQueue()类型)                # 这个唯一的队列                self.data_queue = self.worker_result_queue            # 设置守护进程            for w in self.workers:                w.daemon = True  # ensure that the worker exits on process exit                w.start()
            ...
            # prime the prefetch loop            # 初始化的时候，就将 2*num_workers 个 (batch_idx, sampler_indices) 放到 index_queue 中            for _ in range(2 * self.num_workers):                self._put_indices()

‍
class BasicBlock(nn.Module):    expansion = 1    def __init__(self, inplanes, planes, stride=1, downsample=None):        super(BasicBlock, self).__init__()        self.conv1 = conv3x3(inplanes, planes, stride)        self.bn1 = nn.BatchNorm2d(planes)        self.relu = nn.ReLU(inplace=True)        self.conv2 = conv3x3(planes, planes)        self.bn2 = nn.BatchNorm2d(planes)        self.downsample = downsample        self.stride = stride
    def forward(self, x):        identity = x
        out = self.conv1(x)        out = self.bn1(out)        out = self.relu(out)
        out = self.conv2(out)        out = self.bn2(out)
        if self.downsample is not None:            identity = self.downsample(x)
        out += identity        out = self.relu(out)        return out

class Bottleneck(nn.Module):    expansion = 4    def __init__(self, inplanes, planes, stride=1, downsample=None):        super(Bottleneck, self).__init__()        self.conv1 = conv1x1(inplanes, planes)        self.bn1 = nn.BatchNorm2d(planes)        self.conv2 = conv3x3(planes, planes, stride)        self.bn2 = nn.BatchNorm2d(planes)        self.conv3 = conv1x1(planes, planes * self.expansion)        self.bn3 = nn.BatchNorm2d(planes * self.expansion)        self.relu = nn.ReLU(inplace=True)        self.downsample = downsample        self.stride = stride
    def forward(self, x):        identity = x
        out = self.conv1(x)        out = self.bn1(out)        out = self.relu(out)
        out = self.conv2(out)        out = self.bn2(out)        out = self.relu(out)
        out = self.conv3(out)        out = self.bn3(out)
        if self.downsample is not None:            identity = self.downsample(x)        out += identity        out = self.relu(out)
        return out

‍
class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=1000):        self.inplanes = 64        super(ResNet, self).__init__()        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,                               bias=False)        self.bn1 = nn.BatchNorm2d(64)        self.relu = nn.ReLU(inplace=True)        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, layers[0])        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        self.avgpool = nn.AvgPool2d(7, stride=1)        self.fc = nn.Linear(512 * block.expansion, num_classes)
        for m in self.modules():            if isinstance(m, nn.Conv2d):                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels                m.weight.data.normal_(0, math.sqrt(2. / n))            elif isinstance(m, nn.BatchNorm2d):                m.weight.data.fill_(1)                m.bias.data.zero_()
    def _make_layer(self, block, planes, blocks, stride=1):        downsample = None        if stride != 1 or self.inplanes != planes * block.expansion:            downsample = nn.Sequential(                nn.Conv2d(self.inplanes, planes * block.expansion,                          kernel_size=1, stride=stride, bias=False),                nn.BatchNorm2d(planes * block.expansion),            )
        layers = []        layers.append(block(self.inplanes, planes, stride, downsample))        self.inplanes = planes * block.expansion        for i in range(1, blocks):            layers.append(block(self.inplanes, planes))
        return nn.Sequential(*layers)
    def forward(self, x):        x = self.conv1(x)        x = self.bn1(x)        x = self.relu(x)        x = self.maxpool(x)
        x = self.layer1(x)        x = self.layer2(x)        x = self.layer3(x)        x = self.layer4(x)
        x = self.avgpool(x)        x = x.view(x.size(0), -1)        x = self.fc(x)
        return x

class RPN(nn.Module):    _feat_stride = [16, ]    anchor_scales = [8, 16, 32]
    def __init__(self):        super(RPN, self).__init__()
        self.features = VGG16(bn=False)        self.conv1 = Conv2d(512, 512, 3, same_padding=True)        self.score_conv = Conv2d(512, len(self.anchor_scales) * 3 * 2, 1, relu=False, same_padding=False)        self.bbox_conv = Conv2d(512, len(self.anchor_scales) * 3 * 4, 1, relu=False, same_padding=False)
        # loss        self.cross_entropy = None        self.los_box = None
    @property    def loss(self):        return self.cross_entropy + self.loss_box * 10
    def forward(self, im_data, im_info, gt_boxes=None, gt_ishard=None, dontcare_areas=None):            """                          |-->rpn_cls_score_net--->_______--->Class Scores--->|softmax--->|Class Probabilities                          |    w/16,h/16,9,2       reshape                          |          rpn_net -->relu-->|                          |                            |-->rpn_bbx_pred_net---->_______--->Bounding Box regressors---->|                               w/16,h/16,9,4       reshape        """        im_data = network.np_to_variable(im_data, is_cuda=True)        im_data = im_data.permute(0, 3, 1, 2)        features = self.features(im_data)
        rpn_conv1 = self.conv1(features)
        # rpn cls score net        rpn_cls_score = self.score_conv(rpn_conv1)        rpn_cls_score_reshape = self.reshape_layer(rpn_cls_score, 2)        rpn_cls_prob = F.softmax(rpn_cls_score_reshape)        rpn_cls_prob_reshape = self.reshape_layer(rpn_cls_prob, len(self.anchor_scales)*3*2)
        # rpn bbx pred net        rpn_bbox_pred = self.bbox_conv(rpn_conv1)
        # proposal layer        cfg_key = 'TRAIN' if self.training else 'TEST'        #         rois = self.proposal_layer(rpn_cls_prob_reshape, rpn_bbox_pred, im_info,                                   cfg_key, self._feat_stride, self.anchor_scales)
        # generating training labels and build the rpn loss        if self.training:            assert gt_boxes is not None            rpn_data = self.anchor_target_layer(rpn_cls_score, gt_boxes, gt_ishard, dontcare_areas,                                                im_info, self._feat_stride, self.anchor_scales)            self.cross_entropy, self.loss_box = self.build_loss(rpn_cls_score_reshape, rpn_bbox_pred, rpn_data)
        return features, rois

def




    
 proposal_layer(rpn_cls_prob_reshape, rpn_bbox_pred, im_info, cfg_key, _feat_stride=[16, ],                   anchor_scales=[8, 16, 32]):    """    Parameters    ----------    rpn_cls_prob_reshape: (1 , H , W , Ax2) outputs of RPN, prob of bg or fg                         NOTICE: the old version is ordered by (1, H, W, 2, A) !!!!    rpn_bbox_pred: (1 , H , W , Ax4), rgs boxes output of RPN    im_info: a list of [image_height, image_width, scale_ratios]    cfg_key: 'TRAIN' or 'TEST'    _feat_stride: the downsampling ratio of feature map to the original input image    anchor_scales: the scales to the basic_anchor (basic anchor is [16, 16])    ----------    Returns    ----------    rpn_rois : (1 x H x W x A, 5) e.g. [0, x1, y1, x2, y2]
    """
    #注意在这个位置就生成了预置框了    _anchors = generate_anchors(scales=np.array(anchor_scales))
    _num_anchors = _anchors.shape[0]    im_info = im_info[0]
    assert rpn_cls_prob_reshape.shape[0] == 1, \        'Only single item batches are supported'    # cfg_key = str(self.phase) # either 'TRAIN' or 'TEST'    # cfg_key = 'TEST'    pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N    post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N
    #这个阈值很重要    nms_thresh = cfg[cfg_key].RPN_NMS_THRESH

    min_size = cfg[cfg_key].RPN_MIN_SIZE
    # the first set of _num_anchors channels are bg probs    # the second set are the fg probs, which we want    scores = rpn_cls_prob_reshape[:, _num_anchors:, :, :]    bbox_deltas = rpn_bbox_pred    # im_info = bottom[2].data[0, :]
    # 1. Generate proposals from bbox deltas and shifted anchors    height, width = scores.shape[-2:]

    # Enumerate all shifts    shift_x = np.arange(0, width) * _feat_stride    shift_y = np.arange(0, height) * _feat_stride    shift_x, shift_y = np.meshgrid(shift_x, shift_y)    shifts = np.vstack((shift_x.ravel(), shift_y.ravel(),                        shift_x.ravel(), shift_y.ravel())).transpose()
    # Enumerate all shifted anchors:    #    # add A anchors (1, A, 4) to    # cell K shifts (K, 1, 4) to get    # shift anchors (K, A, 4)    # reshape to (K*A, 4) shifted anchors    A = _num_anchors    K = shifts.shape[0]    anchors = _anchors.reshape((1, A, 4)) + \              shifts.reshape((1, K, 4)).transpose((1, 0, 2))    anchors = anchors.reshape((K * A, 4))
    # Transpose and reshape predicted bbox transformations to get them    # into the same order as the anchors:    #    # bbox deltas will be (1, 4 * A, H, W) format    # transpose to (1, H, W, 4 * A)    # reshape to (1 * H * W * A, 4) where rows are ordered by (h, w, a)    # in slowest to fastest order    bbox_deltas = bbox_deltas.transpose((0, 2, 3, 1)).reshape((-1, 4))
    # Same story for the scores:    #    # scores are (1, A, H, W) format    # transpose to (1, H, W, A)    # reshape to (1 * H * W * A, 1) where rows are ordered by (h, w, a)    scores = scores.transpose((0, 2, 3, 1)).reshape((-1, 1))
    # Convert anchors into proposals via bbox transformations    proposals = bbox_transform_inv(anchors, bbox_deltas)
    # 2. clip predicted boxes to image    proposals = clip_boxes(proposals, im_info[:2])
    # 3. remove predicted boxes with either height or width < threshold    # (NOTE: convert min_size to input image scale stored in im_info[2])    keep = _filter_boxes(proposals, min_size * im_info[2])    proposals = proposals[keep, :]    scores = scores[keep]
    # # remove irregular boxes, too fat too tall    # keep = _filter_irregular_boxes(proposals)    # proposals = proposals[keep, :]    # scores = scores[keep]
    # 4. sort all (proposal, score) pairs by score from highest to lowest    # 5. take top pre_nms_topN (e.g. 6000)    order = scores.ravel().argsort()[::-1]    if pre_nms_topN > 0:        order = order[:pre_nms_topN]    proposals = proposals[order, :]    scores = scores[order]
    # 6. apply nms (e.g. threshold = 0.7)    # 7. take after_nms_topN (e.g. 300)    # 8. return the top proposals (-> RoIs top)    keep = nms(np.hstack((proposals, scores)), nms_thresh)

    if post_nms_topN > 0:        keep = keep[:post_nms_topN]    proposals = proposals[keep, :]    scores = scores[keep]
    # Output rois blob    # Our RPN implementation only supports a single input image, so all    # batch inds are 0    batch_inds = np.zeros((proposals.shape[0], 1), dtype=np.float32)    blob = np.hstack((batch_inds, proposals.astype(np.float32, copy=False)))    return blob    # top[0].reshape(*(blob.shape))    # top[0].data[...] = blob
    # [Optional] output scores blob    # if len(top) > 1:    #    top[1].reshape(*(scores.shape))    #    top[1].data[...] = scores

import numpy as npsub_sample=16ratio = [0.5, 1, 2]anchor_scales = [8, 16, 32]anchor_base = np.zeros((len(ratios) * len(scales), 4), dtype=np.float32)ctr_y = sub_sample / 2.ctr_x = sub_sample / 2.print(ctr_y, ctr_x)for i in range(len(ratios)):  for j in range(len(anchor_scales)):    h = sub_sample * anchor_scales[j] * np.sqrt(ratios[i])    w = sub_sample * anchor_scales[j] * np.sqrt(1./ ratios[i])    index = i * len(anchor_scales) + j    anchor_base[index, 0] = ctr_y - h / 2.    anchor_base[index, 1] = ctr_x - w / 2.    anchor_base[index, 2] = ctr_y + h / 2.    anchor_base[index, 3] = ctr_x + w / 2.

fe_size = (800//16)ctr_x = np.arange(16, (fe_size+1) * 16, 16)ctr_y = np.arange(16, (fe_size+1) * 16, 16)index = 0for x in range(len(ctr_x)):    for y in range(len(ctr_y)):        ctr[index, 1] = ctr_x[x] - 8        ctr[index, 0] = ctr_y[y] - 8        index +=1
anchors = np.zeros((fe_size * fe_size * 9), 4)index = 0for c in ctr:  ctr_y, ctr_x = c  for i in range(len(ratios)):    for j in range(len(anchor_scales)):      h = sub_sample * anchor_scales[j] * np.sqrt(ratios[i])      w = sub_sample * anchor_scales[j] * np.sqrt(1./ ratios[i])      anchors[index, 0] = ctr_y - h / 2.      anchors[index, 1] = ctr_x - w / 2.      anchors[index, 2] = ctr_y + h / 2.      anchors[index, 3] = ctr_x + w / 2.      index += 1
print(anchors.shape)#Out: [22500, 4]

def _whctrs(anchor):    """    Return width, height, x center, and y center for an anchor (window).    """
    w = anchor[2] - anchor[0] + 1    h = anchor[3] - anchor[1] + 1    x_ctr = anchor[0] + 0.5 * (w - 1)    y_ctr = anchor[1] + 0.5 * (h - 1)    return w, h, x_ctr, y_ctr
def _mkanchors(ws, hs, x_ctr, y_ctr):    """    Given a vector of widths (ws) and heights (hs) around a center    (x_ctr, y_ctr), output a set of anchors (windows).    """
    ws = ws[:, np.newaxis]    hs = hs[:, np.newaxis]    anchors = np.hstack((x_ctr - 0.5 * (ws - 1),                         y_ctr - 0.5 * (hs - 1),                         x_ctr + 0.5 * (ws - 1),                         y_ctr + 0.5 * (hs - 1)))    return anchors
def _ratio_enum(anchor, ratios):    """    Enumerate a set of anchors for each aspect ratio wrt an anchor.    """
    w, h, x_ctr, y_ctr = _whctrs(anchor)    size = w * h    size_ratios = size / ratios    ws = np.round(np.sqrt(size_ratios))    hs = np.round(ws * ratios)    anchors = _mkanchors(ws, hs, x_ctr, y_ctr)    return anchors
def _scale_enum(anchor, scales):    """    Enumerate a set of anchors for each scale wrt an anchor.    """
    w, h, x_ctr, y_ctr = _whctrs(anchor)    ws = w * scales    hs = h * scales    anchors = _mkanchors(ws, hs, x_ctr, y_ctr)    return anchorsdef generate_anchors(base_size=16, ratios=[0.5, 1, 2],                     scales=2**np.arange(3, 6)):    """    Generate anchor (reference) windows by enumerating aspect ratios X    scales wrt a reference (0, 0, 15, 15) window.    """
    base_anchor = np.array([1, 1, base_size, base_size]) - 1    ratio_anchors = _ratio_enum(base_anchor, ratios)    anchors = np.vstack([_scale_enum(ratio_anchors[i, :], scales)                         for i in xrange(ratio_anchors.shape[0])])    return anchors
print(anchors)#array([[ -83.,  -39.,  100.,   56.],#       [-175.,  -87.,  192.,  104.],#       [-359., -183.,  376.,  200.],#       [ -55.,  -55.,   72.,   72.],#       [-119., -119.,  136.,  136.],




    
#       [-247., -247.,  264.,  264.],#       [ -35.,  -79.,   52.,   96.],#       [ -79., -167.,   96.,  184.],#       [-167., -343.,  184.,  360.]])

import numpy as npimport matplotlib.pyplot as pltimport cv2def display(cordlist):    back=np.zeros((800,800,3),dtype=np.uint8)    for index,cord in enumerate(cordlist):        print('draw ',cord)
        color=(np.random.randint(127,255),np.random.randint(127,255),np.random.randint(127,255))        print('color is ',color)
        cv2.rectangle(back, (int(cord[0]),int(cord[1])),         (int(cord[2]),int(cord[3])), color, 1)        cv2.putText(back, str(cord[4]), (int(cord[0]),int(cord[1])),cv2.FONT_ITALIC,0.5,color, 1)    plt.imshow(back),plt.show()    return back


def py_cpu_nms(dets, thresh):    """Pure Python NMS baseline."""    # 所有图片的坐标信息，字典形式储存？？    x1 = dets[:, 0]    y1 = dets[:, 1]    x2 = dets[:, 2]    y2 = dets[:, 3]    scores = dets[:, 4]
    areas = (x2 - x1 + 1) * (y2 - y1 + 1)  # 计算出所有图片的面积    order = scores.argsort()[::-1]  # 图片评分按升序排序
    keep = []  # 用来存放最后保留的图片的相应评分    while order.size > 0:        i = order[0]  # i 是还未处理的图片中的最大评分        keep.append(i)  # 保留改图片的值        # 矩阵操作，下面计算的是图片i分别与其余图片相交的矩形的坐标        tmp=x1[order[1:]]        xxxx = x1[i]        xx1 = np.maximum(x1[i], x1[order[1:]])        yy1 = np.maximum(y1[i], y1[order[1:]])        xx2 = np.minimum(x2[i], x2[order[1:]])        yy2 = np.minimum(y2[i], y2[order[1:]])
        # 计算出各个相交矩形的面积        w = np.maximum(0.0, xx2 - xx1 + 1)        h = np.maximum(0.0, yy2 - yy1 + 1)        inter = w * h        # 计算重叠比例        ovr = inter / (areas[i] + areas[order[1:]] - inter)
        # 只保留比例小于阙值的图片，然后继续处理        inds = np.where(ovr <= thresh)[0]        indsd= inds+1        order = order[inds + 1]
    return keepboxes = np.array([[100, 100, 150, 168, 0.63],[166, 70, 312, 190, 0.55],[221, 250, 389, 500, 0.79],[12, 190, 300, 399, 0.9],[28, 130, 134, 302, 0.3]])# boxes[:,:3]+=100display(boxes)#显示NMS输入thresh = 0.1keep = py_cpu_nms(boxes, thresh)print('keep:',keep)keep_=boxes[keep]#nms之后的索引display(keep_)#显示NMS输出

#torch.numel() 表示一个张量总元素的个数




    
#torch.clamp(min, max) 设置上下限#tensor.item() 把tensor元素取出作为numpy数字
def nms(self, bboxes, scores, threshold=0.5):        x1 = bboxes[:,0]        y1 = bboxes[:,1]        x2 = bboxes[:,2]        y2 = bboxes[:,3]        areas = (x2-x1)*(y2-y1)   # [N,] 每个bbox的面积        _, order = scores.sort(0, descending=True)    # 降序排列
        keep = []        while order.numel() > 0:       # torch.numel()返回张量元素个数            if order.numel() == 1:     # 保留框只剩一个                i = order.item()                keep.append(i)                break            else:                i = order[0].item()    # 保留scores最大的那个框box[i]                keep.append(i)
            # 计算box[i]与其余各框的IOU(思路很好)            xx1 = x1[order[1:]].clamp(min=x1[i])   # [N-1,]            yy1 = y1[order[1:]].clamp(min=y1[i])            xx2 = x2[order[1:]].clamp(max=x2[i])            yy2 = y2[order[1:]].clamp(max=y2[i])            inter = (xx2-xx1).clamp(min=0) * (yy2-yy1).clamp(min=0)   # [N-1,]
            iou = inter / (areas[i]+areas[order[1:]]-inter)  # [N-1,]            idx = (iou <= threshold).nonzero().squeeze() # 注意此时idx为[N-1,] 而order为[N,]            if idx.numel() == 0:                break            order = order[idx+1]  # 修补索引之间的差值        return torch.LongTensor(keep)   # Pytorch的索引值为LongTensor

@property    def loss(self):        return self.cross_entropy + self.loss_box * 10

def build_loss(self, rpn_cls_score_reshape, rpn_bbox_pred, rpn_data):        # classification loss        rpn_cls_score = rpn_cls_score_reshape.permute(0, 2, 3, 1).contiguous().view(-1, 2)        rpn_label = rpn_data[0].view(-1)
        rpn_keep = Variable(rpn_label.data.ne(-1).nonzero().squeeze()).cuda()        rpn_cls_score = torch.index_select(rpn_cls_score, 0, rpn_keep)        rpn_label = torch.index_select(rpn_label, 0, rpn_keep)
        fg_cnt = torch.sum(rpn_label.data.ne(0))
        rpn_cross_entropy = F.cross_entropy(rpn_cls_score, rpn_label)
        # box loss        rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights = rpn_data[1:]        rpn_bbox_targets = torch.mul(rpn_bbox_targets, rpn_bbox_inside_weights)        rpn_bbox_pred = torch.mul(rpn_bbox_pred, rpn_bbox_inside_weights)
        rpn_loss_box = F.smooth_l1_loss(rpn_bbox_pred, rpn_bbox_targets, size_average=False) / (fg_cnt + 1e-4)
        return rpn_cross_entropy, rpn_loss_box