CTPN网络理解

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192

class VGGnet_train(Network):    # 继承自NetWork,关与NetWork可以看这里：https://github.com/xiaofengShi/CHINESE-OCR/blob/master/ctpn/lib/networks/network.py    def __init__(self, trainable=True):        self.inputs = []        self.data = tf.placeholder(tf.float32, shape=[None, None, None, 3], name=‘data‘)        self.im_info = tf.placeholder(tf.float32, shape=[None, 3], name=‘im_info‘)        self.gt_boxes = tf.placeholder(tf.float32, shape=[None, 5], name=‘gt_boxes‘)        self.gt_ishard = tf.placeholder(tf.int32, shape=[None], name=‘gt_ishard‘)        self.dontcare_areas = tf.placeholder(tf.float32, shape=[None, 4], name=‘dontcare_areas‘)        self.keep_prob = tf.placeholder(tf.float32)        self.layers = dict({‘data‘: self.data, ‘im_info‘: self.im_info, ‘gt_boxes‘: self.gt_boxes,‘gt_ishard‘: self.gt_ishard, ‘dontcare_areas‘: self.dontcare_areas})        self.trainable = trainable        self.setup()

    def setup(self):        # 对于文本提议来说，类别为2，一类为为文字部分，另一类为背景        n_classes = cfg.NCLASSES        # anchor的初始尺寸，论文中使用的是16        anchor_scales = cfg.ANCHOR_SCALES        _feat_stride = [16, ]

        # base net is vgg16        # 内部使用的函数        (self.feed(‘data‘)            .conv(3, 3, 64, 1, 1, name=‘conv1_1‘)            .conv(3, 3, 64, 1, 1, name=‘conv1_2‘)            .max_pool(2, 2, 2, 2, padding=‘VALID‘, name=‘pool1‘)            .conv(3, 3, 128, 1, 1, name=‘conv2_1‘)            .conv(3, 3, 128, 1, 1, name=‘conv2_2‘)            .max_pool(2, 2, 2, 2, padding=‘VALID‘, name=‘pool2‘)            .conv(3, 3, 256, 1, 1, name=‘conv3_1‘)            .conv(3, 3, 256, 1, 1, name=‘conv3_2‘)            .conv(3, 3, 256, 1, 1, name=‘conv3_3‘)            .max_pool(2, 2, 2, 2, padding=‘VALID‘, name=‘pool3‘)            .conv(3, 3, 512, 1, 1, name=‘conv4_1‘)            .conv(3, 3, 512, 1, 1, name=‘conv4_2‘)            .conv(3, 3, 512, 1, 1, name=‘conv4_3‘)            .max_pool(2, 2, 2, 2, padding=‘VALID‘, name=‘pool4‘)            .conv(3, 3, 512, 1, 1, name=‘conv5_1‘)            .conv(3, 3, 512, 1, 1, name=‘conv5_2‘)            .conv(3, 3, 512, 1, 1, name=‘conv5_3‘))        # RPN         # 该层对上层的feature map进行卷积，生成512通道的的feature map        (self.feed(‘conv5_3‘).conv(3, 3, 512, 1, 1, name=‘rpn_conv/3x3‘))        # 卷积最后一层的的feature_map尺寸为batch*h*w*512

        # 原来的单层双向LSTM        (self.feed(‘rpn_conv/3x3‘).Bilstm(512, 128, 512, name=‘lstm_o‘))        # bilstm之后输出的尺寸为(N, H, W, 512)

        """         和faster—rcnn相似，在ctpn的rpn网络中，使用双向lstm和全连接得到预测的        目标概率和回归框，在faster-rcnn中使用的是卷积的方式从basenet的最后一层生成        使用LSTM的输出来计算位置偏移和类别概率（判断是否是物体，不判断类别的种类）        输入尺寸为(N, H, W, 512)  输出尺寸（N, H, W, int(d_o)）        可以将这一层当做目标检测中的最后一层feature_map        rpn_bbox_pred--对于h*w的尺寸上，每一anchor上生成4个位置偏移量        rpn_cls_score--对于h*w的尺寸上，每一anchor上生成2个置信度得分，判断是否为物体

        """        (self.feed(‘lstm_o‘).lstm_fc(512, len(anchor_scales) * 10 * 4, name=‘rpn_bbox_pred‘))        (self.feed(‘lstm_o‘).lstm_fc(512, len(anchor_scales) * 10 * 2, name=‘rpn_cls_score‘))

        # generating training labels on the fly        # output: rpn_labels(HxWxA, 2) rpn_bbox_targets(HxWxA, 4) rpn_bbox_inside_weights rpn_bbox_outside_weights        # 给每个anchor上标签，并计算真值（也是delta的形式），以及内部权重和外部权重        (self.feed(‘rpn_cls_score‘, ‘gt_boxes‘, ‘gt_ishard‘, ‘dontcare_areas‘, ‘im_info‘)            .anchor_target_layer(_feat_stride, anchor_scales, name=‘rpn-data‘))

        # shape is (1, H, W, Ax2) -> (1, H, WxA, 2)        # 给之前得到的score进行softmax，得到0-1之间的得分        (self.feed(‘rpn_cls_score‘)            .spatial_reshape_layer(2, name=‘rpn_cls_score_reshape‘)            .spatial_softmax(name=‘rpn_cls_prob‘))        ‘‘‘        # the below is the rcnn net model from faster_rcnn        # 后面的部分是fasterrcnn之后的ROIPooling部分        (self.feed(‘rpn_cls_prob‘).spatial_reshape_layer(len(anchor_scales) * 10 * 2, name=‘rpn_cls_prob_reshape‘))

        self.feed(‘rpn_cls_prob_reshape‘, ‘rpn_bbox_pred‘, ‘im_info‘).proposal_layer(            _feat_stride, anchor_scales, ‘TRAIN‘, name=‘rpn_rois‘)

        (self.feed(‘rpn_rois‘, ‘gt_boxes‘).proposal_target_layer(n_classes, name=‘roi-data‘))

        # ========= RCNN ============        (self.feed(‘conv5_3‘, ‘roi-data‘).roi_pool(7, 7, 1.0/16, name=‘pool_5‘)             .fc(4096, name=‘fc6‘).dropout(0.5, name=‘drop6‘)             .fc(4096, name=‘fc7‘).dropout(0.5, name=‘drop7‘)             .fc(n_classes, relu=False, name=‘cls_score‘).softmax(name=‘cls_prob‘))

        (self.feed(‘drop7‘).fc(n_classes*4, relu=False, name=‘bbox_pred‘))        ‘‘‘

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335

# -*- coding:utf-8 -*-import numpy as npimport numpy.random as npr

from ..fast_rcnn.config import cfgfrom bbox import bbox_overlaps, bbox_intersections

DEBUG = False

# 生成基础anchor boxdef generate_basic_anchors(sizes, base_size=16):    base_anchor = np.array([0, 0, base_size - 1, base_size - 1], np.int32)    anchors = np.zeros((len(sizes), 4), np.int32)    index = 0    for h, w in sizes:        anchors[index] = scale_anchor(base_anchor, h, w)        index += 1    return anchors

# 根据baseanchor和设定的anchor的高度和宽度进行设定的anchor生成def scale_anchor(anchor, h, w):    x_ctr = (anchor[0] + anchor[2]) * 0.5    y_ctr = (anchor[1] + anchor[3]) * 0.5    scaled_anchor = anchor.copy()    scaled_anchor[0] = x_ctr - w / 2  # xmin    scaled_anchor[2] = x_ctr + w / 2  # xmax    scaled_anchor[1] = y_ctr - h / 2  # ymin    scaled_anchor[3] = y_ctr + h / 2  # ymax    return scaled_anchor

# 生成anchor box# 此处使用的是宽度固定，高度不同的anchor设置def generate_anchors(base_size=16, ratios=[0.5, 1, 2],                     scales=2 ** np.arange(3, 6)):    heights = [11, 16, 23, 33, 48, 68, 97, 139, 198, 283]    widths = [16]    sizes = []    for h in heights:        for w in widths:            sizes.append((h, w))    return generate_basic_anchors(sizes)

# 生成的anchor和groundtruth之间进行转换，转换方式和论文一致def bbox_transform(ex_rois, gt_rois):    """    computes the distance from ground-truth boxes to the given boxes, normed by their size    :param ex_rois: n * 4 numpy array, anchor boxes    :param gt_rois: n * 4 numpy array, ground-truth boxes    :return: deltas: n * 4 numpy array, ground-truth boxes    """    ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0 # anchor width     ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0 # anchor height    ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths # anchor center x    ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights # anchor center y

    assert np.min(ex_widths) > 0.1 and np.min(ex_heights) > 0.1, \        ‘Invalid boxes found: {} {}‘. \        format(ex_rois[np.argmin(ex_widths), :], ex_rois[np.argmin(ex_heights), :])

    gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0 # gt_box width    gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0 # gt_box height    gt_ctr_x = gt_rois[:, 0] + 0.5 * gt_widths # gt_box center x    gt_ctr_y = gt_rois[:, 1] + 0.5 * gt_heights # gt_box center y

    # warnings.catch_warnings()    # warnings.filterwarnings(‘error‘)    targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths  # (gt_c_x-a_c_x)    targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights    targets_dw = np.log(gt_widths / ex_widths)    targets_dh = np.log(gt_heights / ex_heights)

    targets = np.vstack(        (targets_dx, targets_dy, targets_dw, targets_dh)).transpose()

    return targets

# 生成anchorsdef anchor_target_layer(        rpn_cls_score, gt_boxes, gt_ishard, dontcare_areas, im_info, _feat_stride=[16, ],        anchor_scales=[16, ]):    """    Assign anchors to ground-truth targets. Produces anchor classification    labels and bounding-box regression targets.    Parameters    ----------    rpn_cls_score: (1, H, W, Ax2) bg/fg scores of previous conv layer    gt_boxes: (G, 5) vstack of [x1, y1, x2, y2, class]    gt_ishard: (G, 1), 1 or 0 indicates difficult or not    dontcare_areas: (D, 4), some areas may contains small objs but no labelling. D may be 0    im_info: a list of [image_height, image_width, scale_ratios]    _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_labels : (HxWxA, 1), for each anchor, 0 denotes bg, 1 fg, -1 dontcare    rpn_bbox_targets: (HxWxA, 4), distances of the anchors to the gt_boxes(may contains some transform)                            that are the regression objectives    rpn_bbox_inside_weights: (HxWxA, 4) weights of each boxes, mainly accepts hyper param in cfg    rpn_bbox_outside_weights: (HxWxA, 4) used to balance the fg/bg,                            beacuse the numbers of bgs and fgs mays significiantly different    """    # anchors is the [x_min,y_min,x_max,y_max]    # 生成基本的anchor,一共10个    _anchors = generate_anchors(scales=np.array(anchor_scales))      _num_anchors = _anchors.shape[0]  # 10个anchor

    # allow boxes to sit over the edge by a small amount    _allowed_border = 0    # 原始图像的信息，图像的高宽及通道数    im_info = im_info[0]  

    # 在feature-map上定位anchor，并加上delta，得到在实际图像中anchor的真实坐标    """     Algorithm:        for each (H, W) location i            generate 9 anchor boxes centered on cell i            apply predicted bbox deltas at cell i to each of the 9 anchors            filter out-of-image anchors        measure GT overlap     """    assert rpn_cls_score.shape[0] == 1, \        ‘Only single item batches are supported‘

    # map of shape (..., H, W)    height, width = rpn_cls_score.shape[1:3]  # feature-map的高宽    # 1. Generate proposals from bbox deltas and shifted anchors    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)  # in W H order    # 生成feature-map和真实图像上anchor之间的偏移量    # shifts构建网格结构，shape [height*width,4]    shifts = np.vstack((shift_x.ravel(), shift_y.ravel(),                        shift_x.ravel(), shift_y.ravel())).transpose()      A = _num_anchors  # 10个anchor    K = shifts.shape[0]  # feature-map的宽乘高的大小    # 为当前的featuremap每个点生成A个anchor，shape is [K,A,4]    all_anchors = (_anchors.reshape((1, A, 4)) +                   shifts.reshape((1, K, 4)).transpose((1, 0, 2)))      all_anchors = all_anchors.reshape((K * A, 4))  # shape is (K*A,4)    # 在featuremap上每个点生成A个anchor    total_anchors = int(K * A)    # only keep anchors inside the image    # 因为生成的anchor尺寸有大有小，因此在边缘处生成的anchor有可能会超过原始图像的边界，    # 将这些超过边界的anchor去掉,得到的是这些anchor的在all_anchors中的索引    # 仅保留那些还在图像内部的anchor，超出图像的都删掉    # anchors[:]=[x_min,y_min,x_max,y_max]    inds_inside = np.where(        (all_anchors[:, 0] >= -_allowed_border) &        (all_anchors[:, 1] >= -_allowed_border) &        (all_anchors[:, 2] < im_info[1] + _allowed_border) &  # width        (all_anchors[:, 3] < im_info[0] + _allowed_border)  # height    )[0]

    # keep only inside anchors    anchors = all_anchors[inds_inside, :]  # 保留那些在图像内的anchor

    # 至此，anchor准备好了    # --------------------------------------------------------------    # label: 1 is positive, 0 is negative, -1 is dont care    # (A)    labels = np.empty((len(inds_inside),), dtype=np.float32)    labels.fill(-1)  # 初始化label，均为-1    # overlaps between the anchors and the gt boxes    # overlaps (ex, gt), shape is A x G    # 计算anchor和gt-box的overlap，用来给anchor上标签    # anchor box and groundtruth box 交集面积/并集面积    # 通过IOU的得分来确定anchor为正样本与否    # overlaps shape is [anchor.shape[0],gt_box.shape[0]]    overlaps = bbox_overlaps(        np.ascontiguousarray(anchors, dtype=np.float),        np.ascontiguousarray(gt_boxes, dtype=np.float))      # 存放每一个anchor和每一个gtbox之间的overlap    # 找到和每一个gtbox，overlap最大的那个anchor    argmax_overlaps = overlaps.argmax(axis=1)     max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]    # 找到每个位置上10个anchor中与gtbox，overlap最大的那个    gt_argmax_overlaps = overlaps.argmax(axis=0)      gt_max_overlaps = overlaps[gt_argmax_overlaps,                               np.arange(overlaps.shape[1])]    gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]

    if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:        # assign bg labels first so that positive labels can clobber them        # 先给背景上标签，小于0.3overlap的为负样本label为0        labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0  

    # -----------------------------------#    # 正样本的确定，iou得分大于0.7和每个位置上具有最大IOU得分的anchor    # fg label: for each gt, anchor with highest overlap    # 每个位置上的10个个anchor中overlap最大的认为是前景    labels[gt_argmax_overlaps] = 1      # fg label: above threshold IOU    # overlap大于0.7的认为是前景    labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1  

    if cfg.TRAIN.RPN_CLOBBER_POSITIVES:        # assign bg labels last so that negative labels can clobber positives        labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0

    # preclude dontcare areas    # 这里我们暂时不考虑有doncare_area的存在    if dontcare_areas is not None and dontcare_areas.shape[0] > 0:          # intersec shape is D x A        intersecs = bbox_intersections(            np.ascontiguousarray(dontcare_areas, dtype=np.float),  # D x 4            np.ascontiguousarray(anchors, dtype=np.float)  # A x 4        )        intersecs_ = intersecs.sum(axis=0)  # A x 1        labels[intersecs_ > cfg.TRAIN.DONTCARE_AREA_INTERSECTION_HI] = -1

    # 这里我们暂时不考虑难样本的问题    # preclude hard samples that are highly occlusioned, truncated or difficult to see    if cfg.TRAIN.PRECLUDE_HARD_SAMPLES and gt_ishard is not None and gt_ishard.shape[0] > 0:        assert gt_ishard.shape[0] == gt_boxes.shape[0]        gt_ishard = gt_ishard.astype(int)        gt_hardboxes = gt_boxes[gt_ishard == 1, :]if gt_hardboxes.shape[0] > 0:# H x A            hard_overlaps = bbox_overlaps(                np.ascontiguousarray(gt_hardboxes, dtype=np.float),  # H x 4                np.ascontiguousarray(anchors, dtype=np.float))  # A x 4            hard_max_overlaps = hard_overlaps.max(axis=0)  # (A)            labels[hard_max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = -1            max_intersec_label_inds = hard_overlaps.argmax(axis=1)  # H x 1            labels[max_intersec_label_inds] = -1  #

# subsample positive labels if we have too many# 对正样本进行采样，如果正样本的数量太多的话# 限制正样本的数量不超过128个，排除的置位dont_Care类# TODO 这个后期可能还需要修改，毕竟如果使用的是字符的片段，那个正样本的数量是很多的。    num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)    fg_inds = np.where(labels == 1)[0]if len(fg_inds) > num_fg:        disable_inds = npr.choice(            fg_inds, size=(len(fg_inds) - num_fg), replace=False)  # 随机去除掉一些正样本        labels[disable_inds] = -1  # 变为-1

# subsample negative labels if we have too many# 对负样本进行采样，如果负样本的数量太多的话# 正负样本总数是256，限制正样本数目最多128，# 如果正样本数量小于128，差的那些就用负样本补上，凑齐256个样本    num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)    bg_inds = np.where(labels == 0)[0]if len(bg_inds) > num_bg:        disable_inds = npr.choice(            bg_inds, size=(len(bg_inds) - num_bg), replace=False)        labels[disable_inds] = -1# print "was %s inds, disabling %s, now %s inds" % (# len(bg_inds), len(disable_inds), np.sum(labels == 0))

# 至此， 上好标签，开始计算rpn-box的真值# --------------------------------------------------------------    bbox_targets = np.zeros((len(inds_inside), 4), dtype=np.float32)# 根据anchor和gtbox计算得真值（anchor和gtbox之间的偏差）    bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])# 内部权重，前景就给1，其他是0    bbox_inside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)    bbox_inside_weights[labels == 1, :] = np.array(        cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS)  

    bbox_outside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0: # 此处使用uniform权重，也就是正样本是1，负样本是0# uniform weighting of examples (given non-uniform sampling)# num_examples = np.sum(labels >= 0) + 1# positive_weights = np.ones((1, 4)) * 1.0 / num_examples# negative_weights = np.ones((1, 4)) * 1.0 / num_examples        positive_weights = np.ones((1, 4))  # 前景为1        negative_weights = np.zeros((1, 4))  # 背景为0else:assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) &                (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))        positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT /                            (np.sum(labels == 1)) + 1)        negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) /                            (np.sum(labels == 0)) + 1)# 外部权重，前景是1，背景是0# bbox_outside_weights初始化为0，将label中为0的位置赋值bbox_outside_weights为0,labels为1的位置赋值为1    bbox_outside_weights[labels == 1, :] = positive_weights    bbox_outside_weights[labels == 0, :] = negative_weights

# map up to original set of anchors# 一开始是将超出图像范围的anchor直接丢掉的，现在在加回来# inds_inside 是原始anchor中的索引    labels = _unmap(labels, total_anchors, inds_inside, fill=-1)  # 这些anchor的label是-1，也即dontcare    bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)  # 这些anchor的真值是0，也即没有值    bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors,                                 inds_inside, fill=0)  # 内部权重以0填充    bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors,                                  inds_inside, fill=0)  # 外部权重以0填充

# labels    labels = labels.reshape((1, height, width, A))  # reshap一下label    rpn_labels = labels

# bbox_targets    bbox_targets = bbox_targets.reshape((1, height, width, A * 4))  # reshape    rpn_bbox_targets = bbox_targets

# bbox_inside_weights    bbox_inside_weights = bbox_inside_weights.reshape((1, height, width, A * 4))    rpn_bbox_inside_weights = bbox_inside_weights

# bbox_outside_weights    bbox_outside_weights = bbox_outside_weights.reshape((1, height, width, A * 4))    rpn_bbox_outside_weights = bbox_outside_weights

	rpn_data=(rpn_labels, rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights)

return rpn_data

# 将排除掉边界之外的anchors之后的anchor补全回来def _unmap(data, count, inds, fill=0):""" Unmap a subset of item (data) back to the original set of items (of    size count) """if len(data.shape) == 1:        ret = np.empty((count,), dtype=np.float32)        ret.fill(fill)        ret[inds] = dataelse:        ret = np.empty((count,) + data.shape[1:], dtype=np.float32)        ret.fill(fill)        ret[inds, :] = datareturn ret

# 计算anchor和gt之间的矩形框的偏差def _compute_targets(ex_rois, gt_rois):"""Compute bounding-box regression targets for an image."""

assert ex_rois.shape[0] == gt_rois.shape[0]assert ex_rois.shape[1] == 4assert gt_rois.shape[1] == 5

return bbox_transform(ex_rois, gt_rois[:, :4]).astype(np.float32, copy=False)

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596

import numpy as npcimport numpy as np

DTYPE = np.floatctypedef np.float_t DTYPE_t

# 计算IOUdef bbox_overlaps(        np.ndarray[DTYPE_t, ndim=2] boxes,        np.ndarray[DTYPE_t, ndim=2] query_boxes):    """    Parameters    ----------    boxes: (N, 4) ndarray of float, anchor box nums    query_boxes: (K, 4) ndarray of float, groud_truth object nums,[x_min,y_min,x_max,y_max,class]    Returns    -------    overlaps: (N, K) ndarray of overlap between boxes and query_boxes    """    cdef unsigned int N = boxes.shape[0]    cdef unsigned int K = query_boxes.shape[0]    cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)    cdef DTYPE_t iw, ih, box_area    cdef DTYPE_t ua    cdef unsigned int k, n    for k in range(K):        box_area = (            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *            (query_boxes[k, 3] - query_boxes[k, 1] + 1)        )        for n in range(N):            # 水平方向上的交集，如果存在那么iw为正            iw = (                min(boxes[n, 2], query_boxes[k, 2]) -                max(boxes[n, 0], query_boxes[k, 0]) + 1            )            if iw > 0:                # 竖直方向上的交集                ih = (                    min(boxes[n, 3], query_boxes[k, 3]) -                    max(boxes[n, 1], query_boxes[k, 1]) + 1                )                if ih > 0:                    # 如果存在交集，计算并集的面积                    # union area                    ua = float(                        (boxes[n, 2] - boxes[n, 0] + 1) *                        (boxes[n, 3] - boxes[n, 1] + 1) +                        box_area - iw * ih                    )                    # 交集面积/并集面积                    overlaps[n, k] = iw * ih / ua    return overlaps

# anchor与gt交集面积相对于gt面积的比例def bbox_intersections(        np.ndarray[DTYPE_t, ndim=2] boxes,        np.ndarray[DTYPE_t, ndim=2] query_boxes):    """    For each query box compute the intersection ratio covered by boxes    ----------    Parameters    ----------    boxes: (N, 4) ndarray of float    query_boxes: (K, 4) ndarray of float    Returns    -------    overlaps: (N, K) ndarray of intersec between boxes and query_boxes    """    cdef unsigned int N = boxes.shape[0]    cdef unsigned int K = query_boxes.shape[0]    cdef np.ndarray[DTYPE_t, ndim=2] intersec = np.zeros((N, K), dtype=DTYPE)    cdef DTYPE_t iw, ih, box_area    cdef DTYPE_t ua    cdef unsigned int k, n    for k in range(K):        box_area = (            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *            (query_boxes[k, 3] - query_boxes[k, 1] + 1)        )        for n in range(N):            iw = (                min(boxes[n, 2], query_boxes[k, 2]) -                max(boxes[n, 0], query_boxes[k, 0]) + 1            )            if iw > 0:                ih = (                    min(boxes[n, 3], query_boxes[k, 3]) -                    max(boxes[n, 1], query_boxes[k, 1]) + 1                )                if ih > 0:                    intersec[n, k] = iw * ih / box_area    return intersec