平时训练模型,会写一些评估函数,简单的评估函数如准确率等很容易实现,当使用AUC、NDCG等指标时,调用sklearn.metrics不仅准确可靠,而且速度飞快。
sklearn有三种不同的度量:
model_selection.cross_val_score
和model_selection.GridSearchCV
)依赖于内部评分策略。sklearn.metrics
模块实现了为特定目的评估预测误差的功能。这些指标在分类指标(Classification metrics)、多标签排名指标(Multilabel ranking metrics)、回归指标(Regression metrics)和聚类指标(Clustering metrics)部分中有详细说明。本节主要就是介绍Metric functions。
参考资料:
sklearn.metrics官方文档
sklearn.metrics一个package,包含评分函数(score functions)、性能指标(性能指标)、pairwise metrics和距离计算(distance computations)。
上图就是混淆矩阵(Confusion Matrix)。
confusion_matrix(y_true, y_pred)
y_true = [0, 0, 0, 1, 1, 1, 1, 1]
y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
print(confusion_matrix(y_true, y_pred))
"""
输出:
[[2 1]
[2 3]]
"""
# 求混淆矩阵各个元素的值
tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
参考:
precision简称为 P \text{P} P,分为 macro-P \text{macro-P} macro-P、 micro-P \text{micro-P} micro-P、 weighted-P \text{weighted-P} weighted-P
西瓜书上说的就是二分类,其:
查准率(Precision): P = T P T P + F P P={\frac {TP} {TP+FP}} P=TP+FPTP,挑出的西瓜中,有多少比例是好瓜。
查全率(Recall): R = T P T P + F N R={\frac {TP} {TP+FN}} R=TP+FNTP,所有好瓜中,有多少比例被挑出来。
F1: F 1 = 2 × P × R P + R = 2 × T P 样 本 总 数 + T P − T N F1={\frac {2\times P\times R} {P+R}}={\frac {2\times TP} {样本总数+TP-TN}} F1=P+R2×P×R=样本总数+TP−TN2×TP,P和R的调和平均数。
from sklearn.metrics import precision_score, recall_score,f1_score
y_true = [0, 0, 1, 1, 1, 1]
y_pred = [0, 1, 0, 1, 0, 1]
precision_score(y_true, y_pred)
"""
输出:0.6666666666666666
TP=2, FP=1
根据公式可得P=2/(2+1)=2/3
"""
recall_score(y_true, y_pred) # 同理
f1_score(y_true, y_pred) # 同理
本节解释:average_precision_score
sklearn官方文档:sklearn.metrics.average_precision_score
wiki百科:Average precision
在wiki百科中,平均查准率(average precision, AP)的定义为P-R曲线下的面积:
AP
=
∫
0
1
p
(
r
)
d
r
\text{AP}=\int_{0}^{1}p(r)dr
AP=∫01p(r)dr,其中
p
(
r
)
p(r)
p(r) 是召回率
r
r
r 的函数。
实践中,上面的积分会被文档排序序列中每个位置的有限和所取代:
AP
=
∑
n
(
R
n
−
R
n
−
1
)
P
n
\text{AP} = \sum_n (R_n - R_{n-1}) P_n
AP=n∑(Rn−Rn−1)Pn
根据定义可以知道,AP的积分公式就是sklearn.metrics.auc
的原理,AP的有限梯度和APIaverage_precision_score
就是积分的逼近公式,其验证代码见“相关结论”一节的讨论。
准确度分类得分。为样本预测的标签集必须与y_true中的相应标签集完全匹配。也可以给样本加权,详见sklearn.metrics.accuracy_score文档
accuracy_score(y_true, y_pred)
y_pred = [0, 2, 1, 3]
y_true = [0, 1, 2, 3]
accuracy_score(y_true, y_pred)
"""
输出:
0.5
"""
使用梯形法则(trapezoidal rule)求曲线下的面积“Area Under the Curve (AUC) ”。这是一个通用的求曲线下面积的函数,只需要给定曲线上的点。要计算ROC曲线下的面积,使用roc_auc_score
。
简单来说,这就是一个根据梯形法则逼近曲线在区间内的积分,比如我们计算
y
=
x
2
y=x^2
y=x2 在区间
[
0
,
2
]
[0,2]
[0,2] 内的面积,通过牛顿-莱布尼茨公式可以计算出其面积为
8
3
{\frac 8 3}
38,我们只需要给定
y
=
x
2
y=x^2
y=x2 曲线在
[
0
,
1
]
[0,1]
[0,1] 上的点,就可以用梯形法则逼近其区间内的面积,见如下图片及代码部分(图片来源于南安普顿大学)。
sklearn.metrics.auc(x, y)
x:x坐标,要么是单调递增,要么是单调递减。
y:y坐标。
import numpy as np
from sklearn import metrics
# n越大,结果越精确
n = 10000000
x = np.linspace(0,2,n)
y = x**2
metrics.auc(x, y)
"""
输出:
2.6666666666666803
"""
DCG(Discounted Cumulative Gain)和nDCG(Normalized DCG)的原理类似,都是按照预测得分的顺序对真实相关性进行排序,并应用相应的discount(如除以 l o g 2 ( i + 1 ) log_2(i+1) log2(i+1)),然后加和。
sklearn.metrics.ndcg_score(y_true, y_score, k)
y_true:排名items的真实得分。(在搜索中,可以理解为items与query的相关性。)
y_scores:模型给出的items的得分。
k: 只考虑排名最高的k个items的dcg。
注意:y_scores的作用仅仅是为了对y_true进行排序,最终计算的事y_true在y_scores给出的排序下的dcg。
原理参见:我的博文nDCG笔记及在spark中的实现
打印分类相关的指标,包括 precision、recall、f1-score及相应的accuracy,macro avg和weighted avg。
from sklearn.metrics import classification_report
y_true = [1,2,3,1,2,3,1,2,3]
y_pred = [1,2,3,2,1,1,2,1,3]
print(classification_report(y_true, y_pred, target_names=["类别1","类别2","类别3"]))
"""
输出:
precision recall f1-score support
类别1 0.25 0.33 0.29 3
类别2 0.33 0.33 0.33 3
类别3 1.00 0.67 0.80 3
accuracy 0.44 9
macro avg 0.53 0.44 0.47 9
weighted avg 0.53 0.44 0.47 9
"""
通过前文的分析可知,average_precision_score是对PR曲线的梯形法则的有限逼近,auc是直接求PR曲线下的积分(或者说是无限逼近),我们分别设置不同的梯形个数来逼近PR曲线下的面积,结果如下:
梯形个数 | average_precision_score与auc的误差 |
---|---|
10 | 10% |
100 | 1.8% |
1000 | 0.26% |
10000 | 0.04% |
代码如下:
from tqdm import tqdm
import numpy as np
from sklearn.metrics import average_precision_score, precision_recall_curve, auc
def func(k):
"""
k 梯形个数
"""
L = []
for i in tqdm(range(200)):
y_true = np.random.randint(0,2,k)
y_pred = np.abs(np.random.randn(k))+y_true/6
ap1 = average_precision_score(y_true, y_pred)
P,R,thres = precision_recall_curve(y_true,y_pred)
ap2 = auc(R, P)
L.append((ap1,ap2))
A1 = np.array(L)
return np.mean((A1[:,0]-A1[:,1])/A1[:,0])
func(k=10000)