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

素颜马尾好姑娘i 2021-12-03 05:29 2158阅读 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 Average #

在google上搜索，可以看到如下描述

The F1 measure is widely used to evaluate the success of a binary classifier when one class is rare. Micro average, macro average, and per instance average F1 measures are used in multilabel classification.

可见，传统的F1计算公式\[1\]，只适用于二分类模型。对多分类模型来说，要用Macro Average规则来进行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.

则Macro Average F1的计算过程如下：

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

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

*  P1 = (预测为1且正确预测的样本数)/(所有预测为1的样本数) = TP/(TP+FP) = 1/(1+1)=0.5
 *  R1 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)= 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的样本数) = TP/(TP+FP) =0.0
 *  R2 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)= 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的样本数) = TP/(TP+FP) = 1/1=1.0
 *  R3 = (预测为1且正确预测的样本数)/(所有真实情况为1的样本数) = TP/(TP+FN)= 1/1 = 1.0
 *  F1\_3 = 2\*(Precision*Recall)/(Precision+Recall)=2*1.0\*1.0/(1.0+1.0)=1.0

（4）对P1/P2/P3取平均为P，对R1/R2/R3取平均为R，对F1\_1/F1\_2/F1\_3取平均F1

*  P=(P1+P2+P3)/3=(0.5+0.0+1.0)/3=0.5
 *  R=(R1+R2+R3)/3=(1.0+0.0+1.0)/3=0.6666666
 *  F1 = (0.6666667+0.0+1.0)/3=0.5556

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

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

# sklearn计算程序（macro） #

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

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='macro' )
    p = precision_score(y_true, y_pred, average='macro')
    r = recall_score(y_true, y_pred, average='macro')
    
    print(f1, p, r)
    # output: 0.555555555556 0.5 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`是单个值。否则（`macro`时），`precision`和`recall`也是各个类别计算得到的多个值的list。

# 动态分析 #

（1）通过上面的步骤，“找到要调试的源码位置”

我的位置在`/root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py`

（2）删掉Python预编译的字节码

到如下目录，删掉`__pycache__`目录。

/root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/

（3）在第三方库源码中加断点

`f1_score()`的关键计算过程，在源码`precision_recall_fscore_support()`函数中的如下位置。在其中用pdb加入断点，如下所示：

import pdb;pdb.set_trace()
    
    beta2 = beta ** 2
    
    # Divide, and on zero-division, set scores to 0 and warn:
    
    precision = _prf_divide(tp_sum, pred_sum,
                            'precision', 'predicted', average, warn_for)
    recall = _prf_divide(tp_sum, true_sum,
                         'recall', 'true', average, warn_for)
    # Don't need to warn for F: either P or R warned, or tp == 0 where pos
    # and true are nonzero, in which case, F is well-defined and zero
    denom = beta2 * precision + recall
    denom[denom == 0.] = 1  # avoid division by 0
    f_score = (1 + beta2) * precision * recall / denom
    if average is not None:
        assert average != 'binary' or len(precision) == 1
        precision = np.average(precision, weights=weights)
        recall = np.average(recall, weights=weights)
        f_score = np.average(f_score, weights=weights)
        true_sum = None  # return no support

静态看这个代码，也能基本理解其含义。我们下面参考\[2\]中的过程，来动态调试程序，看看各个变量动态过程中实际的数值。

运行上文中的“sklearn计算程序（macro）”，单步调试，过程如下

(Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1107)precision_recall_fscore_support()
    -> with np.errstate(divide='ignore', invalid='ignore'):
    (Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1112)precision_recall_fscore_support()
    -> precision = _prf_divide(tp_sum, pred_sum,
    (Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1113)precision_recall_fscore_support()
    -> 'precision', 'predicted', average, warn_for)
    (Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1114)precision_recall_fscore_support()
    -> recall = _prf_divide(tp_sum, true_sum,
    (Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1115)precision_recall_fscore_support()
    -> 'recall', 'true', average, warn_for)
    (Pdb) precision
    array([ 0.5,  0. ,  1. ])
    (Pdb) recall
    *** NameError: name 'recall' is not defined
    (Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1118)precision_recall_fscore_support()
    -> f_score = ((1 + beta2) * precision * recall /
    (Pdb) recall
    array([ 1.,  0.,  1.])

可见，sklearn源码计算得到的recall与precision是和我们手工计算一致的。继续单步，如下

(Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1128)precision_recall_fscore_support()
    -> elif average == 'samples':
    (Pdb) f_score
    array([ 0.66666667,  0.        ,  1.        ])

可见，f\_score的值就是这个数组，和我们上面手动计算的数值一样。继续单步执行程序，如下所示

(Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1137)precision_recall_fscore_support()
    -> f_score = np.average(f_score, weights=weights)
    (Pdb) f_score
    array([ 0.66666667,  0.        ,  1.        ])
    (Pdb) n
    > /root/anaconda3/envs/envtf/lib/python3.5/site-packages/sklearn/metrics/classification.py(1138)precision_recall_fscore_support()
    -> true_sum = None  # return no support
    (Pdb) f_score
    0.55555555555555547

可见，最终f\_score的值的计算，是由`f_score = np.average(f_score, weights=weights)`计算得到的，在这里就是把上面的f\_score数组取均值。

sklearn的整个计算过程，与我们手工计算完全一样。

注意，调试完成后，删除对源码的改动，即去掉`import pdb;pdb.set_trace()`。

# 总结 #

Macro Average 多类别（N类） F1/P/R的计算，就是计算N次F1/P/R，再分别取平均。

# 参考 #

*  \[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