图像分割中的混淆矩阵和利用混淆矩阵计算指标

目录

1. 介绍

2. 创建混淆矩阵

2.1 update 方法

2.2 compute 方法

2.3 str 方法

3. 测试

4. 完整代码


1. 介绍

语义分割中,性能指标可以利用混淆矩阵进行计算

这里实现的方法和图像分类中不一样,需要的可以参考:混淆矩阵Confusion Matrix

 

这里采用的测试数据如下:

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第1张图片

 

2. 创建混淆矩阵

混淆矩阵的实现如下

init 是初始化混淆矩阵

update 更新混淆矩阵的数值

reset 将矩阵的值清零

compute 根据update 算出来的混淆矩阵计算相应的性能指标

str 是返回的字符串,就是实例化混淆矩阵后,print的值

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第2张图片

 

这里讲解混淆矩阵类的测试数据都是上面的:

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第3张图片

2.1 update 方法

如下:

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第4张图片

a传入的是真实的label,b传入的是网络预测的值,注:这里的预测值也是和label一样的整型数组

首先通过init初始化方法将混淆矩阵的大小赋值给n(分类类别的个数+1 背景),然后创建混淆矩阵mat,先初始化为0

接下来,k在真正标签a中找到对应的索引,

这里目的是为了将不感兴趣的区域设为False,其余的具体分割标签应该为1,2,3这样的排序方式。因为通常0为背景,255为不感兴趣的区域。

例如,当分割类别为2(1,2),那么加上背景传入的n就是3(0,1,2),同时不感兴趣的区域设置为255(0,1,2,255)。那么在k在真实标签a(0,1,2,255)中的索引,就会将a>=0 & a

所以,dataset加载数据中,要将前景从1,2,3这样排序

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第5张图片

 

然后,通过下面的操作就能将横坐标为true,纵坐标为pred的混淆矩阵update

中间的inds大概是将a和b变为一维向量,那么n*a就会将一维向量变为n个为一组的样子,然后在里面进行计算,最后reshape成n*n的矩阵就行了。具体的可以自己调试一下

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第6张图片

 例如,true = 1,pred = 0 的个数是一个,同样在混淆矩阵的值也是1(第0行,第1列)

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第7张图片

 

2.2 compute 方法

compute 是利用update产生的混淆矩阵,计算分割任务中的性能指标,关于分割任务的性能指标,可以查看:关于语义分割常见的评价指标

混淆矩阵:横坐标为true,纵坐标为pred

像素准确率 = 混淆矩阵对角线 / 混淆矩阵的sum

acc 这里是指各个类别的召回率 = 各个对角线的值 / 真实值(矩阵的行为ture,所以对行求和)

recall 召回率就是在...召回的个数,...就是label,召回的个数就是预测正确的个数。所以召回率就是在label中,预测正确个数的占比

iou 就是各个对角线的值 / (对应行 + 对应列 - 重复的对角线的值)

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第8张图片

2.3 str 方法

python类中str方法,是返回实例化类的print的值

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第9张图片

 

因此混淆矩阵类中的str方法返回的是compute计算出的性能指标。

因为这里的str方法自动调用了compute,而compute是根据update计算的。所以调用str之前,一定要先调用update方法,更新混淆矩阵的值

这里的recall和iou都是针对不同类别的,所以返回是个列表

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第10张图片

 

3. 测试

测试的代码如下:

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第11张图片

 测试的样本为:

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第12张图片

这里手动计算分割的参数,验证混淆矩阵

首先是像素准确率:4 / 9 = 0.4444

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第13张图片

然后是各个类别的召回率:这里是三个类别0 1 2 

图像分割中的混淆矩阵和利用混淆矩阵计算指标_第14张图片

然后是iou:

对于0:1 / 3 =0.3333

对于1:1 / 6 =0.1667

对于2:2 / 5 =0.4

最后mean iou就是iou的均值:(0.3333+0.1667+0.4) / 3 = 0.9 / 3 = 0.3

4. 完整代码

混淆矩阵的代码:

import torch


# 混淆矩阵
class ConfusionMatrix(object):
    def __init__(self, num_classes):
        self.num_classes = num_classes      # 分类个数(加了背景之后的)
        self.mat = None         # 混淆矩阵

    def update(self, a, b):      # 计算混淆矩阵,a = Ture,b = Predict
        n = self.num_classes
        if self.mat is None:         # 创建混淆矩阵
            self.mat = torch.zeros((n, n), dtype=torch.int64, device=a.device)
        with torch.no_grad():
            k = (a >= 0) & (a < n)
            inds = n * a[k].to(torch.int64) + b[k]      # 统计像素真实类别a[k]被预测成类别b[k]的个数(这里的做法很巧妙)
            self.mat += torch.bincount(inds, minlength=n**2).reshape(n, n)

    def reset(self):
        if self.mat is not None:
            self.mat.zero_()

    def compute(self):      # 计算分割任务的性能指标
        h = self.mat.float()

        acc_global = torch.diag(h).sum() / h.sum()     # 计算全局预测准确率(混淆矩阵的对角线为预测正确的个数)
        acc = torch.diag(h) / h.sum(1)                 # 计算每个类别的 recall
        iou = torch.diag(h) / (h.sum(1) + h.sum(0) - torch.diag(h))     # 计算iou
        return acc_global, acc, iou

    def __str__(self):
        acc_global, acc, iou = self.compute()
        return (
            'global correct: {:.4f}\n'
            'recall: {}\n'
            'IoU: {}\n'
            'mean IoU: {:.4f}').format(
            acc_global.item() ,
            ['{:.4f}'.format(i) for i in acc.tolist()],
            ['{:.4f}'.format(i) for i in iou.tolist()],
            iou.mean().item())

测试的代码:

confmat = ConfusionMatrix(num_classes=3)    # 实例化混淆矩阵

ture = torch.LongTensor([[1,2,1],[0,2,2],[0,1,1]])
pred = torch.LongTensor([[1,2,0],[1,2,1],[0,2,2]])

confmat.update(ture, pred)  # update 混淆矩阵的值
print(confmat)
'''
global correct: 0.4444
recall: ['0.5000', '0.2500', '0.6667']
IoU: ['0.3333', '0.1667', '0.4000']
mean IoU: 0.3000
'''

你可能感兴趣的:(#,关于,segmentation,矩阵,python,算法)