语义分割miou指标计算详解

2024-01-14 00:28
文章标签 计算 详解 分割 指标 语义 miou

本文主要是介绍语义分割miou指标计算详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • 1. 语义分割的评价指标
    • 2. 混淆矩阵计算
      • 2.1 np.bincount的使用
      • 2.2 混淆矩阵计算
    • 3. 语义分割指标计算
      • 3.1 IOU计算
        • 方式1(推荐)
        • 方式2
      • 3.2 Precision 计算
      • 3.3 总体的Accuracy计算
      • 3.4 Recall 计算
      • 3.5 MIOU计算
    • 参考

MIoU全称为Mean Intersection over Union，平均交并比。可作为语义分割系统性能的评价指标。

  • P：Prediction预测值
  • G：Ground Truth真实值
    在这里插入图片描述
    其中IOU: 交并比就是该类的真实标签和预测值的交和并的比值
    在这里插入图片描述
    单类的交并比可以理解为下图：
    在这里插入图片描述

1. 语义分割的评价指标

True Positive (TP): 把正样本成功预测为正。
True Negative (TN)：把负样本成功预测为负。
False Positive (FP)：把负样本错误地预测为正。
False Negative (FN)：把正样本错误的预测为负。

  • (1) Accuracy准确率，指的是“预测正确的样本数÷样本数总数”。计算公式为：
    A c c u r a c y = T P + T N T P + T N + F P + F N Accuracy = \frac{TP+TN}{TP+TN+FP+FN} Accuracy=TP+TN+FP+FNTP+TN​

  • (2) Precision精确率或者精度，指的是预测为Positive的样本，占所有预测样本的比率
    P r e c i s i o n = T P T P + F P Precision= \frac{TP}{TP+FP} Precision=TP+FPTP​

  • (3)Recall召回率，指的是预测为Positive的样本，占所有Positive样本的比率
    P r e c i s i o n = T P P Precision= \frac{TP}{P} Precision=PTP​

  • (4) F1 score: 综合考虑了precision和recall两方面的因素，做到了对于两者的调和，即：既要“求精”也要“求全”，做到不偏科。

F 1 s c o r e = 2 ∗ p r e c i s i o n ∗ r e c a l l p r e c i s i o n + r e c a l l F1 score= \frac{2*precision*recall}{precision+recall} F1score=precision+recall2∗precision∗recall​

  • (5) MIOU 作为为语义分割最重要标准度量。其计算两个集合的交集和并集之比，在语义分割的问题中，这两个集合为真实值和预测值。在每个类上计算IoU，之后平均。计算公式如下
    M I O U = 1 k + 1 ∑ i = 0 k T P F N + F P + T P MIOU =\frac{1}{k+1}\sum_{i=0}^{k}\frac{TP}{FN+FP+TP} MIOU=k+11​i=0∑k​FN+FP+TPTP​
    等价于:
    M I O U = 1 k + 1 ∑ i = 0 k p i i ∑ j = 0 k p i j + ∑ j = 0 k p j i − p i i MIOU=\frac{1}{k+1}\sum_{i=0}^{k}\frac{p_{ii}}{\sum_{j=0}^k p_{ij} + \sum_{j=0}^k p_{ji} -p_{ii}} MIOU=k+11​i=0∑k​∑j=0k​pij​+∑j=0k​pji​−pii​pii​​

其中： p i i p_{ii} pii​ 真实为类别i,预测也为i的像素个数，也就是正确预测的像素个数TP; p i j p_{ij} pij​表示真实为类别i,但预测为类别j的像素个数，也就是FN； p j i p_{ji} pji​表示真实为类别j，但预测为类别i的像素个数， 也就是FP

注意: 对于多分类，TN为0 ，即没有所谓的负样本

2. 混淆矩阵计算

  • 计算MIoU，我们需要借助混淆矩阵来进行计算。
  • 混淆矩阵就是统计分类模型的分类结果，即：统计归对类，归错类的样本的个数，然后把结果放在一个表里展示出来，这个表就是混淆矩阵
  • 其每一列代表预测值（pred)，每一行代表的是实际的类别(gt)
    在这里插入图片描述
  • 对角都对TP，横看真实，竖看预测: 每一行之和，为该行对应类(如Cat)的总数；每一列之和为该列对应类别的预测的总数。

2.1 np.bincount的使用

在计算混淆矩阵时，可以利用np.bincount函数方便我们计算。

numpy.bincount(x, weights=None, minlength=None)
  • 该方法返回每个索引值在x中出现的次数
  • 给一个向量x，x中最大的元素记为j，返回一个向量1行j+1列的向量y，y[i]代表i在x中出现的次数
#x中最大的数为7，那么它的索引值为0->7
x = np.array([0, 1, 1, 3, 2, 1, 7])
#索引0出现了1次，索引1出现了3次......索引5出现了0次......
np.bincount(x)
#因此，输出结果为：array([1, 3, 1, 1, 0, 0, 0, 1])
  • minlength也是一个常用的参数，表示输出的数组长度至少为minlength，如果x中最大的元素加1大于数组长度，那么数组的长度以x中最大元素加1为准（例如，如果数组中最大元素为3，minlength=5，那么数组的长度为5；如果数组中最大元素为7，minlength=5，那么数组的最大长度为7+1=8，这里之所以加1是因为元素0也占了一个索引）。举个例子说明：
# a中最大的数为3，因此数组长度为4，那么它的索引值为0->3
a = np.array([2, 2, 1, 3 ])
# 本来数组的长度为4，但指定了minlength为7，因此现在数组长度为7（多的补0），所以现在它的索引值为0->6
np.bincount(x, minlength=7)
# 输出结果为：array([0, 1, 2, 1, 0, 0, 0])# a中最大的数为4，因此bin的数量为5，那么它的索引值为0->4
x = np.array([4, 2, 3, 1, 2])
# 数组的长度原本为5，但指定了minlength为1，因为5 > 1，所以这个参数不起作用，索引值还是0->4
np.bincount(x, minlength=1)
# 输出结果为：array([0, 1, 2, 1，1])

2.2 混淆矩阵计算

# 设标签宽W，长H
def fast_hist(a, b, n):#--------------------------------------------------------------------------------##   a是转化成一维数组的标签，形状(H×W,)；b是转化成一维数组的预测结果，形状(H×W,)#--------------------------------------------------------------------------------#k = (a >= 0) & (a < n)#--------------------------------------------------------------------------------##   np.bincount计算了从0到n**2-1这n**2个数中每个数出现的次数，返回值形状(n, n)#   返回中，写对角线上的为分类正确的像素点#--------------------------------------------------------------------------------#return np.bincount(n * a[k].astype(int) + b[k], minlength=n ** 2).reshape(n, n)
  • 产生n×n的混淆矩阵统计表
    • 参数a：即：真实的标签gt， 需要reshape为一行输入
    • 参数b：即预测的标签pred，它是经过argmax输出的预测8位标签图, 每个像素表示为类别索引（reshape为一行输入)，
    • 参数n:类别数cls_num
  • 首先过滤gt中，类别超过n的索引，确保gt的分类都包含在n个类别中
 k = (a >= 0) & (a < n)
  • 如果要去掉背景，不将背景计算在混淆矩阵，则可以写为:
 k = (a > 0) & (a < n) #去掉了背景,假设0是背景
  • 然后利用np.bincount生成元素个数为n*n的数组，并且reshape为 n × n n \times n n×n的混淆矩阵，这样确保混淆矩阵行和列都为类别class的个数n
  • n*n数组中，每个元素的值，表示为0~n*n的索引值在x中出现的次数，这样就获得了最终混淆矩阵。这里的x表示为n * a[k] + b[k] , 为啥这么定义呢？，

举例如下：将图片的gt标签a和pred输出图片b，都转换为一行; a和b中每个元素代表类别索引

在这里插入图片描述

  • 前面8, 9, 4, 7, 6都预测正确， 对于预测正确的像素来说，n * a + b就是对角线的值; 假设n=10，有10类。n * a + b就是88, 99, 44, 77, 66
  • 紧接着6预测成了5， 因此n * a + b就是65
  • 88, 99, 44, 77, 66就是对角线上的值（如下图红框，65就是预测错误，并且能真实反映把6预测成了5（如下图蓝框）
    在这里插入图片描述

3. 语义分割指标计算

在这里插入图片描述

图 混淆矩阵

3.1 IOU计算

方式1(推荐)

计算每个类别的IOU计算：
I O U = T P F N + F P + T P IOU =\frac{TP}{FN+FP+TP} IOU=FN+FP+TPTP​

def per_class_iu(hist):return np.diag(hist) / np.maximum((hist.sum(1) + hist.sum(0) - np.diag(hist)), 1)
  • 输入hist 表示 2维的混淆矩阵，大小为n*n (n为类别数)
  • 混淆矩阵对角线元素值，表示每个类别预测正确的数TP:
np.diag(hist)
  • 其中：混淆矩阵所对应行中，每一行为对应类别(如类1)的统计值中，对角线位置为正常预测为该类别的统计值(TP)，其他位置则是错误的将该类别预测为其他的类别FN: 因此每个类别的FP统计值为：
FN =hist.sum(1) -TP = hist.sum(1) - np.diag(hist)
  • 同理，预测为该类别所对应的列中，对角线为正确预测，其他位置则是将其他类别错误的预测为该列所对应的类别，也就是FP
FP =hist.sum(0) -TP = hist.sum(0) - np.diag(hist)

因此分母FN_FP+TP=np.maximum（hist.sum(1) + hist.sum(0) - np.diag(hist),1), 这里加上np.maximum确保了分母不为0

方式2
def IOU(pred,target,n_classes = args.num_class ):ious = []# ignore IOU for background classfor cls in range(1,n_classes):pred_inds = pred == clstarget_inds = target == cls# target_sum = target_inds.sum()intersection = (pred_inds[target_inds]).sum()union = pred_inds.sum() + target_inds.sum() - intersectionif union == 0:ious.append(float('nan')) # If there is no ground truth，do not include in evaluationelse:ious.append(float(intersection)/float(max(union,1)))return ious

参考：https://github.com/dilligencer-zrj/code_zoo/blob/master/compute_mIOU

3.2 Precision 计算

每个类别的Precision 计算如下：

P r e c i s i o n = T P T P + F P Precision= \frac{TP}{TP+FP} Precision=TP+FPTP​

def per_class_Precision(hist):return np.diag(hist) / np.maximum(hist.sum(0), 1)
  • 其中 np.diag(hist) 为TP值，hist.sum(0)表示为 TP+FP, np.maximum确保确保分母不为0

3.3 总体的Accuracy计算

总体的Accuracy计算如下:

A c c u r a c y = T P + T N T P + T N + F P + F N Accuracy = \frac{TP+TN}{TP+TN+FP+FN} Accuracy=TP+TN+FP+FNTP+TN​
由于是多类别，没有负样本，因此TN为0。

def per_Accuracy(hist):return np.sum(np.diag(hist)) / np.maximum(np.sum(hist), 1)

3.4 Recall 计算

recall指的是预测为Positive的样本，占所有Positive样本的比率
P r e c i s i o n = T P P Precision= \frac{TP}{P} Precision=PTP​

def per_class_PA_Recall(hist):return np.diag(hist) / np.maximum(hist.sum(1), 1)
  • 每一行统计值为该类别样本的真实数量P, 因此P = hist.sum(1)

3.5 MIOU计算

def compute_mIoU(gt_dir, pred_dir, png_name_list, num_classes, name_classes=None):  print('Num classes', num_classes)  #-----------------------------------------##   创建一个全是0的矩阵，是一个混淆矩阵#-----------------------------------------#hist = np.zeros((num_classes, num_classes))#------------------------------------------------##   获得验证集标签路径列表，方便直接读取#   获得验证集图像分割结果路径列表，方便直接读取#------------------------------------------------#gt_imgs     = [join(gt_dir, x + ".png") for x in png_name_list]  pred_imgs   = [join(pred_dir, x + ".png") for x in png_name_list]  #------------------------------------------------##   读取每一个（图片-标签）对#------------------------------------------------#for ind in range(len(gt_imgs)): #------------------------------------------------##   读取一张图像分割结果，转化成numpy数组#------------------------------------------------#pred = np.array(Image.open(pred_imgs[ind]))  #------------------------------------------------##   读取一张对应的标签，转化成numpy数组#------------------------------------------------#label = np.array(Image.open(gt_imgs[ind]))  # 如果图像分割结果与标签的大小不一样，这张图片就不计算if len(label.flatten()) != len(pred.flatten()):  print('Skipping: len(gt) = {:d}, len(pred) = {:d}, {:s}, {:s}'.format(len(label.flatten()), len(pred.flatten()), gt_imgs[ind],pred_imgs[ind]))continue#------------------------------------------------##   对一张图片计算21×21的hist矩阵，并累加#------------------------------------------------#hist += fast_hist(label.flatten(), pred.flatten(), num_classes)  # 每计算10张就输出一下目前已计算的图片中所有类别平均的mIoU值if name_classes is not None and ind > 0 and ind % 10 == 0: print('{:d} / {:d}: mIou-{:0.2f}%; mPA-{:0.2f}%; Accuracy-{:0.2f}%'.format(ind, len(gt_imgs),100 * np.nanmean(per_class_iu(hist)),100 * np.nanmean(per_class_PA_Recall(hist)),100 * per_Accuracy(hist)))#------------------------------------------------##   计算所有验证集图片的逐类别mIoU值#------------------------------------------------#IoUs        = per_class_iu(hist)PA_Recall   = per_class_PA_Recall(hist)Precision   = per_class_Precision(hist)#------------------------------------------------##   逐类别输出一下mIoU值#------------------------------------------------#if name_classes is not None:for ind_class in range(num_classes):print('===>' + name_classes[ind_class] + ':\tIou-' + str(round(IoUs[ind_class] * 100, 2)) \+ '; Recall (equal to the PA)-' + str(round(PA_Recall[ind_class] * 100, 2))+ '; Precision-' + str(round(Precision[ind_class] * 100, 2)))#-----------------------------------------------------------------##   在所有验证集图像上求所有类别平均的mIoU值，计算时忽略NaN值#-----------------------------------------------------------------#print('===> mIoU: ' + str(round(np.nanmean(IoUs) * 100, 2)) + '; mPA: ' + str(round(np.nanmean(PA_Recall) * 100, 2)) + '; Accuracy: ' + str(round(per_Accuracy(hist) * 100, 2)))  return np.array(hist, np.int), IoUs, PA_Recall, Precision
  • 首先创建一个维度为(num_classes, num_classes)的空混淆矩阵hist
  • 遍历pred_imgs和gt_imgs, 将遍历得到的每一张pred 和label展平(flatten)到一维，输入到fast_hist计算单张图片预测的混淆矩阵,将每次的计算结果加到总的混淆矩阵hist中
for ind in range(len(gt_imgs)): #------------------------------------------------##   读取一张图像分割结果，转化成numpy数组#------------------------------------------------#pred = np.array(Image.open(pred_imgs[ind]))  #------------------------------------------------##   读取一张对应的标签，转化成numpy数组#------------------------------------------------#label = np.array(Image.open(gt_imgs[ind]))  # 如果图像分割结果与标签的大小不一样，这张图片就不计算if len(label.flatten()) != len(pred.flatten()):  print('Skipping: len(gt) = {:d}, len(pred) = {:d}, {:s}, {:s}'.format(len(label.flatten()), len(pred.flatten()), gt_imgs[ind],pred_imgs[ind]))continue#------------------------------------------------##   对一张图片计算21×21的hist矩阵，并累加#------------------------------------------------#hist += fast_hist(label.flatten(), pred.flatten(), num_classes)
  • 每计算10张就输出一下目前已计算的图片中所有类别平均的mIoU值
# 每计算10张就输出一下目前已计算的图片中所有类别平均的mIoU值if name_classes is not None and ind > 0 and ind % 10 == 0: print('{:d} / {:d}: mIou-{:0.2f}%; mPA-{:0.2f}%; Accuracy-{:0.2f}%'.format(ind, len(gt_imgs),100 * np.nanmean(per_class_iu(hist)),100 * np.nanmean(per_class_PA_Recall(hist)),100 * per_Accuracy(hist)))
  • 遍历完成后，得到所有类别的Iou值IoUs以及PA_Recall 和Precision ,并逐类别输出一下mIoU值
   if name_classes is not None:for ind_class in range(num_classes):print('===>' + name_classes[ind_class] + ':\tIou-' + str(round(IoUs[ind_class] * 100, 2)) \+ '; Recall (equal to the PA)-' + str(round(PA_Recall[ind_class] * 100, 2))+ '; Precision-' + str(round(Precision[ind_class] * 100, 2)))
  • 最后在所有验证集图像上求所有类别平均的mIoU值
 print('===> mIoU: ' + str(round(np.nanmean(IoUs) * 100, 2)) + '; mPA: ' + str(round(np.nanmean(PA_Recall) * 100, 2)) + '; Accuracy: ' + str(round(per_Accuracy(hist) * 100, 2)))

参考

  • https://github.com/bubbliiiing/deeplabv3-plus-pytorch/blob/main/utils/utils_metrics.py
  • https://github.com/dilligencer-zrj/code_zoo/blob/master/compute_mIOU
  • https://www.jianshu.com/p/42939bf83b8a

这篇关于语义分割miou指标计算详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/603310。

相关文章

Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息，即可快速实现设备配网，是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递，利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力，实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后，即可发送相关配网数据。同时还支持与常规Sof
阅读更多...
poj 1113 凸包+简单几何计算

poj 1113 凸包+简单几何计算

题意： 给N个平面上的点，现在要在离点外L米处建城墙，使得城墙把所有点都包含进去且城墙的长度最短。 解析： 韬哥出的某次训练赛上A出的第一道计算几何，算是大水题吧。 用convexhull算法把凸包求出来，然后加加减减就A了。 计算见下图： 好久没玩画图了啊好开心。 代码： #include <iostream>#include <cstdio>#inclu
阅读更多...
uva 1342 欧拉定理（计算几何模板）

uva 1342 欧拉定理（计算几何模板）

题意： 给几个点，把这几个点用直线连起来，求这些直线把平面分成了几个。 解析： 欧拉定理： 顶点数 + 面数 - 边数= 2。 代码： #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#inc
阅读更多...
uva 11178 计算集合模板题

uva 11178 计算集合模板题

题意： 求三角形行三个角三等分点射线交出的内三角形坐标。 代码： #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#include <stack>#include <vector>#include <
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
XTU 1237 计算几何

XTU 1237 计算几何

题面： Magic Triangle Problem Description: Huangriq is a respectful acmer in ACM team of XTU because he brought the best place in regional contest in history of XTU. Huangriq works in a big compa
阅读更多...
K8S（Kubernetes）开源的容器编排平台安装步骤详解

K8S（Kubernetes）开源的容器编排平台安装步骤详解

K8S（Kubernetes）是一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用程序。以下是K8S容器编排平台的安装步骤、使用方式及特点的概述： 安装步骤： 安装Docker：K8S需要基于Docker来运行容器化应用程序。首先要在所有节点上安装Docker引擎。 安装Kubernetes Master：在集群中选择一台主机作为Master节点，安装K8S的控制平面组件，如AP
阅读更多...
嵌入式Openharmony系统构建与启动详解

嵌入式Openharmony系统构建与启动详解

大家好，今天主要给大家分享一下，如何构建Openharmony子系统以及系统的启动过程分解。 第一：OpenHarmony系统构建      首先熟悉一下，构建系统是一种自动化处理工具的集合，通过将源代码文件进行一系列处理，最终生成和用户可以使用的目标文件。这里的目标文件包括静态链接库文件、动态链接库文件、可执行文件、脚本文件、配置文件等。      我们在编写hellowor
阅读更多...
LabVIEW FIFO详解

LabVIEW FIFO详解

在LabVIEW的FPGA开发中，FIFO（先入先出队列）是常用的数据传输机制。通过配置FIFO的属性，工程师可以在FPGA和主机之间，或不同FPGA VIs之间进行高效的数据传输。根据具体需求，FIFO有多种类型与实现方式，包括目标范围内FIFO（Target-Scoped）、DMA FIFO以及点对点流（Peer-to-Peer）。 FIFO类型 **目标范围FIFO（Target-Sc
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2