sklearn.metrics 模型评估指标

 

一、分类指标

1.accuracy_score(y_true,y_pre)：准确率

总的来说就是分类正确的样本占总样本个数的比例，数据越大越好，

但是有一个明显的缺陷，即是当不同类别样本的比例非常不均衡时，占比大的类别往往成为影响准确率的最主要因素，就会出现准确率很高，但是auc却很低的情况（样本不均衡）

参数如下：

y_true : 一维数组，或标签指示符 / 稀疏矩阵，实际（正确的）标签.
y_pred : 一维数组，或标签指示符 / 稀疏矩阵，分类器返回的预测标签.
normalize : 布尔值, 可选的(默认为True). 如果为False，返回分类正确的样本数量，否则，返回正 确分类的得分.
sample_weight : 形状为[样本数量]的数组，可选. 样本权重.
 
返回值：
score : 浮点型
如果normalize为True，返回正确分类的得分（浮点型），否则返回分类正确的样本数量（整型）.
当normalize为True时，最好的表现是score为1，当normalize为False时，最好的表现是score未样本数量.

#示例
import numpy as np
from sklearn.metrics import accuracy_score

y_pred = [0, 2, 1, 3]
y_true = [0, 1, 2, 3]
print(accuracy_score(y_true, y_pred))  # 0.5
print(accuracy_score(y_true, y_pred, normalize=False))  # 2

# 在具有二元标签指示符的多标签分类案例中
print(accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2))))  # 0.5

 

2.auc(x, y, reorder=False) 

计算roc曲线下的面积auc的值

sklearn.metrics.auc(x, y)

参数：

x：fpr

y：tpr

首先要通过roc_curve计算出fpr和tpr的值，然后再metrics.auc(fpr, tpr)

返回：auc的值

 

3.average_precision_score(y_true, y_score, average='macro', sample_weight=None):

根据预测得分计算平均精度(AP)

 

其中Pn和Rn是第n个阈值处的precision和recall。对于随机预测，AP是正样本的比例,

该值在 0 和 1 之间，并且越高越好

注意：此实现仅限于二进制分类任务或多标签分类任务

#官方示例
 import numpy as np
 from sklearn.metrics import average_precision_score
 y_true = np.array([0, 0, 1, 1])
 y_scores = np.array([0.1, 0.4, 0.35, 0.8])
 average_precision_score(y_true, y_scores)   #0.83...

 

4.brier_score_loss(y_true, y_prob, sample_weight=None, pos_label=None):

Brier 分数损失

 

Brier 分数是一个特有的分数函数，用于衡量概率预测的准确性。它适用于预测必须将概率分配给一组相互排斥的离散结果的任务

该函数返回的是 实际结果与可能结果 的预测概率之间均方差的得分。 实际结果必须为1或0（真或假），而实际结果的预测概率可以是0到1之间的值。

Brier 分数损失也在0到1之间，分数越低（均方差越小），预测越准确。它可以被认为是对一组概率预测的 “校准” 的度量

其中:  是预测的总数，  是实际结果  的预测概率

#官方示例
 import numpy as np
 from sklearn.metrics import brier_score_loss
 y_true = np.array([0, 1, 1, 0])
 y_true_categorical = np.array(["spam", "ham", "ham", "spam"])
 y_prob = np.array([0.1, 0.9, 0.8, 0.4])
 y_pred = np.array([0, 1, 1, 0])
 brier_score_loss(y_true, y_prob)  #0.055
 brier_score_loss(y_true, 1-y_prob, pos_label=0) #0.055
 brier_score_loss(y_true_categorical, y_prob, pos_label="ham")  #0.055
 brier_score_loss(y_true, y_prob > 0.5)  #0.0

 

5.confusion_matrix(y_true, y_pred, labels=None, sample_weight=None):

通过计算混淆矩阵来评估分类的准确性 返回混淆矩阵

#官方代码
 from sklearn.metrics import confusion_matrix
 y_true = [2, 0, 2, 2, 0, 1]
 y_pred = [0, 0, 2, 2, 0, 2]
 confusion_matrix(y_true, y_pred)  #array([[2, 0, 0],[0, 0, 1],[1, 0, 2]])

 y_true = ["cat", "ant", "cat", "cat", "ant", "bird"]
 y_pred = ["ant", "ant", "cat", "cat", "ant", "cat"]
 confusion_matrix(y_true, y_pred, labels=["ant", "bird", "cat"])  #array([[2, 0, 0], [0, 0, 1],[1, 0, 2]])


 tn, fp, fn, tp = confusion_matrix([0, 1, 0, 1], [1, 1, 1, 0]).ravel()
 (tn, fp, fn, tp)  #(0, 2, 1, 1)

返回的是TN（真的当成假的），FP（假的当成真的） ，FN（假的还是假的） TP （真的还是真的）

总的来说，T，F分别是真实值中的真假，P，N 分别是预测中的真假

关于类别顺序可由 labels参数控制调整，例如 labels=[2,1,0],则类别将以这个顺序自上向下排列。

默认数字类别是从小到大排列，英文类别是按首字母顺序排列

第一个例子这样理解：

	0（真实）	1（真实）	2（真实）
0（预测）	2	0	1
1（预测）	0	0	0
2（预测）	0	1	2

 

所以就有[[2,0,0],[0,0,1],[1,0,2]]

 

6.f1_score(y_true, y_pred, labels=None, pos_label=1, average='binary', sample_weight=None): F1值

 

 F1 score可以解释为精确率和召回率的加权平均值. F1 score的最好值为1，最差值为0. 精确率和召回率对F1 score的相对贡献是相等的

#示例
from sklearn.metrics import f1_score

y_true = [0, 1, 2, 0, 1, 2]
y_pred = [0, 2, 1, 0, 0, 1]
print(f1_score(y_true, y_pred, average='macro'))  # 0.26666666666666666
print(f1_score(y_true, y_pred, average='micro'))  # 0.3333333333333333
print(f1_score(y_true, y_pred, average='weighted'))  # 0.26666666666666666
print(f1_score(y_true, y_pred, average=None))  # [0.8 0.  0. ]

average : string,[None, ‘binary’(default), ‘micro’, ‘macro’, ‘samples’, ‘weighted’]

这里需要注意，如果是二分类问题则选择参数‘binary’；如果考虑类别的不平衡性，需要计算类别的加权平均，则使用‘weighted’；如果不考虑类别的不平衡性，计算宏平均，则使用‘macro’

对于类0：TP=1，FP=0，FN=1，precision=1，recall=1/2，F1-score=2/3，Weights=1/3

对于类1：TP=1，FP=2，FN=2，precision=1/3，recall=1/3，F1-score=1/3，Weights=1/2

对于类2：TP=0，FP=2，FN=1，precision=0，recall=0，F1-score=0，Weights=1/6

宏平均分数为：0.333；加权平均分数为：0.389

7.log_loss(y_true, y_pred, eps=1e-15, normalize=True, sample_weight=None, labels=None)：

又被称为 logistic regression loss（logistic 回归损失）或者 cross-entropy loss（交叉熵损失） 定义在 probability estimates （概率估计）

#示例
from sklearn.metrics import log_loss

y_true = [0, 0, 1, 1]
y_pred = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]]
log_loss(y_true, y_pred)   #0.1738

 

8.precision_score(y_true, y_pred, labels=None, pos_label=1, average='binary',) ：查准率或者精确度

参数
y_true : 一维数组，或标签指示符 / 稀疏矩阵，实际（正确的）标签.
y_pred : 一维数组，或标签指示符 / 稀疏矩阵，分类器返回的预测标签.
labels : 列表，默认情况下，y_true和y_pred中的所有标签按照排序后的顺序使用.
pos_label : 字符串或整型，默认为1. 如果average = binary并且数据是二进制时需要被报告的类. 若果数据是多类的或者多标签的，这将被忽略；设置labels=[pos_label]和average != binary就只会报告设置的特定标签的分数.
average : 字符串，可选值为[None, ‘binary’ (默认), ‘micro’, ‘macro’, ‘samples’, ‘weighted’]. 多类或 者多标签目标需要这个参数. 如果为None，每个类别的分数将会返回. 否则，它决定了数据的平均值类型.
‘binary’: 仅报告由pos_label指定的类的结果. 这仅适用于目标（y_{true, pred}）是二进制的情况.
‘micro’: 通过计算总的真正性、假负性和假正性来全局计算指标.
‘macro’: 为每个标签计算指标，找到它们未加权的均值. 它不考虑标签数量不平衡的情况.
‘weighted’: 为每个标签计算指标，并通过各类占比找到它们的加权均值（每个标签的正例数）.它解决了’macro’的标签不平衡问题；它可以产生不在精确率和召回率之间的F-score.
‘samples’: 为每个实例计算指标，找到它们的均值（只在多标签分类的时候有意义，并且和函数accuracy_score不同）.
sample_weight : 形状为[样本数量]的数组，可选参数. 样本权重.
 
返回值
precision : 浮点数(如果average不是None) 或浮点数数组, shape =[唯一标签的数量]
二分类中正类的精确率或者在多分类任务中每个类的精确率的加权平均.

#官方代码如下
from sklearn.metrics import precision_score

y_true = [0, 1, 2, 0, 1, 2]
y_pred = [0, 2, 1, 0, 0, 1]
print(precision_score(y_true, y_pred, average='macro'))  # 0.2222222222222222
print(precision_score(y_true, y_pred, average='micro'))  # 0.3333333333333333
print(precision_score(y_true, y_pred, average='weighted'))  # 0.2222222222222222
print(precision_score(y_true, y_pred, average=None))  # [0.66666667 0.         0.        ]

 

9.recall_score(y_true, y_pred, labels=None, pos_label=1, average='binary', sample_weight=None)：召回率

recall(召回率)=TP/(TP+FN)

召回率指实际为正的样本中被预测为正的样本所占实际为正的样本的比例

召回率最好的值是1，最差的值是0

#示例
from sklearn.metrics import recall_score

y_true = [0, 1, 2, 0, 1, 2]
y_pred = [0, 2, 1, 0, 0, 1]
print(recall_score(y_true, y_pred, average='macro'))  # 0.3333333333333333
print(recall_score(y_true, y_pred, average='micro'))  # 0.3333333333333333
print(recall_score(y_true, y_pred, average='weighted'))  # 0.3333333333333333
print(recall_score(y_true, y_pred, average=None))  # [1. 0. 0.]

 

10.roc_auc_score(y_true, y_score, average='macro', sample_weight=None)：

计算ROC曲线下的面积就是AUC的值，值越大越好

#官方示例
import numpy as np
from sklearn.metrics import roc_auc_score

y_true = np.array([0, 0, 1, 1])
y_scores = np.array([0.1, 0.4, 0.35, 0.8])
roc_auc_score(y_true, y_scores)  #0.75

 

11.roc_curve(y_true, y_score, pos_label=None, sample_weight=None, drop_intermediate=True)；

计算ROC曲线的横纵坐标值，TPR，FPR：

TPR = TP/(TP+FN) = recall(真正例率，敏感度)       FPR = FP/(FP+TN)(假正例率，1-特异性)

ks和auc画图时经常使用到

参数：

pos_label：正样本的标签，例如样本label（0,1），其中1表示正样本，则pos_label=1

drop_intermediate：是否降低一些不会出现在绘制的ROC曲线上的次优阈值。这对于创建更浅的ROC曲线很有用

#官方代码
import numpy as np
from sklearn import metrics
y = np.array([1, 1, 2, 2])
scores = np.array([0.1, 0.4, 0.35, 0.8])
fpr, tpr, thresholds = metrics.roc_curve(y, scores, pos_label=2)
fpr  #array([0. , 0. , 0.5, 0.5, 1. ])
tpr  #array([0. , 0.5, 0.5, 1. , 1. ])
thresholds  #array([1.8 , 0.8 , 0.4 , 0.35, 0.1 ])

补充一下混淆矩阵如下：

 

 

二、回归指标

1.explained_variance_score(y_true, y_pred, sample_weight=None, multioutput='uniform_average')：回归方差(反应自变量与因变量之间的相关程度)

 

explained_variance_score：解释方差分，这个指标用来衡量我们模型对数据集波动的解释程度，如果取值为1时，模型就完美，越小效果就越差

# 例子
from sklearn.metrics import explained_variance_score

y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
explained_variance_score(y_true, y_pred)  #0.957


y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
explained_variance_score(y_true, y_pred, multioutput='uniform_average')  #0.983

 

2.mean_absolute_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average')：平均绝对误差

 

即是真实值和预测值的差的绝对值的平均值
给定数据点的平均绝对误差，一般来说取值越小，模型的拟合效果就越好
缺点：若本身真实值就比较大，比如真实值1万，预测值9000，但mae=1000就会造成MAE是比较大的,如真实值10，预测值9，但mae=1，所以不能单独从MAE的值来说明网络预测能力的好坏

 

#官方例子
from sklearn.metrics import mean_absolute_error

y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
mean_absolute_error(y_true, y_pred)  #0.5

y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
mean_absolute_error(y_true, y_pred)  #0.75

mean_absolute_error(y_true, y_pred, multioutput='raw_values') #array([0.5, 1. ])
mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7]) #0.85

参数解释：multioutput可选2种方式：
row_values:返回完整的错误集；
uniform_average:输出的误差均以相同的权重

 

3.mean_squared_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average')：均方误差

 

反映预测值与真实值之间差异程度的一种度量，换句话说，预测值与真实值差的平方的期望值。MSE可以评价数据的变化程度，MSE的值越小，说明预测模型的预测能力越好

#官方示例
from sklearn.metrics import mean_squared_error

y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
mean_squared_error(y_true, y_pred)  #0.375
mean_squared_error(y_true, y_pred, squared=False) #0.612

y_true = [[0.5, 1],[-1, 1],[7, -6]]
y_pred = [[0, 2],[-1, 2],[8, -5]]
mean_squared_error(y_true, y_pred) #0.708
mean_squared_error(y_true, y_pred, multioutput='raw_values') #array([0.41666667, 1.        ])
mean_squared_error(y_true, y_pred, multioutput=[0.3, 0.7]) #0.825

 

4.median_absolute_error(y_true, y_pred)   中位数绝对误差

 

得到的值越小越好

 from sklearn.metrics import median_absolute_error


 y_true = [3, -0.5, 2, 7]
 y_pred = [2.5, 0.0, 2, 8]
 median_absolute_error(y_true, y_pred) #0.5


 y_true = [[0.5, 1], [-1, 1], [7, -6]]
 y_pred = [[0, 2], [-1, 2], [8, -5]]
 median_absolute_error(y_true, y_pred) #0.75


 median_absolute_error(y_true, y_pred, multioutput='raw_values') #array([0.5, 1. ])
 median_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7]) #0.85

 

5.r2_score(y_true, y_pred, sample_weight=None, multioutput='uniform_average')  ：决定系数，R平方

也等于

 

 

残差平方和：SSE，即估计值与真实值的误差，反映模型拟合程度
总离差平方和：SST，即平均值与真实值的误差，反映与数学期望的偏离程度
R方可以理解为因变量y中的变异性能能够被估计的多元回归方程解释的比例，它衡量各个自变量对因变量变动的解释程度，其取值在0与1之间，其值越接近1，则变量的解释程度就越高，其值越接近0，其解释程度就越弱。可以通俗地理解为使用均值作为误差基准，看预测误差是否大于或者小于均值基准误差
一般来说，增加自变量的个数，回归平方和会增加，残差平方和会减少，所以R方会增大；反之，减少自变量的个数，回归平方和减少，残差平方和增加。
经验值：>0.4， 拟合效果好

R2_score = 1，样本中预测值和真实值完全相等，没有任何误差，表示回归分析中自变量对因变量的解释越好。
R2_score = 0。此时分子等于分母，样本的每项预测值都等于均值。
R2_score不是r的平方，也可能为负数(分子>分母)，模型等于盲猜，还不如直接计算目标变量的平均值

缺点：数据集的样本越大，R²越大，因此，不同数据集的模型结果比较会有一定的误差

#官方示例
 from sklearn.metrics import r2_score

 y_true = [3, -0.5, 2, 7]
 y_pred = [2.5, 0.0, 2, 8]
 r2_score(y_true, y_pred)  #0.948...

 y_true = [[0.5, 1], [-1, 1], [7, -6]]
 y_pred = [[0, 2], [-1, 2], [8, -5]]
 r2_score(y_true, y_pred,multioutput='variance_weighted')  #0.938...

 y_true = [1, 2, 3]
 y_pred = [1, 2, 3]
 r2_score(y_true, y_pred)  #1.0

 y_true = [1, 2, 3]
 y_pred = [2, 2, 2]
 r2_score(y_true, y_pred)  #0.0

 y_true = [1, 2, 3]
 y_pred = [3, 2, 1]
 r2_score(y_true, y_pred)  #-3.0

 

 6.mean_squared_log_error(y_true, y_pred)

 当目标实现指数增长时，例如人口数量、一种商品在几年时间内的平均销量等，这个指标最适合使用。请注意，这个指标惩罚的是一个被低估的估计大于被高估的估计