语义分割中的评价指标问题

最新推荐文章于 2024-05-16 16:04:53 发布

别致的人

最新推荐文章于 2024-05-16 16:04:53 发布

阅读量2.9k

点赞数 2

分类专栏：语义分割 pytorch 文章标签：分类机器学习深度学习

本文链接：https://blog.csdn.net/qnlailai/article/details/121931071

版权

语义分割同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

pytorch

1 篇文章 0 订阅

订阅专栏

语义分割中的评价指标问题

1.二分类与多分类TP,TN,FP,FN
2.多分类混淆矩阵介绍与代码
- 2.1通过sklean库实现
- 2.2 通过numpy实现
3.F1-score介绍与代码
- 3.1通过sklean库实现F1-score
- 3.2 numpy来实现F1-score
4.多分类的MIoU和IoU介绍与代码
- 代码实现：

语义分割归根结底就是像素级别的二分类/多分类问题。在测试评价的时候用到各种评价指标，网上很多人的总结要么太凌乱，甚至还有错误，总结一下各种常用的评价指标，以备使用时查阅，如有错误欢迎指出。

1.二分类与多分类TP,TN,FP,FN

1).二分类

TP：标签值为正样本，预测值也为正样本
TN：标签值为负样本，预测值也为负样本
FP：标签值为负样本，预测值为正样本
FN：标签值为正样本，预测值为负样本
所以要注意的是：标签值中的
P=TP+FN, N =TN+FN

图片引用于二分类

2). 多分类
多分类问题中的TP\TN\FP\TN这些指标要具体和某一类挂钩。举个例子，如果有一个多分类(类别为5)，下面是求类别为4的各项参数：

TP：标签值类别为4，预测值类别也为4
TN：标签值与预测值保持一致，值为1、2、3、5中的任何一个
FP：标签值类别为4，预测值类别为1、2、3、5中的任何一个
FN：标签值类别为1、2、3、5，预测值类别为4
以上就是关于类别4的TP、TN、FP、FN解释。下面是多分类的混淆矩阵。混淆矩阵求法可以看第二部分。

图片引用于多分类

2.多分类混淆矩阵介绍与代码

在第一部分介绍了多分类和二分类的基础指标问题。这部分介绍混淆矩阵。混淆矩阵的定义：

混淆矩阵是机器学习中总结分类模型预测结果的情形分析表，以矩阵形式将数据集中的记录按照真实的类别与分类模型预测的类别判断两个标准进行汇总。一般来说矩阵的行表示真实值，矩阵的列表示预测值。

混淆矩阵代码实现有多种方式，本文介绍两种。

2.1通过sklean库实现

官方文档here

语法实现：

from sklearn.metrics import confusion_matrix

confusion_matrix参数：
y_true ：一维数组。维度shape = [n_samples]
y_pred：一维数组。维度shape = [n_samples]
labels：array类型, 维度shape = [n_classes]（这个的作用笔者实验了下，就是等于求某类的TP）
sample_weight：样本权重(一般用不上)
根据以上所述，confusion_matrix函数接受单通道的预测值和单通道的标签值。所以一般经过argmax操作再flatten之后传入。

消融比较：

1.预测值或标签值包含全部的类别
>>> from sklearn.metrics import confusion_matrix
>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> confusion_matrix(y_true, y_pred)
array([[2, 0, 0],
       [0, 0, 1],
       [1, 0, 2]], dtype=int64)
       
2.预测值和标签值不包含全部的类别
>>> y_true = [3, 0, 3, 3, 0, 1]
>>> y_pred = [0, 0, 3, 3, 0, 3]
>>> confusion_matrix(y_true, y_pred)
array([[2, 0, 0],
       [0, 0, 1],
       [1, 0, 2]], dtype=int64)

综上消融所述：
基于sklearn库求的混淆矩阵，只包含传入类别的，不按照实际标签值，容易忽略，不适合求多张图片混淆矩阵叠加。

2.2 通过numpy实现

实现语法：

>>>def Hist(y_true,y_pred,numclass):
>>>    hist=np.bincount(numclass * y_true.astype(int)+y_pred,minlength=numclass ** 2).reshape(numclass, numclass)
>>>    return hist

如果一个图片有n类，直接建立一个n*n混淆矩阵。

消融比较：

1.
>>>y_true = np.array([2, 0, 2, 2, 0, 1])
>>>y_pred = np.array([0, 0, 2, 2, 0, 2])
>>>numclass = 4
>>>Hist(y_true,y_pred,numclass)
array([[2, 0, 0, 0],
       [0, 0, 1, 0],
       [1, 0, 2, 0],
       [0, 0, 0, 0]], dtype=int64)
2.
>>>y_true = np.array([3, 0, 3, 3, 0, 1])
>>>y_pred = np.array([0, 0, 3, 3, 0, 3])
>>>numclass = 4
>>>Hist(y_true,y_pred,numclass)
array([[2, 0, 0, 0],
       [0, 0, 0, 1],
       [0, 0, 0, 0],
       [1, 0, 0, 2]], dtype=int64)

综上所述：自己编写的代码是建立完整的混淆矩阵，而不是根据传入的类的种类数目来建立。

3.F1-score介绍与代码

F1-score的定义如下：

F1分数（F1 Score）:是统计学中用来衡量二分类模型精确度的一种指标。它同时兼顾了分类模型的精确率和召回率。 F1分数可以看作是模型精确率和召回率的一种调和平均，它的最大值是1，最小值是0。分数（ Score），又称平衡F分数（balanced F Score），它被定义为精确率和召回率的调和平均数。

准确率( P )：
在这里插入图片描述
召回率( R ) ：

F1-score :

经过化简：

3.1通过sklean库实现F1-score

实现语法：

sklearn.metrics.f1_score(y_true, 
                 y_pred,
                 labels=None, 
                 pos_label=1, 
                 average=’binary’, 
                 sample_weight=None)

f1_score参数：
y_true ：一维数组。维度shape = [n_samples]
y_pred：一维数组。维度shape = [n_samples]
average：string, [None, ‘binary’ (default), ‘micro’, ‘macro’, ‘weighted’, ‘samples’]，有这六个中取值，意义如下

None:返回每一类各自的f1_score，得到一个array.
== ‘binary’==:只对二分类问题有效，返回由pos_label指定的类的f1_score。
‘micro’:设置average='micro’时，Precision = Recall = F1_score = Accuracy。整体计算TP,FN，FP
== ‘macro’==:对每一类别的f1_score进行简单算术平均（unweighted mean）,这类有一个前提假设：每一个类都同等的重要。
== ‘weighted’==:对每一类别的f1_score进行加权平均，权重为各类别数在y_true中所占比例。
‘samples’:用于多标签任务，按照样本维度计算混淆矩阵，然后计算平均值。（笔者实验后发现这个必须有规定形式，标签值和预测值必须是独热编码）

sample_weight：(一般用不上)

消融对比：
举个例子：
标签值：[0, 0, 0, 0, 1, 1, 1, 2, 2]
预测值：[0, 0, 1, 2, 1, 1, 2, 1, 2]
可以得出这个混淆矩阵为：
2 1 1
0 2 1
0 1 1
也可以的出来：
0类：TP=2,FP=0,FN=2
1类：TP=2,FP=2,FN=1
2类：TP=1,FP=2,FN=1 怎么求我就不过多赘述了

0类别的准确率： PA = 2/(2+0）= 1
0类别的召回率： RA = 2/(2+2）= 0.5
0类别的F1-score ： FA = 2*(1*0.5)/(1+0.5) = 0.667

1类别的准确率： PB = 2/(2+2）= 0.5
1类别的召回率： RB = 2/(2+1）= 0.667
1类别的F1-score ： FB = 2*(0.5*0.667)/(0.5+0.667) = 0.572

2类别的准确率： PC = 1/(1+2）= 0.333
2类别的召回率： RC = 1/(1+1）= 0.5
2类别的F1-score ： FC = 2*(0.333*0.5）/（0.333+0.5） = 0.39976

所有数据的F1-score:
有两种方式
第一种方式是计算数据中所有的TP,FP,FN,然后计算F1-score,即micro；
第二种方式是分别计算各个类别的TP，FP，FN，然后计算各个类被的F1-score,然后对F-score求平均，即macro.

micro:
P = 5/(5+4) = 0.556
R = 5/(5+4) = 0.556
F1-score = 2*(0.556*0.556)/(0.556+0.556) = 0.556

macro :
F1-score = (0.667+0.572+0.39976)/3 = 0.5462

代码实现：
>>>from sklearn.metrics import f1_score
 
>>>y_true = [0, 0, 0, 0, 1, 1, 1, 2, 2]
>>>y_pred = [0, 0, 1, 2, 1, 1, 2, 1, 2]
 
>>>f1_micro = f1_score(y_true,y_pred,average='micro')
0.5555555555555556
>>>f1_macro = f1_score(y_true,y_pred,average='macro')
0.546031746031746
>>>f1_None = f1_score(y_true,y_pred,average=None)
array([0.66666667, 0.57142857, 0.4       ]) 

>>>z1= np.eye(3)[np.array(y_true ).reshape(-1)] # 独热编码
>>>z2=np.eye(3)[np.array(y_pred ).reshape(-1)] # 独热编码
>>>f1_score=(z1,z2,average="samples")  #这个测试处于micro与macro之间，笔者不建议使用
0.5555555555555556

3.2 numpy来实现F1-score

不太建议，比较复杂，而且会让值虚高，训练可以尝试使用，测试还是建议使用sklearn库自带的。这个是直接通过求TP,FP,FN,TN来进行测试。但是为了避免出现NaN数值，这里面求F1分数的时候通过分子分母同加一个极小值。但是！这样会造成一个小后果：假设在k类，预测和标签都没有的情况下，关于k类的F1就会变成1。然后这个最后求平均F1score就会导致值虚高。

def f_score(inputs, target, beta=1, smooth = 1e-5, threhold = 0.5):
    n, c, h, w = inputs.size()
    nt, ht, wt, ct = target.size()
    
    if h != ht and w != wt:
        inputs = F.interpolate(inputs, size=(ht, wt), mode="bilinear", align_corners=True)
    temp_inputs = torch.softmax(inputs.transpose(1, 2).transpose(2, 3).contiguous().view(n, -1, c),-1)
    temp_target = target.view(n, -1, ct)

    #--------------------------------------------#
    #   计算dice系数
    #--------------------------------------------#
    temp_inputs = torch.gt(temp_inputs,threhold).float()
    tp = torch.sum(temp_target * temp_inputs, axis=[0,1])
    fp = torch.sum(temp_inputs                       , axis=[0,1]) - tp
    fn = torch.sum(temp_target              , axis=[0,1]) - tp


    score = ((1 + beta ** 2) * tp + smooth) / ((1 + beta ** 2) * tp + beta ** 2 * fn + fp + smooth)
    score = torch.mean(score)
    return score

4.多分类的MIoU和IoU介绍与代码

Mean Intersection over Union（MIoU，均交并比）为语义分割的标准度量。其计算两个集合的交集和并集之比，在语义分割问题中，这两个集合为真实值（ground truth）和预测值（predicted segmentation）。
IoU(Intersection over Union)IoU 计算的是 “预测的边框” 和 “真实的边框” 的交集和并集的比值.

IoU是求得单个类，而MIoU求得是所有类平均。

公式如下：
在这里插入图片描述
在多分类情况下，B是代表除了A之外得所有类。

简化成TP、TF、FN、FP公式：

代码实现：

1.通过混淆矩阵来求每类得IOU，这个函数传入一个n*n的混淆矩阵，返回一个[n]数组(反映每一类的Iou)
如果想再求MIoU，直接进行 np.nanmean(hist) 就可以了。
# 为什么不用np.mean（）？ 因为一张图中有些类标签值没有，预测值没有，就会出现0/0=Nan情况
>>>def per_class_iu(hist):
>>>    return np.diag(hist) / np.maximum((hist.sum(1) + hist.sum(0) - np.diag(hist)), 1)
    # hist.sum(0) 是压缩成一行  求的是什么呢  TP+FN    TP：标签为1 预测为1的个数   FN 标签为1  预测为其他的 就是FN
    # hist.sum(1) 是压缩成一列  求的是什么呢  TP+FP   TP：标签为1 预测为1的个数   FN 标签为其他  预测为1的 就是FP