详解多分类模型的Micro-F1/Precision/Recall计算过程

我就是我 2021-11-09 23:32 1207阅读 0赞

# 引入 #

关于准确率(accuracy)、精度(precision)、查全率(recall)、F1的计算过程，之前写过一篇文章\[1\]。

根据文章\[1\]中的公式，我们可以知道，精度(precision)、查全率(recall)、F1的计算，是针对于二分类器来说的。他们的计算，只与y\_true/y\_pred有关，也要求y\_true/y\_pred中，只含有0和1两个数。

对二分类模型来说，可以直接调用`sklearn.metrics`中的`f1_score`, `precision_score`, 和`recall_score`来进行计算。但对多分类模型来说，y\_true/y\_pred中可能会有种label（比如y\_true=\[1,2,3\]），应该如何计算其F1/P/R值呢？

之前写过Macro准则，可以解决多分类问题中的F1计算问题。出了Macro外，还有其他的方法吗？

# Micro #

传统的F1计算公式\[1\]，只适用于二分类模型。对多分类模型来说，要用Micro规则来进行F1（或者P、R）的计算。

举例来说，假设是三个类别的分类模型:

y_true=[1,2,3]
    y_pred=[1,1,3]

根据P/R的计算规则\[1\]，

*  Precision = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP/(TP+FP)
 *  Recall = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)
 *  F1 = 2\*(Precision\*Recall)/(Precision+Recall)

下面计算过程中，若除法过程中，分子分母同时为零，则最终结果也为0.

则Micro F1的计算过程如下：

（1）如下，将第1个类别设置为True（1），非第1个类别的设置为False（0），计算其P1,R1

y_true=[1,0,0]
    y_pred=[1,1,0]

*  P1 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP1/(TP1+FP1) = 1/(1+1)=0.5
 *  R1 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP1/(TP1+FN1)= 1/1 = 1.0
 *  F1\_1 = 2\*(Precision*Recall)/(Precision+Recall)=2*0.5\*1.0/(0.5+1.0)=0.6666667

（2）如下，将第2个类别设置为True（1），非第2个类别的设置为False（0），计算其P2,R2

y_true=[0,1,0]
    y_pred=[0,0,0]

*  P2 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP2/(TP2+FP2) =0.0
 *  R2 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP2/(TP2+FN2)= 0.0/1=0.0
 *  F1\_2 = 2\*(Precision\*Recall)/(Precision+Recall)=0

（3）如下，将第3个类别设置为True（1），非第3个类别的设置为False（0），计算其P3,R3

y_true=[0,0,1]
    y_pred=[0,0,1]

*  P3 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP3/(TP3+FP3) = 1/1=1.0
 *  R3 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP3/(TP3+FN3)= 1/1 = 1.0
 *  F1\_3 = 2\*(Precision*Recall)/(Precision+Recall)=2*1.0\*1.0/(1.0+1.0)=1.0

（4）micro规则计算P/R/F1的公式如下

*  P=(TP1+TP2+TP3)/(TP1+FP1+TP2+FP2+TP3+FP3)=(1+0+1)/(1+1+0+0+1+0)=0.6666667
 *  R=(TP1+TP2+TP3)/(TP1+FN1+TP2+FN2+TP3+FN3)=(1+0+1)/(1+0+0+1+1+0)=0.6666667
 *  F1 = 2\*(0.6666667\*0.6666667)/(0.6666667+0.6666667)=0.6666667

最后这个取平均后的得到的P值/R值，就是Micro规则下的P值/R值。

对这个3类别模型来说，它的F1就是0.6666667。

# sklearn计算程序（micro） #

下面是使用sklearn直接计算多类别F1/P/R的程序，将接口中的average参数配置为’micro’即可。

from sklearn.metrics import f1_score, precision_score, recall_score
    
    y_true=[1,2,3]
    y_pred=[1,1,3]
    
    f1 = f1_score( y_true, y_pred, average='micro' )
    p = precision_score(y_true, y_pred, average='micro')
    r = recall_score(y_true, y_pred, average='micro')
    
    print(f1, p, r)
    # output: 0.666666666667 0.666666666667 0.666666666667

可见，输出的P/R/F1值，都和上面我们手动计算的结果一致。

# sklearn中macro-F1源码静态分析 #

（1）找到第三方库所在的位置  
先利用如下Python代码找到sklearn源码位置。我的位置在`/root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn`

import sklearn, os
    path = os.path.dirname(sklearn.__file__)

（2）找到要调试的源码位置

我们调试源码的目的，就是想看看`f1_score()`计算的过程，所以应该调试`f1_score`的源码。

问题是怎么找到`f1_score()`的源码呢？

sklearn的api文档（[https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1\_score.html\#sklearn.metrics.f1\_score）中，都在“\[source\]”中给出了源码链接。][https_scikit-learn.org_stable_modules_generated_sklearn.metrics.f1_score.html_sklearn.metrics.f1_score_source]

通过这个“\[source\]”的链接（[https://github.com/scikit-learn/scikit-learn/blob/b7b4d3e2f/sklearn/metrics/classification.py\#L950），可以发现，我们要调试的源码，位于][https_github.com_scikit-learn_scikit-learn_blob_b7b4d3e2f_sklearn_metrics_classification.py_L950]`sklearn/metrics/classification.py`。

（3）分析`classification.py`中的F1计算函数[f1\_score()][f1_score]

主要是调用了计算F值的函数`fbeta_score()`，并将beta设置为1，就是计算F1值。`fbeta_score()`中最重要的函数是`[precision_recall_fscore_support()](https://github.com/scikit-learn/scikit-learn/blob/b7b4d3e2f1a65bcb6d40431d3b61ed1d563c9dab/sklearn/metrics/classification.py#L1263)`，该函数的核心逻辑如下：

#参数解释：
    #y_true：真实值
    #y_pred：预测值
    #beta=1.0：默认计算F1值
    #其他参数这里用不到
    def precision_recall_fscore_support(y_true, y_pred, beta=1.0, labels=None,
                                        pos_label=1, average=None,
                                        warn_for=('precision', 'recall',
                                                  'f-score'),
                                        sample_weight=None):
        # F值得beta必须大于0
        if beta <= 0:
            raise ValueError("beta should be >0 in the F-beta score")
        
        # 计算混淆矩阵
        MCM = multilabel_confusion_matrix(y_true, y_pred,
                                          sample_weight=sample_weight,
                                          labels=labels, samplewise=samplewise)
        tp_sum = MCM[:, 1, 1]
        pred_sum = tp_sum + MCM[:, 0, 1]
        true_sum = tp_sum + MCM[:, 1, 0]
        
        # 若为micro准则，则将各个类别的TP等值累加后进行计算
        # 若为micro，tp_sum/pred_sum/true_sum，最终就由一个list（各个类别自己的值）变为一个值
        if average == 'micro':
            tp_sum = np.array([tp_sum.sum()])
            pred_sum = np.array([pred_sum.sum()])
            true_sum = np.array([true_sum.sum()])
    
        beta2 = beta ** 2# 这里beta=1,则beta2也等于1，就是计算F1
    
        # 计算precision和recall
        precision = _prf_divide(tp_sum, pred_sum,
                                'precision', 'predicted', average, warn_for)
        recall = _prf_divide(tp_sum, true_sum,
                             'recall', 'true', average, warn_for)
    
        # 计算f_score, 
        denom = beta2 * precision + recall
        denom[denom == 0.] = 1  # avoid division by 0
        f_score = (1 + beta2) * precision * recall / denom
    
        # 如果考虑weight，则需要设置weights变量（后面函数中会用到）
        if average == 'weighted':
            weights = true_sum
            if weights.sum() == 0:
                return 0, 0, 0, None
        elif average == 'samples':
            weights = sample_weight
        else:
            weights = None
    
        # macro/micro都会运行到这里
        if average is not None:
            assert average != 'binary' or len(precision) == 1
            # 把各个类别的precision取平均，作为多类别的precision
            precision = np.average(precision, weights=weights)
            # 把各个类别的recall取平均，作为多类别的recall
            recall = np.average(recall, weights=weights)
            # 把各个类别的f_score取平均，作为多类别的f_score
            f_score = np.average(f_score, weights=weights)
            true_sum = None  # return no support
    
        return precision, recall, f_score, true_sum

因为有`if average == 'micro'`中的逻辑，会将各个类别计算得到的tp\_sum/pred\_sum/true\_sum这样一个多个值的list，转换为单个值的list。

所以，后续计算`precision`和`recall`时，若为’micro’，则`precision`和`recall`是单个值（正好是上面讲到的对P/R值计算取sum的过程）。

否则（`macro`时），`precision`和`recall`也是各个类别计算得到的多个值的list。

# 总结 #

注意区别Macro与Micro规则。

# 参考 #

*  \[1\] 理解准确率(accuracy)、精度(precision)、查全率(recall)、F1. [https://blog.csdn.net/ybdesire/article/details/53613628][https_blog.csdn.net_ybdesire_article_details_53613628]
 *  \[2\] 如何动态调试Python的第三方库. [https://blog.csdn.net/ybdesire/article/details/54649211][https_blog.csdn.net_ybdesire_article_details_54649211]

[https_scikit-learn.org_stable_modules_generated_sklearn.metrics.f1_score.html_sklearn.metrics.f1_score_source]: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score%EF%BC%89%E4%B8%AD%EF%BC%8C%E9%83%BD%E5%9C%A8%E2%80%9C%5Bsource%5D%E2%80%9D%E4%B8%AD%E7%BB%99%E5%87%BA%E4%BA%86%E6%BA%90%E7%A0%81%E9%93%BE%E6%8E%A5%E3%80%82
[https_github.com_scikit-learn_scikit-learn_blob_b7b4d3e2f_sklearn_metrics_classification.py_L950]: https://github.com/scikit-learn/scikit-learn/blob/b7b4d3e2f/sklearn/metrics/classification.py#L950%EF%BC%89%EF%BC%8C%E5%8F%AF%E4%BB%A5%E5%8F%91%E7%8E%B0%EF%BC%8C%E6%88%91%E4%BB%AC%E8%A6%81%E8%B0%83%E8%AF%95%E7%9A%84%E6%BA%90%E7%A0%81%EF%BC%8C%E4%BD%8D%E4%BA%8E
[f1_score]: https://github.com/scikit-learn/scikit-learn/blob/b7b4d3e2f1a65bcb6d40431d3b61ed1d563c9dab/sklearn/metrics/classification.py#L950
[https_blog.csdn.net_ybdesire_article_details_53613628]: https://blog.csdn.net/ybdesire/article/details/53613628
[https_blog.csdn.net_ybdesire_article_details_54649211]: https://blog.csdn.net/ybdesire/article/details/54649211