maskrcnn_benchmark/data/datasets/evaluation/seed/seed_eval.py
def calc_detection_seed_prec_rec(gt_boxlists, pred_boxlists, iou_thresh=0.5):
    """Calculate precision and recall based on evaluation code of PASCAL VOC.
    This function calculates precision and recall of
    predicted bounding boxes obtained from a dataset which has :math:`N`
    images.
    The code is based on the evaluation code used in PASCAL VOC Challenge.
   """
    n_pos = defaultdict(int)
    score = defaultdict(list)
    match = defaultdict(list)
    for gt_boxlist, pred_boxlist in zip(gt_boxlists, pred_boxlists):
        pred_bbox = pred_boxlist.bbox.numpy()
        pred_label = pred_boxlist.get_field("labels").numpy()
        # print(pred_label)
        pred_score = pred_boxlist.get_field("scores").numpy()
        gt_bbox = gt_boxlist.bbox.numpy()
        gt_label = gt_boxlist.get_field("labels").numpy()
        # print(gt_label)
        gt_difficult = gt_boxlist.get_field("difficult").numpy()

        for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):
            pred_mask_l = pred_label == l
            pred_bbox_l = pred_bbox[pred_mask_l]
            pred_score_l = pred_score[pred_mask_l]
            # sort by score
            order = pred_score_l.argsort()[::-1]
            pred_bbox_l = pred_bbox_l[order]
            pred_score_l = pred_score_l[order]

            gt_mask_l = gt_label == l
            gt_bbox_l = gt_bbox[gt_mask_l]
            gt_difficult_l = gt_difficult[gt_mask_l]

            n_pos[l] += np.logical_not(gt_difficult_l).sum()
            score[l].extend(pred_score_l)

            if len(pred_bbox_l) == 0:
                continue
            if len(gt_bbox_l) == 0:
                match[l].extend((0,) * pred_bbox_l.shape[0])
                continue

            # VOC evaluation follows integer typed bounding boxes.
            pred_bbox_l = pred_bbox_l.copy()
            pred_bbox_l[:, 2:] += 1
            gt_bbox_l = gt_bbox_l.copy()
            gt_bbox_l[:, 2:] += 1
            iou = boxlist_iou(
                BoxList(pred_bbox_l, gt_boxlist.size),
                BoxList(gt_bbox_l, gt_boxlist.size),
            ).numpy()
            gt_index = iou.argmax(axis=1)
            # set -1 if there is no matching ground truth
            gt_index[iou.max(axis=1) < iou_thresh] = -1
            del iou

            selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
            for gt_idx in gt_index:
                if gt_idx >= 0:
                    if gt_difficult_l[gt_idx]:
                        match[l].append(-1)
                    else:
                        if not selec[gt_idx]:
                            match[l].append(1)
                        else:
                            match[l].append(0)
                    selec[gt_idx] = True
                else:
                    match[l].append(0)

    print(n_pos)
    if(not n_pos):
        print("empty")
        n_fg_class=1
    else:
        n_fg_class = max(n_pos.keys()) + 1
    prec = [None] * n_fg_class
    rec = [None] * n_fg_class

    for l in n_pos.keys():
        score_l = np.array(score[l])
        match_l = np.array(match[l], dtype=np.int8)

        order = score_l.argsort()[::-1]
        match_l = match_l[order]

        tp = np.cumsum(match_l == 1)
        fp = np.cumsum(match_l == 0)

        # If an element of fp + tp is 0,
        # the corresponding element of prec[l] is nan.
        prec[l] = tp / (fp + tp)
        # If n_pos[l] is 0, rec[l] is None.
        if n_pos[l] > 0:
            rec[l] = tp / n_pos[l]

    return prec, rec
Calculate precision and recall based on evaluation code of PASCAL VOC.
    This function calculates precision and recall of
    predicted bounding boxes obtained from a dataset which has :math:`N`
    images.
    The code is based on the evaluation code used in PASCAL VOC Challenge.
   
Calculate precision and recall based on evaluation code of PASCAL VOC.
This function calculates precision and recall of
predicted bounding boxes obtained from a dataset which has :math:`N`
images.
The code is based on the evaluation code used in PASCAL VOC Challenge.
Calculate precision and recall based on evaluation code of PASCAL VOC . This function calculates precision and recall of predicted bounding boxes obtained from a dataset which has : math : ` N ` images . The code is based on the evaluation code used in PASCAL VOC Challenge .
def calc_detection_seed_prec_rec(gt_boxlists, pred_boxlists, iou_thresh=0.5):
    n_pos = defaultdict(int)
    score = defaultdict(list)
    match = defaultdict(list)
    for gt_boxlist, pred_boxlist in zip(gt_boxlists, pred_boxlists):
        pred_bbox = pred_boxlist.bbox.numpy()
        pred_label = pred_boxlist.get_field("labels").numpy()
        pred_score = pred_boxlist.get_field("scores").numpy()
        gt_bbox = gt_boxlist.bbox.numpy()
        gt_label = gt_boxlist.get_field("labels").numpy()
        gt_difficult = gt_boxlist.get_field("difficult").numpy()
        for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):
            pred_mask_l = pred_label == l
            pred_bbox_l = pred_bbox[pred_mask_l]
            pred_score_l = pred_score[pred_mask_l]
            order = pred_score_l.argsort()[::-1]
            pred_bbox_l = pred_bbox_l[order]
            pred_score_l = pred_score_l[order]
            gt_mask_l = gt_label == l
            gt_bbox_l = gt_bbox[gt_mask_l]
            gt_difficult_l = gt_difficult[gt_mask_l]
            n_pos[l] += np.logical_not(gt_difficult_l).sum()
            score[l].extend(pred_score_l)
            if len(pred_bbox_l) == 0:
                continue
            if len(gt_bbox_l) == 0:
                match[l].extend((0,) * pred_bbox_l.shape[0])
                continue
            pred_bbox_l = pred_bbox_l.copy()
            pred_bbox_l[:, 2:] += 1
            gt_bbox_l = gt_bbox_l.copy()
            gt_bbox_l[:, 2:] += 1
            iou = boxlist_iou(
                BoxList(pred_bbox_l, gt_boxlist.size),
                BoxList(gt_bbox_l, gt_boxlist.size),
            ).numpy()
            gt_index = iou.argmax(axis=1)
            gt_index[iou.max(axis=1) < iou_thresh] = -1
            del iou
            selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
            for gt_idx in gt_index:
                if gt_idx >= 0:
                    if gt_difficult_l[gt_idx]:
                        match[l].append(-1)
                    else:
                        if not selec[gt_idx]:
                            match[l].append(1)
                        else:
                            match[l].append(0)
                    selec[gt_idx] = True
                else:
                    match[l].append(0)
    print(n_pos)
    if(not n_pos):
        print("empty")
        n_fg_class=1
    else:
        n_fg_class = max(n_pos.keys()) + 1
    prec = [None] * n_fg_class
    rec = [None] * n_fg_class
    for l in n_pos.keys():
        score_l = np.array(score[l])
        match_l = np.array(match[l], dtype=np.int8)
        order = score_l.argsort()[::-1]
        match_l = match_l[order]
        tp = np.cumsum(match_l == 1)
        fp = np.cumsum(match_l == 0)
        prec[l] = tp / (fp + tp)
        if n_pos[l] > 0:
            rec[l] = tp / n_pos[l]
    return prec, rec
def calc_detection_seed_prec_rec ( gt_boxlists , pred_boxlists , iou_thresh = 0.5 ) : n_pos = defaultdict ( int ) score = defaultdict ( list ) match = defaultdict ( list ) for gt_boxlist , pred_boxlist in zip ( gt_boxlists , pred_boxlists ) : pred_bbox = pred_boxlist . bbox . numpy ( ) pred_label = pred_boxlist . get_field ( "labels" ) . numpy ( ) pred_score = pred_boxlist . get_field ( "scores" ) . numpy ( ) gt_bbox = gt_boxlist . bbox . numpy ( ) gt_label = gt_boxlist . get_field ( "labels" ) . numpy ( ) gt_difficult = gt_boxlist . get_field ( "difficult" ) . numpy ( ) for l in np . unique ( np . concatenate ( ( pred_label , gt_label ) ) . astype ( int ) ) : pred_mask_l = pred_label == l pred_bbox_l = pred_bbox [ pred_mask_l ] pred_score_l = pred_score [ pred_mask_l ] order = pred_score_l . argsort ( ) [ : : - 1 ] pred_bbox_l = pred_bbox_l [ order ] pred_score_l = pred_score_l [ order ] gt_mask_l = gt_label == l gt_bbox_l = gt_bbox [ gt_mask_l ] gt_difficult_l = gt_difficult [ gt_mask_l ] n_pos [ l ] += np . logical_not ( gt_difficult_l ) . sum ( ) score [ l ] . extend ( pred_score_l ) if len ( pred_bbox_l ) == 0 : continue if len ( gt_bbox_l ) == 0 : match [ l ] . extend ( ( 0 , ) * pred_bbox_l . shape [ 0 ] ) continue pred_bbox_l = pred_bbox_l . copy ( ) pred_bbox_l [ : , 2 : ] += 1 gt_bbox_l = gt_bbox_l . copy ( ) gt_bbox_l [ : , 2 : ] += 1 iou = boxlist_iou ( BoxList ( pred_bbox_l , gt_boxlist . size ) , BoxList ( gt_bbox_l , gt_boxlist . size ) , ) . numpy ( ) gt_index = iou . argmax ( axis = 1 ) gt_index [ iou . max ( axis = 1 ) < iou_thresh ] = - 1 del iou selec = np . zeros ( gt_bbox_l . shape [ 0 ] , dtype = bool ) for gt_idx in gt_index : if gt_idx >= 0 : if gt_difficult_l [ gt_idx ] : match [ l ] . append ( - 1 ) else : if not selec [ gt_idx ] : match [ l ] . append ( 1 ) else : match [ l ] . append ( 0 ) selec [ gt_idx ] = True else : match [ l ] . append ( 0 ) print ( n_pos ) if ( not n_pos ) : print ( "empty" ) n_fg_class = 1 else : n_fg_class = max ( n_pos . keys ( ) ) + 1 prec = [ None ] * n_fg_class rec = [ None ] * n_fg_class for l in n_pos . keys ( ) : score_l = np . array ( score [ l ] ) match_l = np . array ( match [ l ] , dtype = np . int8 ) order = score_l . argsort ( ) [ : : - 1 ] match_l = match_l [ order ] tp = np . cumsum ( match_l == 1 ) fp = np . cumsum ( match_l == 0 ) prec [ l ] = tp / ( fp + tp ) if n_pos [ l ] > 0 : rec [ l ] = tp / n_pos [ l ] return prec , rec
Calculate precision and recall based on evaluation code of PASCAL VOC.
Calculate precision and recall based on evaluation code of PASCAL VOC .
"""Calculate precision and recall based on evaluation code of PASCAL VOC.
    This function calculates precision and recall of
    predicted bounding boxes obtained from a dataset which has :math:`N`
    images.
    The code is based on the evaluation code used in PASCAL VOC Challenge.
   """ # print(pred_label) # print(gt_label) # sort by score # VOC evaluation follows integer typed bounding boxes. # set -1 if there is no matching ground truth # If an element of fp + tp is 0, # the corresponding element of prec[l] is nan. # If n_pos[l] is 0, rec[l] is None.
gt_boxlists
pred_boxlists
iou_thresh