>>> from sklearn import svm, datasets
>>> from sklearn.model_selection import cross_val_score
>>> X, y = datasets.load_iris(return_X_y=True)
>>> clf = svm.SVC(random_state=0)
>>> cross_val_score(clf, X, y, cv=5, scoring='recall_macro')
array([0.96..., 0.96..., 0.96..., 0.93..., 1.        ])
>>> model = svm.SVC()
>>> cross_val_score(model, X, y, cv=5, scoring='wrong_choice')
Traceback (most recent call last):
ValueError: 'wrong_choice' is not a valid scoring value. Use sorted(sklearn.metrics.SCORERS.keys()) to get va 

>>> 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, cv=5) 

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




    
...
>>> score(clf, X, y)
-0.69... 

>>> from custom_scorer_module import custom_scoring_function 
>>> cross_val_score(model,
...  X_train,
...  y_train,
...  scoring=make_scorer(custom_scoring_function, greater_is_better=False),
...  cv=5,
...  n_jobs=-1)  

>>> scoring = ['accuracy', 'precision'] 

>>> from sklearn.metrics import accuracy_score
>>> from sklearn.metrics import make_scorer
>>> scoring = {'accuracy': make_scorer(accuracy_score),
...            'prec': 'precision'} 

>>> from sklearn.model_selection import cross_validate
>>> from sklearn.metrics import confusion_matrix
>>> # A sample toy binary classification dataset
>>> X, y = datasets.make_classification(n_classes=2, random_state=0)
>>> svm = LinearSVC(random_state=0)
>>> def tn(y_true, y_pred): return confusion_matrix(y_true, y_pred)[0, 0]
>>> def fp(y_true, y_pred): return confusion_matrix(y_true, y_pred)[0, 1]
>>> def fn(y_true, y_pred): return confusion_matrix(y_true, y_pred)[1, 0]
>>> def tp(y_true, y_pred): return confusion_matrix(y_true, y_pred)[1, 1]
>>> scoring = {'tp': make_scorer(tp), 'tn': make_scorer(tn),
...            'fp': make_scorer(fp), 'fn': make_scorer(fn)}
>>> cv_results = cross_validate(svm.fit(X, y), X, y, cv=5, scoring=scoring)
>>> # Getting the test set true positive scores
>>> print(cv_results['test_tp'])
[10  9  8  7  8]
>>> # Getting the test set false negative scores
>>> print(cv_results['test_fn'])
[0 1 2 3 2] 

在随后的各子部分中，将会描述每一个上述函数，使用常用的API和指数定义。

一些指标本质上是定义给二分类模型的（例如： f1_score ）。在这些例子中，模型的默认值是只有正标签会被评估，假设正样本类的标签为1是初始值（尽管标签可以通过pos_label参数进行修改）。

由二分类指标延伸到多类或者多标签问题，数据被当作是二分类问题的集合，每个类都有一个。有一系列的方法可用于计算类集合的平均二分类指标，每个二分类指标可以应用于某些领域中。如果需要，可以使用average参数进行定义。

当多分类数据作为类标签数组提供给指标时，如二分类标签，多标签数据就会被指定为一个指标矩阵。 如元素（一个列表形式）[i, j]，如果样本i被标记为j，则其值为1，否则为0。

3.3.2.2 准确率评分

accuracy_score 函数计算 accuracy （准确率），或者是个分数（初始值）或者是正确预测个数的计数（normalize=False）。

在多标签分类中，函数返回各子集的准确率。如果整个集合中每一个样本的预测标签严格匹配集合中的标签真实值，子集的准确率是1.0；否则是0.0。

如果 是第i个样本的预测值与真实值 相一致，对

其中*l(x)*是指标函数（ indicator function ）。

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

3.3.2.3 平衡的准确率评分（Balanced accuracy score）

balanced_accuracy_score 函数计算 balanced accuracy ，避免了对不平衡数据集进行夸大的性能估计。每个类别召回率的宏平均，或者等同于每个样本根据真实类别的比率（inverse prevalence）的权重，而计算的原始准确率。因此，对于平衡样本，平衡的准确率评分（Balanced accuracy score）与准确率相同。

在二分类的例子中，平衡的准确率与灵敏度（ sensitivity ）相同（真正率）和特异性（ specificity ）（真负率），或者ROC曲线的面积（二分类预测值而不是分数）：

如果分类器在每个类的表现都很好，则该函数会退化为传统的准确率（例如：正确预测的个数除以总预测样本数）。

与之相对比，如果传统的准确率高于样本比例，仅因为分类器利用的是不均衡测试集，而对于平衡的准确率，会下降为

分数范围为0-1，或者当参数adjusted=True时，范围变为

如果 是第i个样本的真实值， 是对应的样本权重，从而调整的样本权重为：

其中， l(x )是指标函数。根据样本i的预测值 ，平衡的准确率被定义如下：

设置adjusted=True，平衡的准确率报告的是比 相对高的值。在二分类的例子中，也被称为 *Youden's J statistic* 或者 informedness 。

**注意：**多分类的定义看起来是用于二分类指标的合理延伸，尽管在文献中未达成共识。

Guyon2015( 1 , 2 ) I. Guyon, K. Bennett, G. Cawley, H.J. Escalante, S. Escalera, T.K. Ho, N. Macià, B. Ray, M. Saeed, A.R. Statnikov, E. Viegas, Design of the 2015 ChaLearn AutoML Challenge , IJCNN 2015.

Mosley2013( 1 , 2 ) L. Mosley, A balanced approach to the multi-class imbalance problem , IJCV 2010.

Kelleher2015 John. D. Kelleher, Brian Mac Namee, Aoife D’Arcy, Fundamentals of Machine Learning for Predictive Data Analytics: Algorithms, Worked Examples, and Case Studies , 2015.

Urbanowicz2015 Urbanowicz R.J., Moore, J.H. ExSTraCS 2.0: description and evaluation of a scalable learning classifier system , Evol. Intel. (2015) 8: 89.

3.3.2.4 Cohen's kappa

cohen_kappa_score 函数计算 Cohen's kappa 统计值。此度量旨在比较不同标注的标签，而分类器和真实数据的比较。

Kappa score（参见文档字符串）是一个数值，介于-1和1之间。分数大于0.8会被认为是好的协议；小于0说明没有协议（等同于随机标签）。

Kappa score可被用于计算二分类或者多分类的问题，但不适用于多标签的问题（除手动计算每一个标签分数）和多于两个以上注释器的问题。

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

3.3.2.5 混淆矩阵

confusion_matrix 函数评估分类模型准确率，通过计算每一行相对应真实类别（维基百科或者其它资料可能使用不同的轴向）的混淆矩阵（ confusion matrix ）。

根据定义， 混淆矩阵中的条目 i,j 是实际为 i ，但是预测为 j 的观测个数。

如下示例：

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

plot_confusion_matrix 可被用于展示混淆矩阵的可视化，在 混淆矩阵 的例子中，如下图所示：

>>> y_true = [0, 0, 0, 1, 1, 1, 1, 1]
>>> y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
>>> confusion_matrix(y_true, y_pred, normalize='all')
array([[0.25 , 0.125],
       [0.25 , 0.375]]) 

对于二分类问题，可以得到真负值计数，假正值计数，假负值计数和真正值计数，详见如下代码：

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

3.3.2.6 分类模型报告

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

    accuracy                           0.60         5
   macro avg       0.56      0.50      0.49         5
weighted avg




    
       0.67      0.60      0.59         5  

3.3.2.7 Hamming损失函数

Hamming_loss 计算平均的 Hamming loss 或者Hamming distance在两个样本的集合中。

如果 是某个样本第 j 个标签的预测值， 是其对应的真实值，

其中，*l(x)*是指标函数（ indicator function ）。

>>> 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_true和y_pred的Hamming损失函数与Hamming距离相一致，Hamming损失函数与零一损失函数（ Zero one loss ）相类似。但是零-一损失函数惩罚预测集合，预测集不与真实值集直接匹配，Hamming损失函数惩罚单个标签。因次，Hamming损失函数的上限是零一损失函数，它介于零和一之间，包括边界；预测真实标签合适的子集或者超子集会使Hamming损失函数界于零和一之间，不包括边界。

3.3.2.8 精确率，召回率和F-measures

直观地说，精确率（ precision ）是模型区分的能力，而不是将样本为负的标签标记为正，而召回率（ recall ）是找到正样本的能力。

F-measure （ 和 测量）可被解释为精确率和召回率的权重调和平均数。 测量值最高为1，最差为0。当 时， 和 是相等的，并且召回率和精确率是同等重要的。

precision_recall_curve 从真实标签和评分（不同阈值设定下，分类器的评分）计算一个精确率-召回率曲线.

average_precision_score 函数从预测分数中计算平均精确率（ average precision （AP））。该值介于0和1之间，且越高越好。AP的定义如下：

其中， 和 是在第n个阈值下的精确率和召回率，AP是正样本的分数。

参考[Manning2008]和[Everingham2010]展现AP的替代变体，它差值计算精确率-召回率曲线。 目前，average_precision_score并不能执行各种差值的变体。参考[Davis2006]和[Flach2015]描述了为何精确率-召回率曲线上点的线性插值产生的结果是过于乐观的分类器表现测量。线性插值被用于计算带有梯形法则的ROC曲线面积，即 auc 。

以下函数提供对精确率，召回率和F-measure评分的解释：

需要注意的是： precision_recall_curve 函数只能用于二分类的例子中。 average_precision_score 函数可以用于二分类的分类模型和多标签形式。 plot_precision_recall_curve 函数画出精确率召回率关系图，如下所示。

[Manning2008] C.D. Manning, P.Raghavan, H. Schütze, Introduction to Information Retrieval , 2008.

[Everingham2010] M. Everingham, L.Van Gool, C.K.I. Williams, J. Winn, A. Zisserman, The Pascal Visual Object Classes (VOC) Challenge , IJCV 2010.

[Davis2006] J. Davis, M. Goadrich, The Relationship Between Precision-Recall and ROC Curves , ICML 2006.

[Flach2015] P.A. Flach, M. Kull, Precision-Recall-Gain Curves: PR Analysis Done Right , NIPS 2015.

3.3.2.8.1 二分类分类模型

在二分类分类模型中，分类预测中的“正”和“负”，“真”和“假”指的是预测值是否与外部评判（也作“观测值”）相一致。基于这些定义，可以总结一下表格：

如下是二分类分类模型代码示例：

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

3.3.2.8.2 多分类和多标签分类模型

在多分类和多标签分类任务中，精确率，召回率，和F-measures的定义可以应用于每一个独立的标签。有很多方法可以将各标签的结果进行组合，可用average参数分别在 average_precision_score （仅用于多标签）， f1_score ， fbeta_score ， precision_recall_support ， precision_score 和 recall_score 函数中传递，已在以上描述( above )。需要注意的是：如果所有的标签啊都包括在内，那么“micro”-averaging（“微”-平均）在多分类中的设置将产生精确率，召回率和F与准确率的结果相等。也要注意"权重"平均可能产生不介于精确率和召回率之间的F-score。

为了更清晰的了解，请考虑如下概念：

各指标定义如下：

对于带有“负类”的多分类类别，可以除去一些标签：

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

同样地，一些未在样本中出现的标签，可以考虑使用宏-平均（macro-averaging）。

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

3.3.2.9 Jaccard相似性系数评分

jacquard_score 函数计算 Jaccard similarity coefficients （Jaccard相似性系数）的均值，也被称为Jaccard指数，在标签对的集合中。

第 i 个样本的Jaccard相似性系数， 与 真实标签和预测标签的定义如下：

jaccard_score 与 precision_recall_fscore_support 的作用类似，应用于二分类标签，并且通过使用参数average可以扩展到多标签和多分类（详见 above ）。

在二分类例子中：

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

用二分类标签指标的多标签例子：

>>> jaccard_score(y_true, y_pred, average='samples')
0.5833...
>>> jaccard_score(y_true, y_pred, average='macro')
0.6666...
>>> jaccard_score(y_true, y_phred, average=None)
array([0.5, 0.5, 1. ]) 

多分类问题被二分类化，并且与多标签问题的解决方法一致：

>>> y_pred = [0, 2, 1, 2]
>>> y_true = [0, 1, 2, 2]
>>> jaccard_score(y_true, y_pred, average=None)
array([1. , 0. , 0.33...])
>>> jaccard_score(y_true, y_pred, average='macro')
0.44...
>>> jaccard_score(y_true, y_pred, average='micro')
0.33... 

3.3.2.10 Hinge loss

hinge_loss 函数指通过使用 hinge loss 方法计算模型和数据之间的平均距离，它是一个单边指数，即仅考虑预测误差。（Hinge loss被用于最大化边际分类器，如支持向量机。）

如果标签被编码为+1和-1， y ：是真实值， w 是预测决策，是decision_function的产出值，hinge loss被定义如下：

如果多于两个标签，根据Crammer & Singer， hinge_loss 使用多分类变体。详见 论文 链接。

如果 是真实样本的预测决策， 是所有样本预测决策的最大值，预测决策是预测函数的返回值，多分类hinge loss的定义如下：

如下是用带有 hinge_loss 函数的支持向量机分类器解决的二分类问题的小例子：

>>> 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(random_state=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 函数的支持向量机分类器解决多分类问题的小例子：

>>> 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()
>>> pred_decision = est.decision_function([[-1], [2], [3]])
>>> y_true = [0, 2, 3]
>>> hinge_loss(y_true, pred_decision, labels)
0.56... 

3.3.2.11 对数损失函数（Log loss）

对数损失函数，也被称作逻辑回归损失函数或者交叉熵损失函数，是基于可能性的估计值。它被广泛应用于（多项式）逻辑回归和神经网络模型中，以及一些计算期望最大化的变种模型，并且被用于评估一个分类器而不是离散预测值的可能性产出（predict_proba）。

对于带有 真实标签二分类分类模型和一个可能性估计 ，每个样本的对数损失函数是给定真实标签分类器的负对数似然值：

它延伸到多分类的例子如下所示。样本中的真实标签可以被编码为1-of-K 二分类指标矩阵 Y，例如： 如果样本 i 的标签 k 是从标签集合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... 

y_pred参数列表[.9, .1]中的第一个值表示第一个样本被标记为0的可能性为90%。对数损失函数是非负的。

3.3.2.12 马修斯相关系数

对于二分类， matters_corrcoef 函数计算的是 Matthew's correlation coefficient (MCC) 。 下面引用自维基百科：

“马修斯相关系数被用于机器学习是作为测量二分类（两类）分类模型质量的评估。它考虑真正，假正，真负和假负，并且被认为是一个平衡值，可被用于类大小不均衡的数据。马修斯相关系数（MCC）本质上是一个介于-1和+1之间的相关系数值。如果系数值为+1，则表示预测非常好，0表示一个平均随机的预测，-1表示预测相反。在统计学中也被称作phi系数。”

在二分类（两类）的例子中，tp,tn,fp和fn分别是真正，真负，假正和假负的数量，MCC被定义如下：

在多分类的例子中，马修斯相关系数被定义为可以根据 K 个分类计算混淆矩阵 C 。为了简化定义，考虑如下的中间变量：

多分类MCC被定义为：

当多于两个标签时，MCC的值不再介于-1和+1之间。而是最小值值介于-1和0之间，且依据真实标签的数量和分布而定。最大值依然是+1。

以下是解释 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... 

3.3.2.13 多标签混合矩阵

multilabel_confusion_matrix 函数计算class-wise（初始值）或者sample-wise（sample wise = True）多标签混淆矩阵来评估分类模型的准确率。如果是多标签，多标签混淆矩阵（multilabel_confusion_matrix）也被认为是多分类数据。这种转变被普遍用于使用二分类分类模型指标（例如精确率，召回率等。）评估多分类问题。

当计算class-wise多标签混淆矩阵 C ，类别 i 的真负个数是 ，假负是 ，真正是 ，和假正是 。

如下示例解释带有 多标签指标矩阵 （多标签指标矩阵）投入的 multilabel_confusion_matrix 函数的使用：

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

或者，可以为每一个标签构建一个混淆矩阵：

>>> multilabel_confusion_matrix(y_true, y_pred, samplewise=True)
array([[[1, 0],
        [1, 1]],
<BLANKLINE>
       [[1, 1],
        [0, 1]]]) 

如下例子解释了带有 multiclass （多分类）投入的 multilabel_confusion_matrix 的使用：

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




    
, 2]],

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

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

如下是一些例子，解释使用multilabel_confusion_matrix函数计算多标签指标矩阵投入的，每一个类别的召回率（或者灵敏度），特异度，fall out（假正率）和 miss rate（假负率）。

计算每一个类的 recall （召回率）（也被称作真正率和灵敏度）：

>>> y_true = np.array([[0, 0, 1],
...                    [0, 1, 0],
...                    [1, 1, 0]])
>>> y_pred = np.array([[0, 1, 0],
...                    [0, 0, 1],
...                    [1, 1, 0]])
>>> mcm = multilabel_confusion_matrix(y_true, y_pred)
>>> tn = mcm[:, 0, 0]
>>> tp = mcm[:, 1, 1]
>>> fn = mcm[:, 1, 0]
>>> fp = mcm[:, 0, 1]
>>> tp / (tp + fn)
array([1. , 0.5, 0. ]) 

计算每一个类的 specificity （特异度）（也被称作真负率）

>>> tn / (tn + fp)
array([1. , 0. , 0.5]) 

计算每个类的 fall out （也被称作假正率）：

>>> fp / (fp + tn)
array([0. , 1. , 0.5]) 

计算每一个类的 miss rate （也被称作假负率）：

>>> fn / (fn + tp)
array([0. , 0.5, 1. ]) 

3.3.2.14 Receiver operating characteristic (ROC)

roc_curve 函数计算 receiver operating characteristic curve, or ROC curve 。引用维基百科：

“receiver operating characteristic (ROC)，或简称ROC 曲线， 是一个图，它解释二分类分类器系统随着不同阈值变化的表现。用来绘制在各种阈值的设置中，真正数占总正样本的比率（TPR = 真正率（true positive rate））与假正数占总负样本的比率（FPR = 假正率（false positive rate））之间的关系。TPR也被认为是敏感度，和FPR（1-敏感度或者真负率）。”

这个函数要求真二分类值和目标分数，它或者是正类别的可能性估计，置信度值，或者是二分类决策值。如下是使用 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. , 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 ]) 

下图是上例ROC曲线：

>>> 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_curve 函数可以通过在标签上进行平均来扩展，如上 例子 。

诸如子集准确率，Hamming损失函数，或者F1分数相比，ROC不能给每一个标签提供最佳的阈值。 roc_auc_score函数可以用于多类别分类模型。当前有两个平均策略可以使用：one-vs-one算法计算ROC AUC评分的均值；one-vs-rest算法计算每一个类ROC AUC评分的均值，而不是总均值。在上面两个例子中，预测标签以数组形式提供，值的范围是0到n_classes，评分与属于某类样本的可能性估计值相一致。OvO和OvR算法支持均匀加权（average = "macro"）和prevalence（average = "weighted"）。

One-vs-one Algorithm: 计算所有可能类组合的AUC的均值。[HT2001]定义一个多类别AUC指标均匀权重：

其中c是类的个数，AUC(j|k)是类别j作为正类和类别k作为负类的AUC值。总而言之， 在多分类的例子中。这个算法是用"ovo"给参数multiclass赋值和"macro"给"average"赋值。

[HT2001]多分类AUC指标可以延伸到用prevalence进行加权：

其中c是类别数。该算法是用“ovo”给参数multiclass赋值，和用“weighted”给参数average赋值。“weighted”选项返回一个prevalence-weighted均值，详见如下描述[FC2009]。

**One-vs-rest Algorithm: **计算每个类别的AUC而不是剩余的[PD2000]。该算法在功能上与多标签的例子相同。通过设置"ovr"给参数multiclass来使用该算法。正如OvO, OvR支持两种均值策略：“macro”[F2006]和"weighted"[F2001]。

在那些高 （false positive rate）不被容忍的情况下，roc_auc_score函数的参数max_fpr可被用来把ROC曲线累加到一个给定的限制。

HT2001( 1 , 2 ) Hand, D.J. and Till, R.J., (2001). A simple generalisation of the area under the ROC curve for multiple class classification problems. Machine learning, 45(2), pp.171-186.

[FC2009] Ferri, Cèsar & Hernandez-Orallo, Jose & Modroiu, R. (2009). An Experimental Comparison of Performance Measures for Classification. Pattern Recognition Letters. 30. 27-38.

[PD2000] Provost, F., Domingos, P. (2000). Well-trained PETs: Improving probability estimation trees (Section 6.2), CeDER Working Paper #IS-00-04, Stern School of Business, New York University.

[F2006] Fawcett, T., 2006. An introduction to ROC analysis. Pattern Recognition Letters, 27(8), pp. 861-874.

[F2001] Fawcett, T., 2001. Using rule sets to maximize ROC performance In Data Mining, 2001. Proceedings IEEE International Conference, pp. 131-138.

3.3.2.15 Zeor one loss

zero_one_loss 函数是通过 来计算0-1分类模型的损失函数（ ）的求和或者均值。初始情况下，函数会将整个数据标准化。为了得到 的求和，设置normalize=False。

在多标签分类模型中， zero_one_loss 给子集打分，严格按照标签和预测值的对应关系，如果有任何错误，都评为0分。初始情况下，函数返回未能较好预测的子集比例。如果想得到这样的子集计数，设置normalize = False。

如果 是第i个样本的预测值， 是与值对应的真实值，那么0-1损失函数 就被如下定义：

其中*l(x)*是 指标函数 （indicator function）。

>>> 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 score是一个合适的评分函数，它测量概率预测的准确率。它适用于预测必须将该率分配给一组相互排斥的离散结果的任务。”

该函数返回一个实际结果与预测的可能结果的可能性之间的均方差的评分。实际结果应是1或者0（真或假），尽管实际结果的预测可能性是一个介于0和1之间的数。

brier分数损失也是一个介于0和1之间的数，评分越低（均方差很小），预测越准确。它被看作是测量一个可能性预测集合的“标尺”。

其中： N 是总预测值， 是实际结果 的预测可能性。

以下是使用该函数的小例子：

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

3.3.3 多标签排序指标

>>> 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 函数执行标签排名平均精确度（label ranking average precision LRAP）。这个指标与 average_precision_score 函数相联系，但是基于标签排名的概念而不是精确度和召回率。

标签排名平均精确度（LRAP）平均所有样本，并是回答如下问题的答案：对于每一个真实标签，多大的较高排名标签的比例是真实的标签？如果可以与每一个样本相关的排名，这个指标测量值会较高。得到的评分均会大于0，最佳值是1。如果每个样本有一个确定的相关标签，标签排名平均精确度等价于 mean reciprocal rank 。

形式上地，给定一个真实标签的二分类指标矩阵 ，且与每个标签相联系的评分 ，平均精确度的定义如下：

其中 计算集合的基数（例如，集合中元素的数量）， 是 “范式”（它计算向量中非零元素个数）。

如下是使用该函数的小例子：

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

3.3.3.3 排序损失

label_ranking_loss函数用于计算排序损失，它计算样本中标签匹配排序不正确的个数均值。例如，真实标签的得分比错误标签的得分低，赋予排序的错误和正确标签匹配个数倒数作为权重。最低的排序损失值为0。

给定一个真实标签 的二分类指标矩阵，以及与每一个标签相联系的评分 ，排序损失函数的定义如下：

其中， 计算集合的基数（例如，集合中各元素的个数）以及 是 "范式"（它计算向量中非零元素的个数）。

如下是使用该函数的小例子：

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

参考资料：

3.3.3.4 Normalized Discounted Cumulative Gain

Discounted Cumulative Gain(DCG)和Normalized Discounted Cumulative Gain(NDCG)均是排序指数；它们对预测序列和真实得分进行比较，例如一个查询答案的相关性。

在维基百科中对于Discounted Cumulative Gain的解释如下：

“Discounted cumulative gain(DCG)是一个对排序质量的测量。在信息检索中，该指标经常被用来搜索引擎算法或者相关应用的效率。在搜索引擎结果集中，使用文档的分级相关性比例，DCG基于它在结果列表中的位置，测量文档有用性，或者增益。增益在结果表中是由上到下的累积，根据每一个结果的增益，不考虑较低的排名。”

DCG在预测序列中，给正确标签排序（例如查询答案的相关性），然后乘以对数衰减，最后汇总求和。在最先的K个结果后，求和会被截断，因此称它为DCG@K。KDCG，或者NDCG@K是DCG除以最佳预测对应的DCG，从而该值是介于0和1之间的。通常，NDCG优先于DCG。

与排序损失作比较，NDCG能够考虑相关性评分，而不是真实值排序。所以，所过真实值仅由一个序列构成，使用排序损失会更好；如果真实值是由实际有用性评分构成（例如，0表示不相关，1表示相关，2表示非常相关），可以选用NDCG。

对于某样本，给定每一个标签 的连续真实值向量，其中 M 是返回值的个数，预测值是 ，它是排序函数的索引 f ，DCG评分是：

并且，NDCG评分是DCG评分除以从 y 中得到的DCG评分。

参考资料：

3.3.4 回归指标

skearn.metrics 模块实现一些损失函数，评分，并且应用函数去测度回归标签。其中一些已经改进，可以处理多指标案例： mean_squared_error ， mean_absolute_error ， explained_variance_score 和 r2_score 。

这些函数使用关键参数multioutout，它指定计算方式，每一个标签的得分或损失都会被平均。初始值是“uniform_average”，它指定给所有输出均匀权重，计算所有输出的平均值。如果一个ndarray的形状（n_outputs,）被传入，它的各条目会被解释为权重，同时返回相应的加权平均值。如果multioutput的值指定为“raw_values”，则所有未改变的得分或损失将会被返回，并以数组形式返回（n_outputs,）。

r2_score 和 explained_variance_score 接受一个额外的值"variance_weighted"给multioutput参数。这个选项是每一个得分的权重通过与目标变量相一致的方差得到。这个设置量化全局捕捉未缩放的方差。如果目标变量是不同的比例，那么这个分数就会将更多的重点放到解释较高方差的变量上。对于向后兼容，r2_score的初始值是multioutput = "variance_weighted"。这个值将会在未来变为uniform_average。

3.3.4.1 可解释的方差分数

explained_variance_score 计算 explained variance regression score 。

如果 是标签估计值， 是与之相一致（正确）的标签输出，并且Var是 Variance ，标准差的平方，则可解释的方法计算如下：

最好的可能取值是1.0，值越低越不好。

如下是一个使用 explained_variane_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... 

3.3.4.2 最大误差

max_error 函数计算最大残差（ residual error ），它是捕捉预测值和真实值中最不好的误差。在一个完美拟合的单输出回归模型中，max_error在训练集上可能为0，但是在现实中基本不可能出现这种情况，这个指标表明拟合模型的误差程度。

如果 是第 i 个样本的预测值， 是与之相一致的真实值，最大误差定义如下：

如下是使用 max_error 函数的小例子：

>>> from sklearn.metrics import max_error
>>> y_true = [3, 2, 7, 1]
>>> y_pred = [9, 2, 7, 1]
>>> max_error(y_true, y_pred)
6 

max_error 不支持多输出（multioutput）。

3.3.4.3 平均绝对误差

mean_absolute_error 函数计算 mean absolute error ，一个与绝对误差损失或者 -正则损失相一致的风险指标。

如果 是第 i 个样本的预测值，且y{i}是与之相一致的真实值， 样本的平均绝对误差（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.85... 

3.3.4.4 均方误差

mean_squared_error 函数计算 mean square error ，平方（二次的）误差或损失的期望值相一致的风险指标。

如果 是第i个样本的预测值， 是与之相一致的真实值，均方误差（MAE）对 的估计值被定义如下：

如下是一个使用 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... 

3.3.4.5 均方误差对数

mean_squared_log_error 函数计算与平方（二次方）对数误差或损失的期望值相一致的风险指标。

如果 是第i个样本的预测*值， 是与之相一致的真实值，那么如下定义是 的均方误差对数（MSLE）：

其中， 表示 x 的自然对数。当目标呈指数倍增长的时候，最好使用这个方法，例如人口计数，跨度为一年的商品平均销售额等。需要注意的是：这个指标惩罚低于预测值的多余于高于预测值的。

如下是使用mean_squared_error函数的小例子：

>>> from sklearn.metrics import mean_squared_log_error
>>> y_true = [3, 5, 2.5, 7]
>>> y_pred = [2.5, 5, 4, 8]
>>> mean_squared_log_error(y_true, y_pred)
0.039...
>>> y_true = [[0.5, 1], [1, 2], [7, 6]]
>>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]]
>>> mean_squared_log_error(y_true, y_pred)
0.044... 

3.3.4.6 中值绝对误差

median_absolute_error是一个有趣的指标，因为它对异常值具有鲁棒性。这个损失通过目标值和预测值所有绝对插值的中值来计算。

如果 是第 i 个样本的预测值， 是与之相一致的真实值，那么中值绝对误差（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 

3.3.4.7 R² score，可决系数

r2_score 函数计算 coefficient of determination ，通常用R²表示。

它代表方差（y的）的比例，被解释为模型中的独立变量。它是模型的拟合度指数，因此，可以代表模型对未知数据的预测好坏程度，通过计算可解释方差的比例。

因此，方差取决于数据集，对比不同的数据集R²，可能不具有意义。最好的分数是1，且它可以小于零（因为模型可能会变得更糟）。一个常数模型在预测y的期望值时，不考虑输入特征，它的R²得分可能为0.0。

如果 是样本 i 的预测值，那么 是与所有n个样本相一致的真实值，则R²的估计表达式为：

其中， 和 。

需要注意的是： r2_score 计算的是未调整的R²（没有调整y的样本方差的偏差）。

如下是使用 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... 

3.3.4.8 平均泊松，Gamma，和Tweedie偏差

mean_tweedie_deviance 函数使用power参数（p）计算 mean Tweedie deviance error 。

此指标可得出回归目标的预测期望值。

存在以下特殊情况：

如果 是第 i 个样本的预测值， 是与之相对应的真实值，则估计 的平均Tweedie偏差误差（D）对于参数为p如下：

Tweedie偏差是一个自由度为2-power的齐次函数。因此，power = 2时的Gamma分布表明同时缩放y_true和y_pred对偏差没有影响。对于power=1的泊松分布偏差呈线性比例，二次地正态分布（power=0）。总而言之，在真实和预测值之间，越高的power，越少的权重赋予给极端偏差。

例如，比较两个预测值1.0和100，它们均与真实值相差50%。

均方误差（power=0）对于与预测值不同的第二点非常敏感，：

>>> from sklearn.metrics import mean_tweedie_deviance
>>> mean_tweedie_deviance([1.0], [1.5], power=0)
0.25
>>> mean_tweedie_deviance([100.], [150.], power=0)
2500.0 

如果将power设置为1：

>>> mean_tweedie_deviance([1.0], [1.5], power=1)
0.18...
>>> mean_tweedie_deviance([100.], [150.], power=1)
18.9... 

误差在下降。最后，设置power = 2：

>>> mean_tweedie_deviance([1.0], [1.5], power=2)
0.14...
>>> mean_tweedie_deviance([100.], [150.], power=2)
0.14... 

可以得到相同的误差。当power = 2时，偏差只对相对误差敏感。

3.3.5 聚类指标

sklearn.metrics 模块实行几种损失，评分和实用功能。详见 Clustering performance evaluation 部分的聚类示例，以及 Biclustering evaluation 的双集群。

3.3.6 Dummy 评估器

当是有监督机器学习时，一个简单的方法是用某个估计器的结果与经验相比较。 DummyClassifier 实现一些简单的分类策略：

需要注意的是：所有这些策略，predict方法完全忽略输入数据！

为了解释 DummyClassifier ，首先需要创建一个不平衡数据集：

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

下一步，比较SVC和most_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(random_state=0, strategy='most_frequent')
>>> clf.score(X_test, y_test)
0.57... 

SVC没有dummy 分类器做的好。现在，改变SVC的核函数：

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

可以看到准确率提升到接近100%。如果不是因为消耗CPU成本太高，交叉验证的策略值得推荐使用以找到更高的准确率估计。详见 交叉验证：评估模型表现 部分。 如果想优化参数空间，强烈推荐使用合适的方法；详见 调整估计器的超参数 部分。

整体上，当一个分类器的结果太接近随机选取的时候，可能意味着哪里出了问题：也许是特征选取的不合适，超参数选取的不合适，分类器不能很好的作用在不均衡样本上，等...

DummyRegressor 也可以执行回归的四个简单经验法则：

在所有这些策略中，predict 方法完全忽略投入数据。