深度学习之PyTorch物体检测实战(1)

1.IOU

def iou(boxA,boxB):
    """
    @param boxA:真实框
    @param boxB:预测框
    @return:IOU
    """
    left_max=max(boxA[0],boxB[0])
    top_max=max(boxA[1],boxB[1])
    right_min=min(boxA[2],boxB[2])
    bottom_min=min(boxA[3],boxB[3])
    #计算重合面积
    inter=max(0,(right_min-left_max))*max(0,(bottom_min-top_max))
    Sa=(boxA[2]-boxA[0])*(boxA[3]-boxA[1])
    Sb=(boxB[2]-boxB[0])*(boxB[3]-boxB[1])
    #计算重合面积
    union=Sa+Sb-inter
    iou=inter/union
    return iou

2.MAP

2.1 AP的计算过程

• 正确检测框TP
• 误检框FP
• 漏检框FN
• 正确背景TN
  
• 预测框Dets
• 标签值Gts
• 召回率R=TP/len（Gts）
• 准确率P=TP/(TP+FP)

$$AP={\int }_0^{1}PdR$$

def ap(classes,det_boxes,gt_boxes,num_pos):
    """

    @param classes: 一共有多少个类别
    @param det_boxes: 包含全部图像中所有类别的预测框，【left,top,right,bottom,score,NameofImage】
    @param gt_boxes: 包含全部图像中所有类别的标签，【left,top,right,bottom,0】 0代表改标签没有被匹配
    @param num_pos: 图像中包含的物体的个数
    @return: ap
    """
    for c in classes:
       #通过类别作为关键字，得到每个类别的预测、标签及总标签数
        dects=det_boxes[c]
        gt_class=gt_boxes[c]
        npos=num_pos[c]
        #根据得分排序
        dects=sorted(dects,key=lambda conf:conf[4],reverse=True)
        TP=np.zeros(len(dects))
        FP=np.zeros(len(dects))
        for d in range(len(dects)):
            iouMax=sys.float_info
            #遍历与预测框Iou
            if dects[d][-1] in gt_boxes:
                for j in range(len(gt_class[dects[d][-1]])):
                    iou=IOU.iou(dects[d][:4],gt_class[dects[d][-1]][j][:4])
                    if iou>iouMax:
                        iouMax=iou
                        jmax=j
                #阈值
                if iouMax>=0.5:
                    if gt_class[dects[d][-1]][jmax][4]==0:
                        TP[d]=1
                        gt_class[dects[d][-1]][jmax][4]=1
                    else:
                        FP[d]=1
                else:
                    FP[d]=1
            else:
                FP[d]=1
        acc_FP=np.cumsum(FP)
        acc_TP=np.cumsum(TP)
        rec=acc_TP/npos
        prec=np.divide(acc_TP,(acc_TP+acc_FP))
        calc_ap(prec, rec)
        
    return sum(ap)/len(classes)

def calc_ap(prec, rec):
    mrec = np.array([0, rec, 1])
    mpre = np.array([0, prec, 0])

    for i in range(mrec.size - 2, -1, -1):
        mpre[i] = max(mpre[i], mpre[i+1]);
    idx1 = np.where(mrec[1 : ]   != mrec[0 : 2])
    idx2 = [x + 1 for x in idx1]
    ap = sum((mrec.take(idx2) - mrec.take(idx1)) * mpre.take(idx2))
    return ap