MIOU的计算

MIOU，即平均交并比（Mean Intersection over Union），是评价语义分割模型性能的一个重要指标。它计算的是预测结果中每一类结果的交并比的平均值。假设绿色为真实的标签值，粉红色为预测的结果。

所谓交并比，就是这两种数据的相交元素数量/两种数据的并集的元素数量，如下图所示：

下面我们来一下MIOU的计算方法。

1. IOU的计算

要计算平均交并比，就要首先计算每一类的交并比。交并比（Intersection over Union）是衡量预测值与真实值相似度的一个指标。第i类IOU的计算公式如下：

其中，TP代表真正例，即某类别i的像素正确预测为该类别的数量；

FP代表假正例，即非类别i的像素预测为该类别的数量；

FN代表假负例，即类别i的像素预测为非该类别的数量；

获取到这几个值之后就可以计算出交并比IOU了。

2. 混淆矩阵的计算

混淆矩阵是一个n*n的矩阵（n是类别数），用于表示实际类别与预测类别之间的关系。混淆矩阵的对角线元素表示正确预测的数量，而其他元素表示错误预测的数量。根据周志华老师的《机器学习》，混淆矩阵如下：

根据混淆矩阵，可以很方便的计算出TP,FN和FP，进而计算出IOU和MIOU。

混淆矩阵的计算，有好几种算法，我这里选了三种方法介绍一下。

第一种是网上很流行的numpy.bincount方法：

numpy.bincount是一个计算某个数组中，索引出现次数的函数。代码举例会更清楚。

import numpy as np

a = [4,5,4,1,3,5,2] 
np.bincount(a)
# 输出：array([0, 1, 1, 1, 2, 2], dtype=int64)

这里，最大值是5，所以类别是0~6之间的6类，返回6个结果，每个位置代表该位置索引出现的次数。这里索引0出现0次，索引1在a中出现1次，索引2在a中出现1次，索引3在a中出现1次，索引4在a中出现2次，索引5在a中出现2次，所以结果是[0,1,1,1,2,2]。

bincount有一个参数minlength，minlength是为了强行设定类别数，比如数组a的最大值只是到5，但是我认为类别数有8类，那么我就可以设定minlength=8，结果当然是后面几类的索引值都是0了。

np.bincount(a, minlength=8)
# 输出：array([0, 1, 1, 1, 2, 2, 0, 0], dtype=int64)

'''
得到n*n的混淆矩阵
a：真实标签label
b：预测结果pred
n:类别数
'''
def confusion_matrix(a, b, n):
    #k就是为了防止出错的
    k = (a >= 0) & (a < n) 
    return np.bincount(n * a[k].astype(int) + b[k], minlength=n**2).reshape(n, n)

这个函数中，k只是为了防止运算出错，其实如果a,b是标签值和预测的结果的话，k可以不需要。这里首先把结果扩充到n * n大小，最后再reshape到n * n,就是为了生成一个n * n的矩阵。而其中的值用n乘上a的值，再加上b的值，其实仅仅是为了计算方便而已。假设a是0，b也是0，那么a乘上n后还是0，加上b还是0，所以索引0就会存在，如果a和b不同，则会有不同的值出现，也就是混淆矩阵其他位置上的值。假设a是1,n是3，那么n * a还是3，b如果是0，那就是和就是3，b如果是1,那和就是4。

这么说可能不大好理解，我举个实际例子，假设有个a和b，类别是3类，用0，1，2表示。

a = np.array([0,1,0,2,1,0,2,2,1])
b = np.array([0,2,0,2,1,0,1,2,1])

这里有三类，0，1，2，所以n=3，minlength=9，我们可以手动计算一下这9个值，根据函数中的算法： [3 * 0 + 0, 3 * 1 + 2, 3 * 0 + 0, 3 * 2 + 2, 3 * 1 + 1, 3 * 0 + 0, 3 * 2 + 1, 3 * 2 + 2, 3 * 1 + 1] ，结果就是 [0, 5, 0, 8, 4, 0, 7, 8, 4] ，

再做一个bincount就是 [3, 0, 0, 0, 2, 1, 0, 1, 2] ，转成3 * 3的矩阵，就是 [[3,0,0] [0,2,1] [0,1,2]] 这个就是混淆矩阵。用程序验证一下。

confusion_matrix(a,b,3)
#输出：
array([[3, 0, 0],
       [0, 2, 1],
       [0, 1, 2]], dtype=int64)

和我们自己计算的结果一致。

第二种计算混淆矩阵的方法，就比较直观，统计出标签值和预测值的各种结果的总和数，就是混淆矩阵，直接上代码：

import numpy as np  
  
def confusion_matrix_np(y_true, y_pred):  
    """  
    使用NumPy计算混淆矩阵。  
  
    参数:  
    - y_true: 真实标签的数组。  
    - y_pred: 预测标签的数组。  
  
    返回:  
    - 混淆矩阵的NumPy数组。  
    """  
    # 确保y_true和y_pred是NumPy数组  
    y_true = np.asarray(y_true)  
    y_pred = np.asarray(y_pred)  
  
    # 检查y_true和y_pred的长度是否相同  
    if y_true.shape[0] != y_pred.shape[0]:  
        raise ValueError("y_true和y_pred的长度必须相同")  
  
    labels = np.unique(np.concatenate((y_true, y_pred)))  
  
    # 初始化混淆矩阵  
    n_labels = len(labels)  
    conf_mat = np.zeros((n_labels, n_labels), dtype=np.int64)  
  
    # 填充混淆矩阵  
    for i, l1 in enumerate(labels):  
        for j, l2 in enumerate(labels):  
            # 混淆矩阵每个元素的值就是该位置标签值和预测值符合条件的总数
            # 比如：conf_mat[0,0]就是真实值和预测值都是0的总数，
            # conf_mat[0,1]就是真实标签值是1，但预测值是0的元素总数
            conf_mat[i, j] = np.sum((y_true == l1) & (y_pred == l2))  
  
    return conf_mat

cm = confusion_matrix_np(a, b)  
print(cm)
# 输出
[[3 0 0]
 [0 2 1]
 [0 1 2]]

这里可以看到，结果和我们之前用bincount计算的结果一致。

第三种方法最简单，直接安装一个sklearn包，用sklearn提供的计算混淆矩阵的函数计算得到。

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(a, b)  
print(cm)
# 输出：
[[3 0 0]
 [0 2 1]
 [0 1 2]]

可以看到，结果也是一样的。

有个混淆矩阵，我们可以计算IOU了。

IOU的计算，在混淆矩阵中，就是把该类所在行的值列的值求和，然后减去对角线上的值，因为对角线上的值在求和的时候会被计算两次，所以要减去一次，然后用对角线的值去除以这个和就是IOU的值。下面是计算过程：

第一类的IOU：3 / ((3+0+0)+(3+0+0)-3) = 1

第二类的IOU：2 / ((0+2+1)+(0+2+1)-2) = 0.5

第三类的IOU：2 / ((0+1+2)+(0+1+2)-2) = 0.5

如果用程序的话，我们可以一次性计算出来，其实就是做了一个批处理，本质上和我们的计算过程是一样的：

def iou(cm):
    return np.diag(cm) / (cm.sum(0) + cm.sum(1) - np.diag(cm))
    
iou(cm)
#输出：array([1. , 0.5, 0.5])

有了各个类别的IOU，就可以很方便的求得MIOU了。

miou = np.mean(iou(cm))
miou
# 输出：0.6666666666666666