多分类混淆矩阵（sklearn.metrics）

多分类混淆矩阵（sklearn.metrics）

sklearn.metrics.multilabel_confusion_matrix(y_true, y_pred, *, sample_weight=None, labels=None, samplewise=False)

Examples
Multilabel-indicator case:

>>> import numpy as np
>>> from sklearn.metrics import multilabel_confusion_matrix
>>> y_true = np.array([[1, 0, 1],
...                    [0, 1, 0]])
>>> y_pred = np.array([[1, 0, 0],
...                    [0, 1, 1]])
>>> multilabel_confusion_matrix(y_true, y_pred)
array([[[1, 0],
        [0, 1]],

       [[1, 0],
        [0, 1]],

       [[0, 1],
        [1, 0]]])

>>> y_true = ["cat", "ant", "cat", "cat", "ant", "bird"]
>>> y_pred = ["ant", "ant", "cat", "cat", "ant", "cat"]
>>> mcm = multilabel_confusion_matrix(y_true, y_pred,
...                             labels=["ant", "bird", "cat"])
>>> mcm
array([[[3, 1],
        [0, 2]],

       [[5, 0],
        [1, 0]],

       [[2, 1],
        [1, 2]]])

评估指标

TP(True Positive)：将正类预测为正类，真实为 ‘0’，预测也为 ‘0’
FN(False Negative)：将正类预测为负类，真实为 ‘0’，预测为 ‘1’
FP(False Positive)：将负类预测为正类， 真实为 ‘1’，预测为 ‘0’
TN(True Negative)：将负类预测为负类，真实为 ‘1’，预测也为 ‘1’

>>> tn = mcm[:, 0, 0]
>>> fp = mcm[:, 0, 1]
>>> fn = mcm[:, 1, 0]
>>> tp = mcm[:, 1, 1]
>>> tp
(array([2, 0, 2], dtype=int64))
>>> tn
(array([3, 5, 2], dtype=int64))

1. 敏感性（sensitivity）也叫召回率（recall），也叫查全率。这个指标是看一下正样本中预测对的占总正样本的比例。也可以说成预测器对正样本的敏感性，越大，说明预测器对正样本越敏感。
   $$sensitivity=\frac{tp}{tp+fn}$$

2. 特异性（specificity）这个和敏感性相反，敏感性算正样本的，而特异性算的是负样本的。换句话说，它是指负样本的敏感性。毕竟你的预测器，不能仅仅是对正样本敏感，负样本，就随意了。所以需要评估一下预测器对负样本的敏感性。
   $$specificity=\frac{tn}{tn+fp}$$

3. 查准率（precision), 这是看你预测为正样本中预测正确的占总的预测为正样本的比例。
   $$precision=\frac{tp}{tp+fp}$$

4. f1值，一般而言，查全率和查准率是不能同时都很大的。举个例子：你现在有100个A和100个B，你用现在训练好的模型去预测A，预测到有80个A。但是这其中75个是正确的A。也就是说查准率是$75/80=0.9375$，查全率是$75/100=0.75$。你觉得查全率太低，你继续改进模型。又进行了一次预测，这次预测到了95个A。其中预测正确的有85个，即查全率是$85/100=0.85$，增加了0.1，但是查准率是$85/95=0.895$下降了。你想查得越多，就更容易产生误差。为了照顾两头，使得两个指标都有不错得值，就有了f1值。
   $$F_1=\frac{2\ast precision\ast recall}{precision+recall}$$

Examples

TN: true=1, pred=1
FP: true=1, pred=0
FN: true=0, pred=1
TP: true=0, pred=0

>>> y_true = [1, 0, 1, 1, 0, 2]
>>> y_pred = [0, 0, 1, 1, 0, 1]
### 对于"0"这一类而言，计算混淆矩阵
# y_true = [1, 0, 1, 1, 0, 1]
# y_pred = [0, 0, 1, 1, 0, 1]
# TN=3, FP=1, FN=0, TP=2
array([[3, 1],
       [0, 2]])
        
### 对于"1"这一类而言，计算混淆矩阵
# y_true = [0, 1, 0, 0, 1, 1]
# y_pred = [1, 1, 0, 0, 1, 0]
# TN=3, FP=1, FN=0, TP=2
array([[2, 1],
       [1, 2]])

### 对于"2"这一类而言，计算混淆矩阵
# y_true = [1, 1, 1, 1, 1, 0]
# y_pred = [1, 1, 1, 1, 1, 1]
# TN=3, FP=1, FN=0, TP=2
array([[5, 0],
       [1, 0]])