yolov5 mAP计算代码分析

最新推荐文章于 2024-08-18 22:25:54 发布
最新推荐文章于 2024-08-18 22:25:54 发布
阅读量582 收藏 22
点赞数 22
文章标签： YOLO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/namelijink/article/details/140959796
版权

image.png

前言

模型训练过程中每一轮都会计算P，R，mAP，mAP@0.5等数值，本篇分析这些数值的计算过程，分析最核心部分。我的感受是计算的过程比想象的复杂。
主要的流程在yolov5/val.py文件的process_batch处理函数中。

 if nl:
    tbox = xywh2xyxy(labels[:, 1:5])  # target boxes
    scale_boxes(im[si].shape[1:], tbox, shape, shapes[si][1])  # native-space labels
    labelsn = torch.cat((labels[:, 0:1], tbox), 1)  # native-space labels
    correct = process_batch(predn, labelsn, iouv, im[si])
    if plots:
        confusion_matrix.process_batch(predn, labelsn)

计算map@0.5的计算基本原理是：

  1. 给定一个阈值数组，从0.5-0.95每间隔0.05，生成一共10个数据
  2. 获取预测结果和标注，计算预测框和gt框的IOU，判断类别是否一致。
  3. 用阈值数组中的每一个阈值去筛选IOU，大于阈值的预测为True, 小于IOU的预测为False
  4. 统计结果，输出结果

入参分析

detections：bbox，预测框信息，格式为：x1, y1, x2, y2, conf, class
labels：gt框信息，格式为：class, x1, y1, x2, y2
iouv：阈值数组，内容是：[0.50000, 0.55000, 0.60000, 0.65000, 0.70000, 0.75000, 0.80000, 0.85000, 0.90000, 0.95000]

def process_batch(detections, labels, iouv, img=None):
    """
    Return correct prediction matrix
    Arguments:
        detections (array[N, 6]), x1, y1, x2, y2, conf, class
        labels (array[M, 5]), class, x1, y1, x2, y2
    Returns:
        correct (array[N, 10]), for 10 IoU levels
    """

预测框的可视化：
5247.png
7945.png
8544.png

构造返回结果数组

对于每一个预测框，在不同的阈值下会判断成True 或 False。构造一个所有预测框在所有阈值下的结果二维数组。

    # 预测正确的记录，所有iouv [0.5, 0.55, 0.6 ... 0.95]阈值下iou大于阈值且类型匹配的结果。
    # shape：(300, 10)  300个预测，10个阈值
    correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)
  1. detections.shape[0]： 300
  2. iouv.shape[0]：10

最终的结果可以理解成300个预测框在10个不同阈值下一共会有3000个结果，结果为布尔数组。

计算所有预测框和标注框的IOU结果

将gt框和预测框传入box_iou函数，得到结果。

"""
计算gt框和预测的iou，这个过程会出现广播机制，5个gt框分别和300个预测框计算iou,得到的结果为5,300
(Pdb) pp detections[:, :4].shape
torch.Size([300, 4])
(Pdb) pp labels[:, 1:].shape
torch.Size([5, 4])
(Pdb) pp iou.shape
torch.Size([5, 300])
"""
iou = box_iou(labels[:, 1:], detections[:, :4])
  1. labels[:, 1:]：（5, 4）
  2. detections[:, :4]：（300, 4）

5个标注框和300个预测框匹配，也就是拿每一个标注框都和300个预测框匹配，得到5*300个结果。相当于每一行代表这一个标注框和预测框的iou匹配结果。

tensor([[0.00000, 0.00000, 0.78682, 0.02270, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.02236, 0.00000, 0.00000, 0.00000, 0.00000, 0.43876, 0.70469, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000,
         0.00000, 0.00000, 0.00000, 0.04540, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.46606, 0.00000, 0.00000, 0.00000, 0.00000, 0.13432, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.53255,

匹配标签

上一步计算了预测框和标注框的iou，这一步计算预测类别和标注类别的匹配。

    
    """
    计算标签匹配。labels[:, 0:1]代表所有标注的标签。用每一个gt的标签和所有的预测的标签匹配。
    过程存在广播机制，结果为：torch.Size([5, 300])
    结果中 0维也就是5是gt的label  1维也就是300是预测label
    (Pdb) labels[:, 0:1].shape
    torch.Size([5, 1])
    (Pdb) detections[:, 5].shape
    torch.Size([300])
    correct_class.shape
    torch.Size([5, 300])
    """
    correct_class = labels[:, 0:1] == detections[:, 5]

labels[:, 0:1]：[5, 1]
detections[:, 5]: [300]
和上一步类似，每一个标注类表和预测类别匹配，5个标注类别和300个预测类别匹配，得到一个5*300的结果。得到的是一个布尔数组

(Pdb) correct_class
tensor([[ True,  True,  True,  True,  True,  True,  True, False,  True,  True, False, False,  True, False,  True,  True, False, False,  True, False,  True, False,  True,  True,  True,  True,  True,  True, False, False,  True,  True,  True, False,  True,  True, False,  True,  True, False,  True, False, False,  True,
         False,  True,  True,  True,  True,  True,  True,  True,  True, False, False, False,  True,  True, False,  True,  True, False, False,  True,  True,  True, False,  True,  True,  True,  True, False,  True,  True,  True,  True, False, False,  True,  True,  True,  True,  True,  True,  True,  True,  True, False

遍历所有阈值计算在不同的阈值下预测正确的个数

阈值数组是[0.50000, 0.55000, 0.60000, 0.65000, 0.70000, 0.75000, 0.80000, 0.85000, 0.90000, 0.95000]，计算在不同的阈值下预测框和标注框的iou匹配结果。以0.5为例，大于0.5为True，小于0.5为False

# 循环遍历所有的iou阈值，计算在不同的阈值下预测正确的个数
for i in range(len(iouv)):
    # (iou >= iouv[i]) & correct_class 得到一个布尔数组
    # torch.where((iou >= iouv[i]) & correct_class) 筛选出布尔数组中为True的元素，返回和布尔数组结构一致，返回为True元素在当前张量中的坐标。当前为二维数组。
    # 返回两个元素，元素1是数组，代表为True元素的x轴下标， 元素2也是数组，代表为True元素的y轴下标。
    # 类似：(tensor([0, 0, 1, 1]), tensor([0, 1, 1, 3]))
    x = torch.where((iou >= iouv[i]) & correct_class)  # IoU > threshold and classes match

(iou >= iouv[i]) & correct_class
iou 是 [5, 300]的iou结果
correct_class 是[5, 300]的类别结果
将两者的判断与操作，得到的就是iou大于阈值，且类别正确的结果。结果是5*300的布尔数组

torch.where((iou >= iouv[i]) & correct_class)
筛选出布尔数组中为True的元素，返回Ture在张量中的坐标。
x的结果如下，结果代表的含义是第一个张量代表标注标签的ID，第二个张量代表匹配的对应的预测标签的ID。

(tensor([0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 5], device='cuda:0'),
 tensor([ 2, 67, 68,  3, 79,  5, 31, 90,  4, 86,  1, 85, 92,  0], device='cuda:0'))

判断是否有正确匹配的结果

# 判断是否有结果
if x[0].shape[0]:

    """
    将结果汇总成[label, detect, iou]的格式。
    label：gt的标签的下标
    detect： 预测结果标签的下标
    iou: 预测和gt的iou值
    
    torch.stack(x, 1) 将x轴和y轴表示的坐标转换成[x, y]的格式
    iou[x[0], x[1]][:, None]) 获取iou中匹配上的元素值
    """
    matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()  # [label, detect, iou]

torch.stack(x, 1)将标注框的ID和预测框的ID组合在一次
iou[x[0], x[1]][:, None]筛选出对应的IOU值
将两者组合在一起，得到的就是[label_id, detect_id, iou]

去除重复匹配

一个gt框可能和多个预测框的iou都大于阈值，这是完全可能的。这里只保留最好的匹配，所以把那些多余的匹配都去掉。一个gt框只保留一个预测框，同时一个预测框只对应一个gt框。

# 匹配存在多个元素，可能是因为广播机制导致的重复，去除重复。
if x[0].shape[0] > 1:
    # 对置信度排序，倒序排列
    matches = matches[matches[:, 2].argsort()[::-1]]

    # 对预测detect进行去重，一个预测框只保留一个iou匹配。返回去重之后的matches
    matches = matches[np.unique(matches[:, 1], return_index=True)[1]]

    # 对label进行去重，一个gt框只保留一个最高iou匹配，返回去重之后的matches
    # matches = matches[matches[:, 2].argsort()[::-1]]
    matches = matches[np.unique(matches[:, 0], return_index=True)[1]]

保存结果

correct是300*10的二维数组，将对应行和列的元素设置为True。

# 将correct中相应的元素置为True
correct[matches[:, 1].astype(int), i] = True
  1. matches[:, 1].astype(int)预测框的下标
  2. i某一个阈值

将某一个阈值下对应的预测框设置成True，也就是代表着在该阈值下，预测框预测的类别正确，同时IOU也超过阈值。

完整代码

def process_batch(detections, labels, iouv, img=None):
    """
    Return correct prediction matrix
    Arguments:
        detections (array[N, 6]), x1, y1, x2, y2, conf, class
        labels (array[M, 5]), class, x1, y1, x2, y2
    Returns:
        correct (array[N, 10]), for 10 IoU levels
    """

    # 预测正确的记录，所有iouv [0.5, 0.55, 0.6 ... 0.95]阈值下iou大于阈值且类型匹配的结果。
    # shape：(300, 10)  300个预测，10个阈值
    correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)

    """
    计算gt框和预测的iou，这个过程会出现广播机制，5个gt框分别和300个预测框计算iou,得到的结果为5,300
    (Pdb) pp detections[:, :4].shape
    torch.Size([300, 4])
    (Pdb) pp labels[:, 1:].shape
    torch.Size([5, 4])
    (Pdb) pp iou.shape
    torch.Size([5, 300])
    """
    iou = box_iou(labels[:, 1:], detections[:, :4])

    breakpoint()

    # 计算标签匹配。labels[:, 0:1]代表所有标注的标签。用每一个gt的标签和所有的预测的标签匹配。
    # 过程存在广播机制，结果为：torch.Size([5, 300])
    # 结果中 0维也就是5是gt的label  1维也就是300是预测label
    """
    (Pdb) labels[:, 0:1].shape
    torch.Size([5, 1])
    (Pdb) detections[:, 5].shape
    torch.Size([300])
    correct_class.shape
    torch.Size([5, 300])
    """
    correct_class = labels[:, 0:1] == detections[:, 5]

    # 循环遍历所有的iou阈值，计算在不同的阈值下预测正确的个数
    for i in range(len(iouv)):
        # (iou >= iouv[i]) & correct_class 得到一个布尔数组
        # torch.where((iou >= iouv[i]) & correct_class) 筛选出布尔数组中为True的元素，返回和布尔数组结构一致，返回为True元素在当前张量中的坐标。当前为二维数组。
        # 返回两个元素，元素1是数组，代表为True元素的x轴下标， 元素2也是数组，代表为True元素的y轴下标。
        # 类似：(tensor([0, 0, 1, 1]), tensor([0, 1, 1, 3]))
        x = torch.where((iou >= iouv[i]) & correct_class)  # IoU > threshold and classes match

        # 判断是否有结果
        if x[0].shape[0]:

            """
            将结果汇总成[label, detect, iou]的格式。
            label：gt的标签的下标
            detect： 预测结果标签的下标
            iou: 预测和gt的iou值
            
            torch.stack(x, 1) 将x轴和y轴表示的坐标转换成[x, y]的格式
            iou[x[0], x[1]][:, None]) 获取iou中匹配上的元素值
            """
            matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()  # [label, detect, iou]

            # 匹配存在多个元素，可能是因为广播机制导致的重复，去除重复。
            if x[0].shape[0] > 1:
                # 对置信度排序，倒序排列
                matches = matches[matches[:, 2].argsort()[::-1]]

                # 对预测detect进行去重，一个预测框只保留一个iou匹配。返回去重之后的matches
                matches = matches[np.unique(matches[:, 1], return_index=True)[1]]

                # 对label进行去重，一个gt框只保留一个最高iou匹配，返回去重之后的matches
                matches = matches[np.unique(matches[:, 0], return_index=True)[1]]

            # 将correct中相应的元素置为True
            correct[matches[:, 1].astype(int), i] = True

            """
            (Pdb) pp correct
            array([[False, False, False, ..., False, False, False],
                   [False, False, False, ..., False, False, False],
                   [False, False, False, ..., False, False, False],
                   ...,
                   [False, False, False, ..., False, False, False],
                   [False, False, False, ..., False, False, False],
                   [False, False, False, ..., False, False, False]])
            (Pdb) pp correct.shape
            (300, 10)
            """

    return torch.tensor(correct, dtype=torch.bool, device=iouv.device)
namelijink
关注
  • 22
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
史上最全AP/mAP通用代码实现(即插即用-基于yolo模型)-中
weixin_38252409的博客
12-28 1249
史上最全AP、mAP详解与代码实现”文章（这里）已经介绍了map相关原理，且给出相应简单代码实现AP方法。然将AP计算融入模型求解AP结果，可能是一个较为复杂的工程量。恰好，我也有一些这样的需求，我是想计算相关DETR的map指标。我将构造一个即插即用计算map的相关模块代码，使用者只需赋值我的模块，即可使用。
【测试集mAP】yolov5中计算测试集mAP，修改类别序号为类别名称
weixin_44772147的博客
01-13 4174
yolov5计算测试集mAP
史上最全AP/mAP通用代码实现(yolov5 txt版本)-下
weixin_38252409的博客
03-08 1669
史上最全AP、mAP详解与代码实现”文章（这里）已经介绍了map相关原理，且给出相应简单代码实现AP方法。然将AP计算融入模型求解AP结果，可能是一个较为复杂的工程量。我也在http://t.csdnimg.cn/j410Y博客分享基于模型构造一个即插即用计算map的相关模块代码，使用者只需复制我的模块，即可使用。然，之前方法是需要使用xml格式，依然对yolo模型不甚友好，我再此修改为txt方式，使用yolo本身数据实现small、medium、large等相关AP或AP0.75等结果预测。
YOLOv5全面解析教程⑤：计算mAP用到的Numpy函数详解
OneFlow深度学习框架
02-24 4355
本文主要介绍在One-YOLOv5项目中计算mAP用到的一些numpy操作，这些numpy操作使用在utils/metrics.py中。本文是《YOLOv5全面解析教程④：目标检测模型精确度评估》的补充，希望能帮助到小伙伴们。欢迎Star、试用One-YOLOv5：https://github.com/Oneflow-Inc/one-yolov5用到的numpy操...
nms和P，R，map原理及在Yolov5代码中的解析
qq_40629612的博客
08-28 9367
nms，准确率，召回率，map原理讲解及示例，基于Yolov5代码中对以上指标进行解析，并分析各指标的利弊
YOLOv3 mAP计算教程
热门推荐
阿木寺的博客
08-10 3万+
前言 本文只介绍如何利用YOLOv3训练好的model来计算VOC数据集的mAP。 举一反三，很容易理解如何利用自己训练的model来计算自己的数据集的mAP。 1 运行detector valid命令，进行测试 ./darknet detector valid cfg/voc.data cfg/yolov3-voc.cfg backup/VOC/yolov3-voc_final.we...
Yolov5代码
weixin_57280374的博客
02-22 596
yolov5
Yolov5的mAP计算——代码解析
IThsyi的博客
03-25 7189
metrics.py # train.py调用 def fitness(x): # Model fitness as a weighted combination of metrics w = [0.0, 0.0, 0.1, 0.9] # weights for [P, R, mAP@0.5, mAP@0.5:0.95] return (x[:, :4] * w).sum(1) # val.py调用 def ap_per_class(tp, conf, pred_cls
YOLOv8改进方法
u010079117的博客
08-18 488
YOLOv8改进方法为解决复杂环境下番茄生长点花蕾检测的难题,本研究针对目标尺度多样、外观相似、遮挡严重等问题,从骨干网络(Backbone)、颈部结构(Neck)和检测头(Head)三个方面系统改进了YOLOv8的网络结构和损失函数,旨在提高其对弱小目标的检测精度和环境适应性。
YOLOv10训练，适合小白训练，新手YOLOv10训练自己数据集教程！超简单，超详细！！
weixin_51692073的博客
08-17 381
YOLOv10训练，适合小白训练，新手YOLOv10训练自己数据集教程！超简单，超详细！！
使用X-AnyLabeling自动标注数据集（以yolov10模型为例，多图详细介绍）
Bruce Che 的专栏
08-16 687
X-AnyLabeling 是一款全新的交互式自动标注工具，其基于AnyLabeling进行构建和二次开发，在此基础上扩展并支持了许多的模型和功能，并借助Segment Anything和YOLO等主流模型提供强大的 AI 支持。无须任何复杂配置，下载即用，支持自定义模型，极大提升用户标注效率！
yolo入门 yolov8下载安装--2024.8
2301_76924624的博客
08-15 615
喂饭级别配置yolov8环境
YOLOv8改进 | 融合改进 | C2f融合新颖的可扩张残差注意力模块助力小目标检测【完整代码】
kay_545
08-16 545
yolov8，模块缝合，yolov8改进，yolov8_C2f_DWR
基于YOLOv8的通用的滑动验证码滑块缺口检测模型
qq_29402011的博客
08-15 594
本文介绍了基于YOLOv8训练滑块验证码缺口检测模型的通用步骤
【逆向日记】1.关于YOLO视觉Ai软件逆向分析
DvlpNews
08-15 254
逆向后截图 逆向过程 分析应用类型 软件查壳 静态、动态基址分析 CE内存特征搜索 OD锁死特征长度、修改想要内容 动态补丁技术 CE基址记录
CV党福音：YOLOv8实现实例分割（二）之训练过程
pengxiang1998的博客
08-16 934
在上一篇博客中，我们已经了解了实例分割的基本流程，本章则是对数据集、以及训练过程等进行进一步的学习。在本次训练中，博主使用的是这个小数据集进行实验，该数据集内只有张图像：我们以第一张图像为例，其标签标注如下： 按行划分目标，第一个数字为目标类别，后面每两个数值为一个坐标（即标注的关键点的坐标） 第一张图像的检测与分割结果如下：与语义分割不同，实例分割一般是首先使用目标检测算法找到图像中的不同实例对象，然后对每个实例对象进行语义分割。 在YOLOv8中则是在原本检测头的基础上增加了分割头，两者共同作用。总的来
YOLO知识点总结：
最新发布
weixin_71113035的博客
08-18 1127
YOLO知识点总结：
【yolov8】6、labelimg安装使用-数据集标注
ladymorgana的博客
08-15 737
选择标注好的label标签存在的文件夹。选择标注的图片文件夹。
yolov5 map计算公式
08-07
Yolov5中的mAP（mean Average Precision）计算公式是根据Pascal VOC的标准进行计算的。具体的计算过程如下： 1. 首先，对于每个类别，将预测框按照置信度从高到低进行排序。 2. 然后，根据预测框的置信度和真实框的重叠程度（IoU），计算每个预测框的Precision和Recall。 3. 接着，根据不同的置信度阈值，计算Precision-Recall曲线。 4. 最后，根据Precision-Recall曲线下的面积来计算每个类别的AP，并取所有类别AP的平均值得到mAP。 具体的公式如下： 1. Precision = True Positive / (True Positive + False Positive) 2. Recall = True Positive / (True Positive + False Negative) 3. Precision-Recall曲线下的面积可以通过插值的方法进行计算，常用的有11-point插值和AP插值两种方法。 4. 最后，mAP可以通过计算所有类别的AP的平均值得到。 需要注意的是，Yolov5中的mAP计算可能会有一些细微的差别，具体的实现细节可以参考Yolov5的源代码或相关文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值