页面树结构

2017-11-09 ApacheCN 开源组织,第二期邀请成员活动,一起走的更远 : http://www.apachecn.org/member/209.html


MachineLearning 优酷地址 : http://i.youku.com/apachecn

转至元数据结尾
转至元数据起始

有三种不同的方法来评估模型的预测质量:

最后,虚拟估算器对于获得随机预测的这些指标的基准值是有用的。

 

也可以看看:对于“成对”指标,样本之间,而不是估计或预测,请参阅成对度量度,亲和力和内核部分。

scoring参数:定义模型评价规则 

使用工具进行模型选择和评估,例如 model_selection.GridSearchCV和 model_selection.cross_val_score,采用一个scoring参数来控制它们对评估的估计量应用的指标。

常见情况:预定义值

对于最常见的用例,您可以使用scoring参数指定一个记分对象 ; 下表显示了所有可能的值。所有得分手对象遵循惯例:较高的返回值优于较低的返回值。因此,衡量模型和数据之间距离的度量(metrics.mean_squared_error如)可用作返回度量值的否定值的neg_mean_squared_error。

评分功能评论
分类  
‘accuracy’metrics.accuracy_score 
‘average_precision’metrics.average_precision_score 
‘f1’metrics.f1_score用于二进制目标
‘f1_micro’metrics.f1_score微平均
‘f1_macro’metrics.f1_score宏平均
‘f1_weighted’metrics.f1_score加权平均
‘f1_samples’metrics.f1_score通过多分类样本
‘neg_log_loss’metrics.log_loss需要predict_proba支持
‘precision’ etc.metrics.precision_score后缀适用于'f1'
‘recall’ etc.metrics.recall_score后缀适用于'f1'
‘roc_auc’metrics.roc_auc_score 
聚类  
‘adjusted_rand_score’metrics.adjusted_rand_score 
回归  
‘neg_mean_absolute_error’metrics.mean_absolute_error 
‘neg_mean_squared_error’metrics.mean_squared_error 
‘neg_median_absolute_error’metrics.median_absolute_error 
‘r2’metrics.r2_score 

用法示例:

>>> from sklearn import svm, datasets
>>> from sklearn.model_selection import cross_val_score
>>> iris = datasets.load_iris()
>>> X, y = iris.data, iris.target
>>> clf = svm.SVC(probability=True, random_state=0)
>>> cross_val_score(clf, X, y, scoring='neg_log_loss') 
array([-0.07..., -0.16..., -0.06...])
>>> model = svm.SVC()
>>> cross_val_score(model, X, y, scoring='wrong_choice')
Traceback (most recent call last):
ValueError: 'wrong_choice' is not a valid scoring value. Valid options are ['accuracy', 'adjusted_rand_score', 'average_precision', 'f1', 'f1_macro', 'f1_micro', 'f1_samples', 'f1_weighted', 'neg_log_loss', 'neg_mean_absolute_error', 'neg_mean_squared_error', 'neg_median_absolute_error', 'precision', 'precision_macro', 'precision_micro', 'precision_samples', 'precision_weighted', 'r2', 'recall', 'recall_macro', 'recall_micro', 'recall_samples', 'recall_weighted', 'roc_auc']

 

 

注意:ValueError异常列出的值对应于以下部分中描述的测量预测精度的函数。这些功能的得分手对象存储在字典中sklearn.metrics.SCORERS

从公制函数定义你的评分策略

该模块sklearn.metric还暴露了一组测量预测误差的简单函数,给出了地面真实和预测:

  • 函数以_score返回值最大化结束,越高越好。
  • 功能结束_error_loss返回值最小化,越低越好。当使用转换为记分对象时make_scorer,将greater_is_better参数设置为False(默认为True);请参阅下面的参数说明。

可用于各种机器学习任务的指标在下面详细介绍。

许多指标没有被赋予用作scoring值的名称,有时是因为它们需要额外的参数,例如 fbeta_score。在这种情况下,您需要生成一个适当的评分对象。生成可评估对象进行评分的最简单的方法是使用make_scorer。该函数将度量转换为可用于模型评估的可调用。

一个典型的用例是将库中的现有度量函数包含在其参数的非默认值中,例如函数的beta参数fbeta_score

>>> from sklearn.metrics import fbeta_score, make_scorer
>>> ftwo_scorer = make_scorer(fbeta_score, beta=2)
>>> from sklearn.model_selection import GridSearchCV
>>> from sklearn.svm import LinearSVC
>>> grid = GridSearchCV(LinearSVC(), param_grid={'C': [1, 10]}, scoring=ftwo_scorer)

第二个用例是使用简单的python函数来构建一个完全自定义的scorer对象make_scorer,它可以使用几个参数:

  • 你想要使用的python函数(my_custom_loss_func 在下面的例子中)
  • python函数是否返回一个分数(greater_is_better=True,默认值)还是一个loss(greater_is_better=False)。如果一个损失,得分器对象的python函数的输出被否定,符合交叉验证约定,得分者为更好的模型返回更高的值。
  • 仅用于分类度量:您提供的python函数是否需要连续的判断确定性(needs_threshold=True)。默认值为False。
  • 任何额外的参数,例如betalabelsf1_score

以下是建立自定义记分员以及使用greater_is_better参数的示例 :

>>> import numpy as np
>>> def my_custom_loss_func(ground_truth, predictions):
...     diff = np.abs(ground_truth - predictions).max()
...     return np.log(1 + diff)
...
>>> # loss_func will negate the return value of my_custom_loss_func,
>>> #  which will be np.log(2), 0.693, given the values for ground_truth
>>> #  and predictions defined below.
>>> loss  = make_scorer(my_custom_loss_func, greater_is_better=False)
>>> score = make_scorer(my_custom_loss_func, greater_is_better=True)
>>> ground_truth = [[1, 1]]
>>> predictions  = [0, 1]
>>> from sklearn.dummy import DummyClassifier
>>> clf = DummyClassifier(strategy='most_frequent', random_state=0)
>>> clf = clf.fit(ground_truth, predictions)
>>> loss(clf,ground_truth, predictions) 
-0.69...
>>> score(clf,ground_truth, predictions) 
0.69...

 

实现自己的评分对象

您可以通过从头开始构建自己的评分对象,而不使用make_scorer工厂,从而生成更灵活的模型得分手。要求成为记分员,需要符合以下两个规则所指定的协议:

  • 它可以用参数调用 ,应该评估的模型在哪里,是验证数据,是(在监督的情况下)或(在无监督的情况下)的基本真实目标。(estimator, X, y)estimatorXyXNone
  • 它返回量化浮点数 estimator上预测质量X,参考y。再次,按照惯例,更高的数字更好,所以如果你的得分手返回损失,该值应该被否定。

 

分类度量

sklearn.metrics模块实现了几种损失,分数和效用函数来测量分类性能。某些指标可能需要正类,置信度值或二进制决策值的概率估计。大多数实现允许每个样本通过sample_weight参数提供对总分的加权贡献。

其中一些仅限于二进制分类案例:

matthews_corrcoef(y_true, y_pred[, ...])计算二进制类的马修斯相关系数(MCC)
precision_recall_curve(y_true, probas_pred)计算不同概率阈值的precision-recall
roc_curve(y_true, y_score[, pos_label, ...])计算接收器工作特性(ROC)

其他人也可以在多类案件中工作:

cohen_kappa_score(y1, y2[, labels, weights])

科恩的kappa: 衡量标注者间协议的统计

confusion_matrix(y_true, y_pred[, labels, ...])计算混淆矩阵来评估分类的准确性
hinge_loss(y_true, pred_decision[, labels, ...])平均铰链损失(非正规化)

有些还可以在多重案例中工作:

accuracy_score(y_true, y_pred[, normalize, ...])准确度分级得分
classification_report(y_true, y_pred[, ...])构建一个显示主要分类指标的文本报告
f1_score(y_true, y_pred[, labels, ...])计算F1分数,也称为平衡F分数或F度量
fbeta_score(y_true, y_pred, beta[, labels, ...])计算F-beta分数
hamming_loss(y_true, y_pred[, labels, ...])计算平均汉明损失
jaccard_similarity_score(y_true, y_pred[, ...])Jaccard相似系数得分
log_loss(y_true, y_pred[, eps, normalize, ...])对数损失,又称物流损失或交叉熵损失
precision_recall_fscore_support(y_true, y_pred)计算每个分类的精度,召回,F度量和支持
precision_score(y_true, y_pred[, labels, ...])计算精度
recall_score(y_true, y_pred[, labels, ...])计算召回
zero_one_loss(y_true, y_pred[, normalize, ...])Zero-one 分类损失

有些工作与二进制和multilabel(但不是多类)问题:

average_precision_score(y_true, y_score[, ...])从预测分数计算平均精度(AP)
roc_auc_score(y_true, y_score[, average, ...])曲线下的计算面积(AUC)来自预测分数

在以下小节中,我们将介绍每个这些功能,前面是一些关于通用API和度量定义的注释。

从二元到多类别和多标签

一些度量基本上是针对二进制分类任务定义的(例如 f1_scoreroc_auc_score)。在这些情况下,默认情况下仅评估正标签,假设默认情况下正面类别已被标记1(尽管这可以通过pos_label参数进行配置 )。

将二进制度量扩展为多类或多标签问题时,数据将被视为二进制问题的集合,每个类都有一个。然后可以使用多种方法在整个类中平均二进制度量计算,每种类在某些情况下可能会有用。如果可用,您应该使用average参数在其中进行选择。

  • "macro"简单地计算二进制度量的平均值,赋予每个类别相同的权重。在不常见的课程重要的问题上,宏观平均可能是突出表现的一种手段。另一方面,所有类别同样重要的假设通常是不真实的,因此宏观平均将过度强调不频繁类的典型的低绩效。
  • "weighted" 通过计算通过其在真实数据样本中的存在来对每个类的分数进行加权的二进制度量的平均值来计算类不平衡。
  • "micro"给出每个样本类对对总体度量的相等贡献(除了作为样本权重的结果)。而不是总结每个类别的指标,这个总和构成每个类别指标的股息和除数计算一个整体商。在多标签设置中,微平均可能是优选的,包括要忽略多数类的多类分类。
  • "samples"仅适用于多标签问题。它不计算每个类别的度量,而是计算评估数据中每个样本的真实和预测类别的度量,并返回( - sample_weight加权)平均值。
  • 选择average=None将返回具有每个类的分数的数组。

虽然将多类数据提供给度量,如二进制目标,作为类标签数组,多标签数据被指定为指示符矩阵,如果样本具有标签,值为0,则其中单元格的值为1 。[i, j] j

精度得分

accuracy_score函数计算正确预测的 精度,分数(默认)或计数(normalize = False)。

在多标签分类中,函数返回子集精度。如果样本的整套预测标签与真正的标签组一致,则子集精度为1.0; 否则为0.0。

如果是第三个样本的预测值,并且义是相应的真实值,则将正确预测的分数定义为

其中指示符函数

>>> import numpy as np
>>> from sklearn.metrics import accuracy_score
>>> y_pred = [0, 2, 1, 3]
>>> y_true = [0, 1, 2, 3]
>>> accuracy_score(y_true, y_pred)
0.5
>>> accuracy_score(y_true, y_pred, normalize=False)
2 

 

在具有二进制标签指示器的多标签案例中:

>>> accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5
 

例:

  • 请参阅 使用排列数据集进行准确评分使用示例的排序分数的重要性进行排列。
 

科恩的kappa

该函数cohen_kappa_score计算Cohen的kappa统计量。此措施旨在比较不同人类注释者的标签,而不是分类器与地面真理。

kappa分数(见docstring)是-1和1之间的数字.8以上的分数通常被认为是很好的一致; 零或更低表示没有协议(实际上是随机标签)。

可以计算二进制或多类问题的Kappa分数,但不能用于多重标签问题(除了手动计算每个标签分数),而不是两个以上的注释器。

>>> from sklearn.metrics import cohen_kappa_score
>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> cohen_kappa_score(y_true, y_pred)
0.4285714285714286

 

混淆矩阵

confusion_matrix函数通过计算混淆矩阵来评估分类精度。

根据定义,混淆矩阵中的输入是实际上在组中的观察次数一世,但是预测在组中。这是一个例子:

>>> 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 = [0, 0, 0, 1, 1, 1, 1, 1]
>>> y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
>>> tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
>>> tn, fp, fn, tp
(2, 1, 2, 3) 

           

例:

 

分类报告

classification_report函数构建一个显示主分类指标的文本报告。这是一个小例子,其中包含自定义target_names和推断标签:

>>> from sklearn.metrics import classification_report
>>> y_true = [0, 1, 2, 2, 0]
>>> y_pred = [0, 0, 2, 1, 0]
>>> target_names = ['class 0', 'class 1', 'class 2']
>>> print(classification_report(y_true, y_pred, target_names=target_names))
             precision    recall  f1-score   support

    class 0       0.67      1.00      0.80         2
    class 1       0.00      0.00      0.00         1
    class 2       1.00      0.50      0.67         2

avg / total       0.67      0.60      0.59         5 

示例:

 

Hamming 损失


所述hamming_loss计算的平均汉明损失或汉明距离两组样品之间。

如果给定样本Ĵ第一个标签的预测值y_j是相应的真实值,并且 是类别或标签的数量,则两个样本之间的汉明丢失定义为:

其中指示符函数

>>> from sklearn.metrics import hamming_loss
>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> hamming_loss(y_true, y_pred)
0.25

在具有二进制标签指示器的多标签案例中:

>>> hamming_loss(np.array([[0, 1], [1, 1]]), np.zeros((2, 2)))
0.75 

注意:在多类别分类中,汉明损失对应于汉明距离之间y_truey_pred零损失函数相似 。然而,零一损失惩罚不严格匹配真实集合的预测集,Hamming损失惩罚单个标签。因此,汉明的损失由零损失上限,总是在零一和零之间; 并且预测真正的标签的正确的子集或超集将给出零和一之间的汉明损失。

 

Jaccard相似系数得分

jaccard_similarity_score函数计算标签组对之间的平均(默认)或Jaccard相似系数的总和,也称为Jaccard索引。

将第三一世个样本的Jaccard相似系数与地面真值标签集义和预测标签集合 定义为

在二进制和多类分类中,Jaccard相似系数得分等于分类精度。

>>> import numpy as np
>>> from sklearn.metrics import jaccard_similarity_score
>>> y_pred = [0, 2, 1, 3]
>>> y_true = [0, 1, 2, 3]
>>> jaccard_similarity_score(y_true, y_pred)
0.5
>>> jaccard_similarity_score(y_true, y_pred, normalize=False)
2 

在具有二进制标签指示器的多标签案例中:

>>> jaccard_similarity_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.75 

 

准确率,召回和F-措施

直观地说,精确度是分类器不能标记为正的样本为负的能力,并且 召回是分类器找到所有阳性样本的能力。

的 F值 (F_1测量)可以被解释为的精确度和召回加权调和平均值。甲 度量达到在1其最佳值和其在0。最坏的得分, 并 F_1 是等效的,并且召回和精度也同样重要。

precision_recall_curve计算从地面实况标签精确召回曲线,通过改变决策阈值由分类给予评分。

average_precision_score函数根据预测分数计算平均精度(AP)。该分数对应于精确回忆曲线下的面积。该值在0和1之间,而更高更好。通过随机预测,AP是阳性样本的分数。

几个功能可以让您分析精度,召回率和F度量度:

average_precision_score(y_true, y_score[, ...])从预测分数计算平均精度(AP)
f1_score(y_true, y_pred[, labels, ...])计算F1分数,也称为平衡F分数或F度量
fbeta_score(y_true, y_pred, beta[, labels, ...])计算F-beta分数
precision_recall_curve(y_true, probas_pred)计算不同概率阈值的精确回忆对
precision_recall_fscore_support(y_true, y_pred)计算每个课程的精度,回忆,F度量和支持
precision_score(y_true, y_pred[, labels, ...])计算精度
recall_score(y_true, y_pred[, labels, ...])计算召回

请注意,该precision_recall_curve功能仅限于二进制的情况。该average_precision_score功能仅适用于二进制分类和多标签指示器格式。

例子:

二进制分类

在二进制分类任务中,术语“正”和“负”是指分类器的预测,术语“真”和“假”是指该预测是否对应于外部判断有时被称为'观察'')。给出这些定义,我们可以制定下表:

 实际班(观察)
预测课(期望)tp(真正)正确结果fp(false positive)意外结果
fn(false negative)缺少结果tn(true negative)正确的没有结果

在这种情况下,我们可以定义精度,召回和F度量的概念:

以下是二进制分类中的一些小例子:

>>> from sklearn import metrics
>>> y_pred = [0, 1, 0, 0]
>>> y_true = [0, 1, 0, 1]
>>> metrics.precision_score(y_true, y_pred)
1.0
>>> metrics.recall_score(y_true, y_pred)
0.5
>>> metrics.f1_score(y_true, y_pred)  
0.66...
>>> metrics.fbeta_score(y_true, y_pred, beta=0.5)  
0.83...
>>> metrics.fbeta_score(y_true, y_pred, beta=1)  
0.66...
>>> metrics.fbeta_score(y_true, y_pred, beta=2) 
0.55...
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5)  
(array([ 0.66...,  1.        ]), array([ 1. ,  0.5]), array([ 0.71...,  0.83...]), array([2, 2]...))


>>> import numpy as np
>>> from sklearn.metrics import precision_recall_curve
>>> 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])
>>> precision, recall, threshold = precision_recall_curve(y_true, y_scores)
>>> precision  
array([ 0.66...,  0.5       ,  1.        ,  1.        ])
>>> recall
array([ 1. ,  0.5,  0.5,  0. ])
>>> threshold
array([ 0.35,  0.4 ,  0.8 ])
>>> average_precision_score(y_true, y_scores)  
0.79... 

 

多类和多标签分类

在多类和多标签分类任务中,精度,召回和F度量的概念可以独立地应用于每个标签。有几种方法可以横跨标签结果组合,由指定的average参数的 average_precision_score(仅多标记), ,f1_score, , fbeta_score 和功能,如所描述以上。请注意,对于包含所有标签的多类设置中的“微” - 相位将产生相等的精度,召回,而“加权”平均可产生不在精度和回忆之间的F分数。precision_recall_fscore_supportprecision_scorerecall_score F

为了使之更加明确,请考虑以下符号:

  • ÿ一组预测 
  • 一套真正的 
  • 大号 该组标签
  • 小号 该套样品
  • Y_Sÿ与样本的子集小号,即
  • Y_Lÿ标签的子集升
  • 类似地,并且是子集 
  •  (约定在处理上有所不同;此实现使用 ,类似于P。)

然后,度量标准定义为:

average精确召回F_beta
"micro"
"samples"
"macro"
"weighted"
None
 
>>> from sklearn import metrics
>>> y_true = [0, 1, 2, 0, 1, 2]
>>> y_pred = [0, 2, 1, 0, 0, 1]
>>> metrics.precision_score(y_true, y_pred, average='macro')  
0.22...
>>> metrics.recall_score(y_true, y_pred, average='micro')
... 
0.33...
>>> metrics.f1_score(y_true, y_pred, average='weighted')  
0.26...
>>> metrics.fbeta_score(y_true, y_pred, average='macro', beta=0.5)  
0.23...
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5, average=None)
... 
(array([ 0.66...,  0.        ,  0.        ]), array([ 1.,  0.,  0.]), array([ 0.71...,  0.        ,  0.        ]), array([2, 2, 2]...))  

 

对于使用“负面类”的多类分类,可以排除一些标签:

>>> metrics.recall_score(y_true, y_pred, labels=[1, 2], average='micro')
... # excluding 0, no labels were correctly recalled
0.0 

类似地,数据样本中不存在的标签可以在宏平均中考虑。

>>> metrics.precision_score(y_true, y_pred, labels=[0, 1, 2, 3], average='macro')
... 
0.166... 

 

铰链损失

hinge_loss函数使用铰链损失来计算模型和数据之间的平均距离 ,单次度量仅考虑预测误差。(铰链损失用于最大边缘分类器,如支持向量机。)

如果标签用+1和-1编码,则 ÿ:是真值,并且是预测的决策作为输出 decision_function,则铰链损失定义为:

如果有两个以上的标签,则hinge_loss由于Crammer&Singer而使用多类型变体。 是描述它的论文。

如果y_w是真实标签的预测决策,并且y_t是所有其他标签的预测决策的最大值,其中通过决策函数输出预测决策,则多类铰链损失由以下定义:

这里有一个小例子演示了hinge_loss在二进制类问题中使用svm分类器的函数:

>>> from sklearn import svm
>>> from sklearn.metrics import hinge_loss
>>> X = [[0], [1]]
>>> y = [-1, 1]
>>> est = svm.LinearSVC(random_state=0)
>>> est.fit(X, y)
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=0, tol=0.0001,
     verbose=0)
>>> pred_decision = est.decision_function([[-2], [3], [0.5]])
>>> pred_decision  
array([-2.18...,  2.36...,  0.09...])
>>> hinge_loss([-1, 1, 1], pred_decision)  
0.3... 

下面是一个示例,说明hinge_loss在多类问题中使用svm分类器的函数:

>>> X = np.array([[0], [1], [2], [3]])
>>> Y = np.array([0, 1, 2, 3])
>>> labels = np.array([0, 1, 2, 3])
>>> est = svm.LinearSVC()
>>> est.fit(X, Y)
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
     verbose=0)
>>> pred_decision = est.decision_function([[-1], [2], [3]])
>>> y_true = [0, 2, 3]
>>> hinge_loss(y_true, pred_decision, labels)  
0.56...

 

日志丢失

Logistic回归损失或交叉熵损失的Log损失定义在概率估计上。它通常用于(多项式)逻辑回归和神经网络,以及一些预期最大化的变体,可用于评估predict_proba分类器的概率输出(而不是其离散预测)。

对于具有真实标签 和概率估计的二进制分类,每个样本的对数损失是给定真实标签的分类器的负对数似然:

这扩展到多类案例如下。让一组样本的真实标签被编码为1-K二进制指示符矩阵ÿ,即如果样本一世具有ķ 从一组标签获取的ķ标签。让我们P成为概率估计矩阵。那么整套的日志丢失就是

要了解这个概括上面给出的二进制日志丢失,请注意,在二进制的情况下, ,因此扩大内求和 给出了二进制日志的损失。

log_loss函数计算日志丢失给地面实况标签和概率矩阵的一个列表,由估计的返回的predict_proba 方法。

>>> 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... 

第一中表示的是,第一样本具有标签0。日志损失是非负的90%的概率。[.9, .1]y_pred

 

马修斯相关系数

matthews_corrcoef函数计算 二进制类的 马修相关系数(MCC)。引用维基百科:

“马修斯相关系数在机器学习中被用来衡量二进制(两类)分类的质量。它考虑到真假误差和负数,并且通常被认为是可以使用的平衡措施,即使类的尺寸非常大。MCC本质上是-1和+1之间的相关系数值。系数+1表示完美预测,0表示平均随机预测,-1表示反向预测。统计量也称为phi系数。

如果TPTNFPFN分别真阳性,真阴性,假阳性和假阴性的数量,MCC系数被定义为

这是一个小例子,说明了该matthews_corrcoef 函数的用法:

>>> from sklearn.metrics import matthews_corrcoef
>>> y_true = [+1, +1, +1, -1]
>>> y_pred = [+1, -1, +1, +1]
>>> matthews_corrcoef(y_true, y_pred)  
-0.33... 

 

 

接收机工作特性(ROC)

该函数roc_curve计算 接收器工作特性曲线或ROC曲线。引用维基百科:

“接收机工作特性(ROC)或简单的ROC曲线是一个图形图,说明了二进制分类器系统的性能,因为它的鉴别阈值是变化的。它是通过在不同的阈值设置下,从真阳性(TPR =真阳性率)与阴性之间的假阳性比例(FPR =假阳性率)绘制真阳性的比例来创建的。TPR也被称为灵敏度,FPR是减去特异性或真实的阴性率。

该函数需要真正的二进制值和目标分数,这可以是正类的概率估计,置信度值或二进制决策。这是一个如何使用该roc_curve功能的小例子:

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

该图显示了这样的ROC曲线的示例:

roc_auc_score函数计算接收器工作特性(ROC)曲线下的面积,也由AUC或AUROC表示。通过计算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

 

在多标签分类中,roc_auc_score通过如上所述的标签平均来扩展该功能。

与诸如子集精确度,汉明丢失或F1分数的度量相比,ROC不需要优化每个标签的阈值。roc_auc_score如果预测的输出已被二进制化,该 功能也可用于多类分类。

例子:

 

Zero one 损失

zero_one_loss函数计算0-1分类丢失()的和或平均值。默认情况下,函数在样本上标准化。得到的总和,设置normalizeFalse

在多zero_one_loss标签分类中,如果其标签严格匹配预测,则分数为一个子集,如果存在任何错误,则为零。默认情况下,函数返回不完全预测子集的百分比。要获得这样的子集的计数,请设置 normalizeFalse

如果一世第一个样本的预测值,并且义是相应的真实值,则0-1损失定义为:

其中指示符函数

>>> from sklearn.metrics import zero_one_loss
>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> zero_one_loss(y_true, y_pred)
0.25
>>> zero_one_loss(y_true, y_pred, normalize=False)
1

在具有二进制标签指示符的多标签情况下,第一个标签集[0,1]有一个错误:

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)),  normalize=False)
1

例:

 

Brier分数损失

brier_score_loss函数计算 二进制类的 Brier分数。引用维基百科:

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

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

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

其中:ñ是预测的总数,F_T是实际结果的预测概率O_t同

这是一个使用这个函数的小例子:

>>> 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 

示例:

参考文献:

 

多标签排名指标

在多标签学习中,每个样本可以具有与其相关联的任何数量的地面真实标签。目标是给予高分,更好地评价地面真相标签。

 

覆盖误差

coverage_error函数计算在最终预测中必须包括的平均标签数,以便预测所有真实的标签。如果您想知道有多少顶级评分标签,您必须平均预测,而不会丢失任何真正的标签,这是有用的。因此,此指标的最佳价值是真正标签的平均数量。

正式地,给定地面真值标签的二进制指标矩阵 和与每个标签相关联的分数 ,覆盖范围被定义为

。给定等级定义,y_scores通过给出将被分配给所有绑定值的最大等级来破坏关系。

这是一个使用这个功能的小例子:

>>> import numpy as np
>>> from sklearn.metrics import coverage_error
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> coverage_error(y_true, y_score)
2.5 

 

标签排名平均精度

label_ranking_average_precision_score功能实现标签排名平均精度(LRAP)。该度量与average_precision_score功能相关,但是基于标签排名的概念,而不是精确度和召回。

标签排名平均精度(LRAP)是分配给每个样本的每个地面真相标签的平均值,真实对总标签与较低分数的比率。如果能够为每个样本相关标签提供更好的排名,这个指标就会产生更好的分数。获得的得分总是严格大于0,最佳值为1.如果每个样本只有一个相关标签,则标签排名平均精度等于平均倒数等级

形式上,给定地面真值标签的二进制指标矩阵 和与每个标签相关的得分 ,平均精度定义为

,  而且是l0规范或集合的基数。

这是一个使用这个功能的小例子:

>>> import numpy as np
>>> from sklearn.metrics import label_ranking_average_precision_score
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_average_precision_score(y_true, y_score) 
0.416... 

 

排名损失

label_ranking_loss函数计算排序损失,平均值取样不正确排列的标签对的数量,即真实标签的分数低于虚假标签,由虚假和真实标签的倒数加权。最低可实现的排名损失为零。

正式地,给定地面真值标签的二进制指标矩阵 和与每个标签相关联的得分 ,排名损失定义为

该集合规范或基数在哪里。

这是一个使用这个功能的小例子:

>>> import numpy as np
>>> from sklearn.metrics import label_ranking_loss
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_loss(y_true, y_score) 
0.75...
>>> # With the following prediction, we have perfect and minimal loss
>>> y_score = np.array([[1.0, 0.1, 0.2], [0.1, 0.2, 0.9]])
>>> label_ranking_loss(y_true, y_score)
0.0 


回归度量

sklearn.metrics模块实现了几个损失,分数和效用函数来衡量回归性能。他们有些已得到增强,以处理多输出的情况下:mean_squared_error, mean_absolute_errorexplained_variance_score和 r2_score

这些函数有一个multioutput关键字参数,它指定每个目标的分数或者损失应该被平均的方式。默认值是'uniform_average'指出输出均匀加权平均值。如果一个ndarray形状(n_outputs,)通过,则其条目被解释为权重,并且返回相应的加权平均值。如果multioutputIS 'raw_values'被指定,则所有未改变的个人得分或损失将在形状的阵列返回 (n_outputs,)

r2_scoreexplained_variance_score接受附加价值'variance_weighted'multioutput参数。该选项通过相应目标变量的方差导出每个单独得分的加权。此设置量化了全局捕获的未缩放方差。如果目标变量的尺度不同,则该分数更好地解释较高的方差变量。 multioutput='variance_weighted'r2_score 用于向后兼容的默认值。这将uniform_average在将来更改。

 

解释方差分数

explained_variance_score计算解释方差回归得分

如果是估计目标输出,ÿ则对应(正确)目标输出,并且瓦尔方差,标准偏差的平方,则所述方差估计如下:

最好的分数是1.0,较低的值越差。

这是一个使用该explained_variance_score 功能的小例子:

>>> 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='raw_values')
... 
array([ 0.967...,  1.        ])
>>> explained_variance_score(y_true, y_pred, multioutput=[0.3, 0.7])
... 
0.990... 

 

平均绝对误差

mean_absolute_error函数计算平均绝对误差,对应于绝对误差损失或者L1损失的预期值的风险度量 。

如果一世第一个样本的预测值,并且义是相应的真实值,则估计的平均绝对误差(MAE)定义为

这是一个使用该mean_absolute_error功能的小例子:

>>> 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.849...

 

 

均方误差

mean_squared_error函数计算均方误差,与平方(二次)误差损失或损耗的预期值对应的风险度量。

如果是第三一世个样本的预测值,并且义是相应的真实值,则估计的均方误差(MSE)定义为

这是一个使用该mean_squared_error 功能的小例子:

>>> 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
>>> 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.7083...

例子:

  • 有关 平均误差使用情况的示例,请参阅渐变增强回归,以评估梯度提升回归。
 

中间绝对误差

median_absolute_error是非常有趣的,因为它对离群值是稳健的。通过取目标和预测之间的所有绝对差值的中位数来计算损失。

如果一世第一个样本的预测值,并且义是相应的真实值,则估计的中值绝对误差(MedAE)定义为

median_absolute_error不支持多输出。

这是一个使用该median_absolute_error 功能的小例子:

>>> 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

 

 

R²分数,确定系数

r2_score函数计算R 2,确定系数。它提供了未来样本如何有可能被模型预测的量度。最佳分数为1.0,可以为负数(因为模型可能会更糟)。总是预测y的预期值,不考虑输入特征的常数模型将得到R ^ 2得分为0.0。

如果一世第一个样本的预测值,并且义是相应的真实值,则估计的分数R 2 定义为

在那里

这是一个使用该r2_score功能的小例子:

>>> 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 = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='uniform_average')
... 
0.936...
>>> r2_score(y_true, y_pred, multioutput='raw_values')
... 
array([ 0.965...,  0.908...])
>>> r2_score(y_true, y_pred, multioutput=[0.3, 0.7])
... 
0.925...

示例:

 

聚类度量

sklearn.metrics模块实现了几个损失,分数和效用函数。有关更多信息,请参阅集群性能评估 部分,例如聚类,以及双聚类的Biclustering评估

 

虚拟估计

在进行监督学习的过程中,简单的理性检查包括将人的估计与简单的经验法则进行比较。DummyClassifier 实施几个这样简单的分类策略:

  • stratified 通过尊重训练集类分布来生成随机预测。

  • most_frequent 总是预测训练集中最常见的标签。

  • prior总是预测课程最大化之前的类(如返回类之前。most_frequent`) and ``predict_proba

  • uniform 随机产生预测。

  • constant 总是预测用户提供的常量标签。这种方法的主要动机是F1得分,当积极阶级在少数时。

请注意,使用所有这些策略,该predict方法完全忽略了输入数据!

为了说明DummyClassifier,首先我们创建一个不平衡的数据集:

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> iris = load_iris()
>>> X, y = iris.data, iris.target
>>> y[y != 1] = -1
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
     

接下来,让我们比较的准确性SVCmost_frequent

>>> from sklearn.dummy import DummyClassifier
>>> from sklearn.svm import SVC
>>> clf = SVC(kernel='linear', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test) 
0.63...
>>> clf = DummyClassifier(strategy='most_frequent',random_state=0)
>>> clf.fit(X_train, y_train)
DummyClassifier(constant=None, random_state=0, strategy='most_frequent')
>>> clf.score(X_test, y_test)  
0.57...

我们看到这SVC不比一个虚拟分类器好多了。现在,我们来更改内核:

>>> clf = SVC(kernel='rbf', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)  
0.97...
 

我们看到准确率提高到近100%。如果不太昂贵,建议采用交叉验证策略,以更好地估计精度。有关更多信息,请参阅交叉验证:评估估计器性能 部分。此外,如果要优化参数空间,强烈建议使用适当的方法; 有关详细信息,请参阅调整估计器部分的超参数

更一般地说,当分类器的准确性太接近随机时,这可能意味着出现了一些问题:特征没有帮助,超参数没有正确调整,分类器遭受类不平衡等...

DummyRegressor 还实现了四个简单的经验法则:

  • mean 总是预测训练目标的平均值。
  • median 总是预测培训目标的中位数。
  • quantile 总是预测用户提供了分数位的训练目标。
  • constant 总是预测用户提供的常数值。

在所有这些策略中,该predict方法完全忽略了输入数据。

 

  • 无标签