目录
1. 介绍
2. 创建混淆矩阵
2.1 update 方法
2.2 compute 方法
2.3 str 方法
3. 测试
4. 完整代码
1. 介绍
语义分割中，性能指标可以利用混淆矩阵进行计算
这里实现的方法和图像分类中不一样，需要的可以参考：混淆矩阵Confusion Matrix
这里采用的测试数据如下：
2. 创建混淆矩阵
混淆矩阵的实现如下
init 是初始化混淆矩阵
update 更新混淆矩阵的数值
reset 将矩阵的值清零
compute 根据update 算出来的混淆矩阵计算相应的性能指标
str 是返回的字符串，就是实例化混淆矩阵后，print的值
这里讲解混淆矩阵类的测试数据都是上面的：
2.1 update 方法
如下：
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<n ，也就是0，1，2 的区域设置为True，从而满足了分割要求且拍出来255不感兴趣的
所以，dataset加载数据中，要将前景从1，2，3这样排序
然后，通过下面的操作就能将横坐标为true，纵坐标为pred的混淆矩阵update
中间的inds大概是将a和b变为一维向量，那么n*a就会将一维向量变为n个为一组的样子，然后在里面进行计算，最后reshape成n*n的矩阵就行了。具体的可以自己调试一下
例如，true = 1，pred = 0 的个数是一个，同样在混淆矩阵的值也是1(第0行,第1列)
2.2 compute 方法
compute 是利用update产生的混淆矩阵，计算分割任务中的性能指标，关于分割任务的性能指标，可以查看：关于语义分割常见的评价指标
混淆矩阵：横坐标为true，纵坐标为pred
像素准确率 = 混淆矩阵对角线 / 混淆矩阵的sum
acc 这里是指各个类别的召回率 = 各个对角线的值 / 真实值(矩阵的行为ture，所以对行求和)
recall 召回率就是在...召回的个数，...就是label，召回的个数就是预测正确的个数。所以召回率就是在label中，预测正确个数的占比
iou 就是各个对角线的值 / (对应行 + 对应列 - 重复的对角线的值)
2.3 str 方法
python类中str方法，是返回实例化类的print的值
因此混淆矩阵类中的str方法返回的是compute计算出的性能指标。
因为这里的str方法自动调用了compute，而compute是根据update计算的。所以调用str之前，一定要先调用update方法，更新混淆矩阵的值
这里的recall和iou都是针对不同类别的，所以返回是个列表
3. 测试
测试的代码如下：
测试的样本为：
这里手动计算分割的参数，验证混淆矩阵
首先是像素准确率：4 / 9 = 0.4444
然后是各个类别的召回率：这里是三个类别0 1 2
然后是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
'''
