目标检测中ROC的实现【1】

评价目标检测中的各种标准，如map,ROC通常用于分类算法中，按照混淆矩阵的计算方式：

ROC计算方式

ROC 为FPR（假阳率）为横坐标，TPR（真阳率）为纵坐标，围成的面积即为ROC值：

而在目标检测中，因为负样本（TN）的值很大，所以在目标检测中会直接考虑使用groundtruth个数，作为（TP + FN）个数；

ROC的实现

这里参考python 实现目标检测中roc
该文中因为只有人脸一个类别，实现完在自己的检测结果的ROC曲线有点问题

这里基于ROC的计算方式，对代码做了局部修改。

2.1 数据预处理

需要从算法端的检测结果保存成以下格式，将检测到的不同label的结果保存到一个txt中：

同一label检测结果保存成
[ 文件名
目标数
label xmin/ymin/xmax/ymax、conf] ,
同时检测的时候需要将conf的阈值设成很小的值，比如0.0001，这样ROC曲线的recall才能保证接近100%，保存成绝对长度就不需要再去读取图片获取长宽了；

2.2 代码实现

对于每个label，实现ROC :

import numpy as np
import cv2
import matplotlib.pyplot as plt
def load(txtfile):
    '''
    读取检测结果或 groundtruth 的文档, 若为椭圆坐标, 转换为矩形坐标
    :param txtfile: 读入的.txt文件, 格式要求与FDDB相同
    :return imagelist: list, 每张图片的信息单独为一行, 第一列是图片名称, 第二列是个数, 后面的列均为列表, 包含4个矩形坐标和1个分数
    :return num_allboxes: int, 矩形框的总个数
    '''
    imagelist = []  # 包含所有图片的信息的列表

    txtfile = open(txtfile, 'r')
    lines = txtfile.readlines()  # 一次性全部读取, 得到一个list
    num_gt = 0
    i = 0
    while i < len(lines):  # 在lines中循环一遍
        image = []  # 包含一张图片信息的列表
        image.append(lines[i].strip())  # 去掉首尾的空格和换行符, 向image中写入图片名称
        num_ = int(lines[i + 1])
        if num_ != 0:
            num_gt = num_gt + 1
        image.append(num_)  # 向image中写入个数

        if num_ > 0:
            for num in range(num_):
                boundingbox = lines[i + 2 + num].strip()  # 去掉首尾的空格和换行符
                boundingbox = boundingbox.split()[1: ]  # 按中间的空格分割成多个元素
                boundingbox = list(map(float, boundingbox))  # 转换成浮点数列表

                image.append(boundingbox)  # 向image中写入包含矩形坐标和分数的浮点数列表

        imagelist.append(image)  # 向imagelist中写入一张图片的信息

        i = i + num_ + 2  # 增加index至下张图片开始的行数

    txtfile.close()

    return imagelist



def cal_IoU(detectedbox, groundtruthbox):
    """
    计算两个水平竖直的矩形的交并比
    :param detectedbox: list, [leftx_det, topy_det, width_det, height_det, confidence]
    :param groundtruthbox: list, [leftx_gt, topy_gt, width_gt, height_gt, 1]
    :return iou: 交并比
    """
    leftx_det, topy_det, width_det, height_det, _ = detectedbox
    leftx_gt, topy_gt, width_gt, height_gt = groundtruthbox

    centerx_det = leftx_det + width_det / 2
    centerx_gt = leftx_gt + width_gt / 2
    centery_det = topy_det + height_det / 2
    centery_gt = topy_gt + height_gt / 2

    distancex = abs(centerx_det - centerx_gt) - (width_det + width_gt) / 2
    distancey = abs(centery_det - centery_gt) - (height_det + height_gt) / 2

    if distancex <= 0 and distancey <= 0:
        intersection = distancex * distancey
        union = width_det * height_det + width_gt * height_gt - intersection
        iou = intersection / union
        return iou
    else:
        return 0




def thres(maxiou_confidence, threshold = 0.5):
    """
    将大于阈值的最大交并比记为1, 反正记为0
    :param maxiou_confidence: np.array, 存放所有检测框对应的最大交并比和置信度
    :param threshold: 阈值
    :return tf_confidence: np.array, 存放所有检测框对应的tp或fp和置信度
    """
    tf_confidence = maxiou_confidence[maxiou_confidence[:, 0] > threshold, :]
    # tf_confidence = np.array([true_or_flase, confidences])
    #tf_confidence = tf_confidence.T
    if tf_confidence.size == 0:
        tf_confidence = np.array([0])
    else:
        tf_confidence = tf_confidence[np.argsort(-tf_confidence[:, 1]), 1]
    return tf_confidence


def match(resultsfile, groundtruthfile):
    """
    匹配检测框和标注框, 为每一个检测框得到一个最大交并比   
    :param resultsfile: 包含检测结果的.txt文件
    :param groundtruthfile: 包含标准答案的.txt文件
    :param show_images: 是否显示图片
    :return maxiou_confidence: np.array, 存放所有检测框对应的最大交并比和置信度
    :return num_detectedbox: int, 检测框的总数
    :return num_groundtruthbox: int, 标注框的总数
    """
    results = load(resultsfile)
    groundtruth = load(groundtruthfile)
    print(results)
    print(groundtruth)
    assert len(results) == len(groundtruth), "数量不匹配: 标准答案中图片数量为%d, 而检测结果中图片数量为%d" % (
        len(groundtruth), len(results))
    results_predlist = []
    results_name = []
    for i in range(len(results)):
        results_name.append(results[i][0])

    for i in range(len(groundtruth)):# 对每个图片
        results_pred = []
        maxiou_confidence = np.array([])
        if groundtruth[i][0] in results_name:
            m = results_name.index(results[i][0])
        else:
            print("Not found ,Error")
        results_pred.append(groundtruth[i][0])
        if len(groundtruth[i]) == 2:
            results_pred.append(0)
            if len(results[m]) == 2:
                maxiou_confidence = 0
            else:
                for k in range(2, len(results[m])):  # 匹配这张图片中的每一个检测框
                    detectedbox = results[m][k]
                    confidence = detectedbox[-1]
                    maxiou_confidence = np.append(maxiou_confidence, confidence)
                    maxiou_confidence = max(maxiou_confidence)

            results_pred.append(maxiou_confidence)

        else:
            results_pred.append(1)

            for j in range(2, len(groundtruth[i])):#图片中每个真实框

                iou_array = np.array([])
                groundtruthbox = groundtruth[i][j]
                if len(results[m]) == 2:
                    maxiou_confidence = np.append(maxiou_confidence, [0, 0])
                else:
                    for k in range(2, len(results[m])): #匹配这张图片中的每一个检测框
                        detectedbox = results[m][k]
                        confidence = detectedbox[-1]
                        iou = cal_IoU(detectedbox, groundtruthbox)
                        iou_array = np.r_[iou_array, [iou, confidence]]
                        # iou_array = np.append(iou_array, [iou, confidence], axis=0) # 得到一个交并比的数组


                    # maxiou_index = np.argmax(iou_array[0], axis=0)  # 最大交并比
                   # maxiou_confidence = np.append(maxiou_confidence, [maxiou, confidence])
                    maxiou_confidence = np.append(maxiou_confidence, iou_array)

            maxiou_confidence = maxiou_confidence.reshape(-1, 2)
            maxiou_confidence = maxiou_confidence[np.argsort(-maxiou_confidence[:, 1])] #置信度从大到小排列
            tf_confidence = thres(maxiou_confidence, threshold=0.5)
            tf_confidence = max(tf_confidence)
            results_pred.append(tf_confidence)

        results_predlist.append(results_pred)

        # maxiou_confidence = maxiou_confidence[np.argsort(-maxiou_confidence[:, 1])]  # 按置信度从大到小排序

    return results_predlist


def draw_curves(resultsfile, groundtruthfile, show_images = False, threshold = 0.1):
    """
    读取包含检测结果和标准答案的两个.txt文件, 画出ROC曲线和PR曲线
    :param resultsfile: 包含检测结果的.txt文件
    :param groundtruthfile: 包含标准答案的.txt文件
    :param show_images: 是否显示图片, 若需可视化, 需修改Calculate.match中的代码, 找到存放图片的路径
    :param threshold: IoU阈值
    """
    print("---")
    results_predlist = match(resultsfile, groundtruthfile)
    # tf_confidence = thres(results_predlist, threshold)
    return results_predlist

def plot(results_predlist, lvyaoyao_predlist):
    """
    从上到下截取tf_confidence, 计算并画图
    :param tf_confidence: np.array, 存放所有检测框对应的tp或fp和置信度
    :param num_groundtruthbox: int, 标注框的总数
    """
    fp_list = []
    recall_list = []
    precision_list = []
    auc = 0
    mAP = 0
    gt_num = 0
    ng_num = 0
    for num in range(len(results_predlist)):
        results_pred = results_predlist[num]
        gt = results_pred[1]  # gt
        if gt == 0:
            ng_num = ng_num + 1
        else:
            gt_num = gt_num + 1

    print("tf_confidence", results_predlist)
    for num in range(len(results_predlist)):
        results_pred = results_predlist[num]
        conf = results_pred[2]  # confidence
        print("conf", conf)
        fp = 0
        tp = 0
        for j in range(len(results_predlist)):
            results_pred = results_predlist[j]
            gt = results_pred[1] # gt
            if gt == 0:
                if results_pred[2] >= conf:
                    fp = fp + 1
            else:
                if results_pred[2] >= conf:
                    tp = tp + 1
        recall_list.append(tp)
        fp_list.append(fp)
        if num > 0:
            auc = auc + (fp_list[-1] - fp_list[-2])/gt_num * (recall_list[-1] + recall_list[-2])/ng_num / 2
            print("auc=", auc)

    recall_list_1 = [x/gt_num for x in recall_list ]
    fp_list_1 = [x / ng_num for x in fp_list]
    print(recall_list_1)
    print(fp_list_1)
    #-------------------------------------------------------------------------------------
    fp_list = []
    recall_list = []
    precision_list = []
    auc2 = 0
    mAP = 0
    gt_num = 0
    ng_num = 0
    for num in range(len(lvyaoyao_predlist)):
        results_pred = lvyaoyao_predlist[num]
        gt = results_pred[1]  # gt
        if gt == 0:
            ng_num = ng_num + 1
        else:
            gt_num = gt_num + 1

    print("tf_confidence", lvyaoyao_predlist)
    for num in range(len(lvyaoyao_predlist)):
        results_pred = lvyaoyao_predlist[num]
        conf = results_pred[2]  # confidence
        print("conf", conf)
        fp = 0
        tp = 0
        for j in range(len(lvyaoyao_predlist)):
            results_pred = lvyaoyao_predlist[j]
            gt = results_pred[1]  # gt
            if gt == 0:
                if results_pred[2] >= conf:
                    fp = fp + 1
            else:
                if results_pred[2] >= conf:
                    tp = tp + 1
        recall_list.append(tp)
        fp_list.append(fp)
        if num > 0:
            auc2 = auc2 + (fp_list[-1] - fp_list[-2]) / gt_num * (recall_list[-1] + recall_list[-2]) / ng_num / 2
            print("auc=", auc2)

    recall_list_2 = [x / gt_num for x in recall_list]
    fp_list_2 = [x / ng_num for x in fp_list]
    print(recall_list_2)
    print(fp_list_2)


    "draw picture"
    fig = plt.figure()
    ax1 = fig.add_subplot(111)
    plt.title('ROC')
    plt.xlabel('False Positives')
    plt.xscale('log')
    plt.ylabel('True Positive rate')
    plt.ylim(0, 1)
    ax1.plot(fp_list_1, recall_list_1, label='AUC: ' + str(auc))
    ax1.plot(fp_list_2, recall_list_2, label='AUC: ' + str(auc2))
    plt.legend()

    # plt.figure()
    # plt.title('Precision-Recall')
    # plt.xlabel('Recall')
    # plt.ylabel('Precision')
    # plt.axis([0, 1, 0, 1])
    # plt.plot(recall_list, precision_list, label='mAP: ' + str(mAP))
    # plt.legend()

    plt.show()


if __name__ == '__main__':
    gt_txt = r"G:\all_gt.txt"
    pred_txt =r"G:\all_1012_pred_rcnn.txt"
    lvy_pred = r"G:\lvyy.txt"

    results_predlist = draw_curves(pred_txt, gt_txt)
    lvyy_predlist = draw_curves(lvy_pred, gt_txt)
    results_predlist.sort(key=lambda x: x[2], reverse=True)
    lvyy_predlist.sort(key=lambda x: x[2], reverse=True)
    # results_predlist.sort(lambda x, y:cmp(x[2], y[2]),reverse=True)
    # results_predlist = results_predlist[np.argsort(-results_predlist[:, 2])]
    plot(results_predlist, lvyy_predlist)

在自己的检测结果上，实现：