多分类混淆矩阵（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))
-
敏感性（sensitivity）也叫召回率（recall），也叫查全率。这个指标是看一下正样本中预测对的占总正样本的比例。也可以说成预测器对正样本的敏感性，越大，说明预测器对正样本越敏感。
se
n
s
i
t
i
v
i
t
y
=
t
p
t
p
+
f
n
sensitivity = \frac{tp}{tp+fn}
s
e
n
s
i
t
i
v
i
t
y
=
t
p
+
f
n
t
p
-
特异性（specificity）这个和敏感性相反，敏感性算正样本的，而特异性算的是负样本的。换句话说，它是指负样本的敏感性。毕竟你的预测器，不能仅仅是对正样本敏感，负样本，就随意了。所以需要评估一下预测器对负样本的敏感性。
sp
e
c
i
f
i
c
i
t
y
=
t
n
t
n
+
f
p
specificity = \frac{tn}{tn+fp}
s
p
e
c
i
f
i
c
i
t
y
=
t
n
+
f
p
t
n
-
查准率（precision), 这是看你预测为正样本中预测正确的占总的预测为正样本的比例。
pr
e
c
i
s
i
o
n
=
t
p
t
p
+
f
p
precision = \frac{tp}{tp+fp}
p
r
e
c
i
s
i
o
n
=
t
p
+
f
p
t
p
-
f1值，一般而言，查全率和查准率是不能同时都很大的。举个例子：你现在有100个A和100个B，你用现在训练好的模型去预测A，预测到有80个A。但是这其中75个是正确的A。也就是说查准率是
75/
80
=
0.9375
75/80=0.9375
7
5
/
8
0
=
0
.
9
3
7
5
，查全率是
75/
100
=
0.75
75/100=0.75
7
5
/
1
0
0
=
0
.
7
5
。你觉得查全率太低，你继续改进模型。又进行了一次预测，这次预测到了95个A。其中预测正确的有85个，即查全率是
85/
100
=
0.85
85/100=0.85
8
5
/
1
0
0
=
0
.
8
5
，增加了0.1，但是查准率是
85/
95
=
0.895
85/95=0.895
8
5
/
9
5
=
0
.
8
9
5
下降了。你想查得越多，就更容易产生误差。为了照顾两头，使得两个指标都有不错得值，就有了f1值。
F1
=
2
∗
p
r
e
c
i
s
i
o
n
∗
r
e
c
a
l
l
p
r
e
c
i
s
i
o
n
+
r
e
c
a
l
l
F_1= \frac{2*precision*recall}{precision+recall}
F
1
=
p
r
e
c
i
s
i
o
n
+
r
e
c
a
l
l
2
∗
p
r
e
c
i
s
i
o
n
∗
r
e
c
a
l
l
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]])