sklearn中的模型评估

约定不等于承诺〃 2021-09-30 04:42 384阅读 0赞

### 文章目录 ###

*   *  1.介绍
     *  2. scoring参数
        
         *  2.1 预定义的值
         *  2.2 从metric函数定义你的scoring策略
         *  2.3 实现你自己的scoring对象
     *  3. 分类metrics
        
         *  3.1 二分类/多分类/多标签
         *  3.2 accuracy\_score
         *  3.3 Cohen’s kappa
         *  3.4 混淆矩阵
         *  3.5 分类报告
         *  3.7 Jaccard相似度系数score
         *  3.8 准确率，召回率与F值
         *  3.8.1 二分类
         *  3.8.2 多元分类和多标签分类
         *  3.9 ROC
     *  4. Multilabel的ranking metrics
        
         *  4.1 范围误差（Coverage error）
         *  4.2 Label ranking平均准确率
     *  5.回归metrics
        
         *  5.1 可释方差值（Explained variance score）
         *  5.2 平均绝对误差（Mean absolute error）
         *  5.3 均方误差（Mean squared error）
         *  5.4 中值绝对误差（Median absolute error）
         *  5.5 R方值，确定系数
     *  6.聚类metrics
     *  7. Dummy estimators

## 1.介绍 ##

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

*  estimator的score方法：sklearn中的estimator都具有一个score方法，它提供了一个缺省的评估法则来解决问题。
 *  Scoring参数：使用cross-validation的模型评估工具，依赖于内部的scoring策略。见下。
 *  Metric函数：metrics模块实现了一些函数，用来评估预测误差。见下。

## 2. scoring参数 ##

模型选择和评估工具，例如： grid\_search.GridSearchCV 和 cross\_validation.cross\_val\_score，使用scoring参数来控制你的estimator的好坏。

### 2.1 预定义的值 ###

对于大多数case而说，你可以设计一个使用scoring参数的scorer对象；下面展示了所有可能的值。所有的scorer对象都遵循：高得分，更好效果。如果从mean\_absolute\_error 和mean\_squared\_error（它计算了模型与数据间的距离）返回的得分将被忽略。

### 2.2 从metric函数定义你的scoring策略 ###

sklearn.metric提供了一些函数，用来计算真实值与预测值之间的预测误差：

*  以\_score结尾的函数，返回一个最大值，越高越好
 *  以\_error结尾的函数，返回一个最小值，越小越好；如果使用make\_scorer来创建scorer时，将greater\_is\_better设为False

接下去会讨论多种机器学习当中的metrics。

许多metrics并没有给出在scoring参数中可配置的字符名，因为有时你可能需要额外的参数，比如：fbeta\_score。这种情况下，你需要生成一个合适的scorer对象。最简单的方法是调用make\_scorer来生成scoring对象。该函数将metrics转换成在模型评估中可调用的对象。

第一个典型的用例是，将一个库中已经存在的metrics函数进行包装，使用定制参数，比如对fbeta\_score函数中的beta参数进行设置：

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

第二个典型用例是，通过make\_scorer构建一个完整的定制scorer函数，该函数可以带有多个参数：

*  你可以使用python函数：下例中的my\_custom\_loss\_func
 *  python函数是否返回一个score（greater\_is\_better=True），还是返回一个loss（greater\_is\_better=False）。如果为loss，python函数的输出将被scorer对象忽略，根据交叉验证的原则，得分越高模型越好。
 *  对于分类问题的metrics：如果你提供的python函数是否需要对连续值进行决策判断，可以将参数设置为（needs\_threshold=True）。缺省值为False。
 *  一些额外的参数：比如f1\_score中的bata或labels。

下例使用定制的scorer，使用了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  = 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...

### 2.3 实现你自己的scoring对象 ###

你可以生成更灵活的模型scorer，通过从头构建自己的scoring对象来完成，不需要使用make\_scorer工厂函数。对于一个自己实现的scorer来说，它需要遵循两个原则：

*  必须可以用(estimator, X, y)进行调用
 *  必须返回一个float的值

## 3. 分类metrics ##

sklearn.metrics模块实现了一些loss, score以及一些工具函数来计算分类性能。一些metrics可能需要正例、置信度、或二分决策值的的概率估计。大多数实现允许每个sample提供一个对整体score来说带权重的分布，通过sample\_weight参数完成。

*  一些二分类(binary classification)使用的case：

>     matthews_corrcoef(y_true, y_pred)
>     precision_recall_curve(y_true, probas_pred)
>     roc_curve(y_true, y_score[, pos_label, …])

*  一些多分类(multiclass)使用的case：

> confusion\_matrix(y\_true, y\_pred\[, labels\]) hinge\_loss(y\_true,  
> pred\_decision\[, labels, …\])

*  一些多标签(multilabel)的case:

> accuracy\_score(y\_true, y\_pred\[, normalize, …\])  
> classification\_report(y\_true, y\_pred\[, …\]) f1\_score(y\_true, y\_pred\[,  
> labels, …\]) fbeta\_score(y\_true, y\_pred, beta\[, labels, …\])  
> hamming\_loss(y\_true, y\_pred\[, classes\])  
> jaccard\_similarity\_score(y\_true, y\_pred\[, …\]) log\_loss(y\_true,  
> y\_pred\[, eps, normalize, …\]) precision\_recall\_fscore\_support(y\_true,  
> y\_pred) precision\_score(y\_true, y\_pred\[, labels, …\])  
> recall\_score(y\_true, y\_pred\[, labels, …\]) zero\_one\_loss(y\_true,  
> y\_pred\[, normalize, …\])

*  还有一些可以同时用于二标签和多标签（不是多分类）问题：

> average\_precision\_score(y\_true, y\_score\[, …\]) roc\_auc\_score(y\_true,  
> y\_score\[, average, …\])

在以下的部分，我们将讨论各个函数。

### 3.1 二分类/多分类/多标签 ###

对于二分类来说，必须定义一些matrics（f1\_score，roc\_auc\_score）。**在这些case中，缺省只评估正例的label，缺省的正例label被标为1**（可以通过配置pos\_label参数来完成）

将一个二分类matrics拓展到多分类或多标签问题时，我们可以将数据看成多个二分类问题的集合，每个类都是一个二分类。接着，我们可以通过跨多个分类计算每个二分类metrics得分的均值，这在一些情况下很有用。你可以使用average参数来指定。

*  macro：计算二分类metrics的均值，为每个类给出相同权重的分值。当小类很重要时会出问题，因为该macro-averging方法是对性能的平均。另一方面，该方法假设所有分类都是一样重要的，因此macro-averaging方法会对小类的性能影响很大。
 *  weighted: 对于不均衡数量的类来说，计算二分类metrics的平均，通过在每个类的score上进行加权实现。
 *  micro： 给出了每个样本类以及它对整个metrics的贡献的pair（sample-weight），而非对整个类的metrics求和，它会每个类的metrics上的权重及因子进行求和，来计算整个份额。Micro-averaging方法在多标签（multilabel）问题中设置，包含多分类，此时，大类将被忽略。
 *  samples：应用在 multilabel问题上。它不会计算每个类，相反，它会在评估数据中，通过计算真实类和预测类的差异的metrics，来求平均（sample\_weight-weighted）
 *  average：average=None将返回一个数组，它包含了每个类的得分.

多分类（multiclass）数据提供了metric，和二分类类似，是一个label的数组，而**多标签（multilabel）数据则返回一个索引矩阵，当样本i具有label j时，元素\[i,j\]的值为1，否则为0.**

### 3.2 accuracy\_score ###

accuracy\_score函数计算了准确率，不管是正确预测的fraction（default），还是count(normalize=False)。

在multilabel分类中，该函数会返回子集的准确率。如果对于一个样本来说，必须严格匹配真实数据集中的label，整个集合的预测标签返回1.0；否则返回0.0.

预测值与真实值的准确率，在n个样本下的计算公式如下：  
![在这里插入图片描述][70]

1(x)为指示函数。

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

在多标签的case下，二分类label：

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

### 3.3 Cohen’s kappa ###

函数cohen\_kappa\_score计算了Cohen’s kappa估计。这意味着需要比较通过不同的人工标注（numan annotators）的标签，而非分类器中正确的类。

kappa score是一个介于(-1, 1)之间的数. score>0.8意味着好的分类；0或更低意味着不好（实际是随机标签）

Kappa score可以用在二分类或多分类问题上，但不适用于多标签问题，以及超过两种标注的问题。

### 3.4 混淆矩阵 ###

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

示例：

*  [Confusion matrix][]
 *  [Recognizing hand-written digits][]
 *  [ Classification of text documents using sparse features][Classification of text documents using sparse features]

### 3.5 分类报告 ###

classification\_report函数构建了一个文本报告，用于展示主要的分类metrics。 下例给出了一个小示例，它使用定制的target\_names和对应的label：

>>> from sklearn.metrics import classification_report
    >>> y_true = [0, 1, 2, 2, 0]
    >>> y_pred = [0, 0, 2, 2, 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      1.00      1.00         2
    
    avg / total       0.67      0.80      0.72         5

示例：

*  [识别手写数字示例][Recognizing hand-written digits]
 *  [使用sparse特征的文本分类][Classification of text documents using sparse features]

\#\#3 3.6 Hamming loss

hamming\_loss计算了在两个样本集里的平均汉明距离或平均Hamming loss。

ˆyj是对应第j个label的预测值，
    yj是对应的真实值
    nlabels是类目数

那么两个样本间的Hamming loss为LHamming，定义如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70]

其中：1(x)为指示函数。

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

在多标签（multilabel）的使用二元label指示器的情况：

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

注意：在多分类问题上，Hamming loss与y\_true 和 y\_pred 间的Hamming距离相关，它与0-1 loss相类似。然而，0-1 loss会对不严格与真实数据集相匹配的预测集进行惩罚。因而，Hamming loss，作为0-1 loss的上界，也在0和1之间；预测一个合适的真实label的子集或超集将会给出一个介于0和1之间的Hamming loss.

### 3.7 Jaccard相似度系数score ###

jaccard\_similarity\_score函数会计算两对label集之间的Jaccard相似度系数的平均（缺省）或求和。它也被称为Jaccard index.

第i个样本的Jaccard相似度系数（Jaccard similarity coefficient），真实标签集为yi，预测标签集为：ˆyj，其定义如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 1]

在二分类和多分类问题上，Jaccard相似度系数score与分类的正确率（accuracy）相同：

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

在多标签（multilabel）问题上，使用二元标签指示器：

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

### 3.8 准确率，召回率与F值 ###

准确率（precision）可以衡量一个样本为负的标签被判成正，召回率（recall）用于衡量所有正例。

F-meature（包括：Fβ和F1”），可以认为是precision和recall的加权调和平均（weighted harmonic mean）。一个Fβ值，最佳为1，最差时为0. 如果β=1，那么Fβ和F1相等，precision和recall的权重相等。

precision\_recall\_curve会根据预测值和真实值来计算一条precision-recall典线。

average\_precision\_score则会预测值的平均准确率（AP: average precision）。该分值对应于precision-recall曲线下的面积。

sklearn提供了一些函数来分析precision, recall and F-measures值：

average_precision_score：计算预测值的AP
        f1_score: 计算F1值，也被称为平衡F-score或F-meature
        fbeta_score: 计算F-beta score
        precision_recall_curve：计算不同概率阀值的precision-recall对
        precision_recall_fscore_support：为每个类计算precision, recall, F-measure 和 support
        precision_score： 计算precision
        recall_score： 计算recall

注意：precision\_recall\_curve只用于二分类中。而average\_precision\_score可用于二分类或multilabel指示器格式

### 3.8.1 二分类 ###

在二元分类中，术语“positive”和“negative”指的是分类器的预测类别(expectation)，术语“true”和“false”则指的是预测是否正确（有时也称为：观察observation）。给出如下的定义：  
实际类目（observation）  
预测类目（expectation） TP(true positive)结果:Correct FP(false postive)结果：Unexpected  
FN(false negative)结果: Missing TN(true negtive)结果：Correct

在这个上下文中，我们定义了precision, recall和F-measure:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 2]

这里是一个二元分类的示例：

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

### 3.8.2 多元分类和多标签分类 ###

在多分类（Multiclass）和多标签（multilabel）分类问题上，precision, recall, 和 F-measure的概念可以独立应用到每个label上。有一些方法可以综合各标签上的结果，通过指定average\_precision\_score （只能用在multilabel上）， f1\_score, fbeta\_score, precision\_recall\_fscore\_support, precision\_score 和 recall\_score这些函数上的参数average可以做到。

注意：

“micro”选项：表示在多分类中的对所有label进行micro-averaging产生一个平均precision，recall和F值
    “weighted”选项：表示会产生一个weighted-averaging的F值。

可以考虑下面的概念：

y是(sample, label)pairs的预测集
    ˆy是(sample, label)pairs的真实集
    L是labels的集
    S是labels的集
    ˆy是y的子集，样本s,比如：y_s :=  \left{(s’, l) \in y | s’ = s \right}
    yl表示label l的y子集
    同样的，ys和yl都是ˆy的子集
    P(A,B):=|A∩B||A|
    R(A,B):=|A∩B||B| 在处理B=∅时方式更不同；该实现采用R(A,B):=0，且与P相类似。
    Fβ(A,B):=(1+β2)P(A,B)×R(A,B)β2P(A,B)+R(A,B)

代码：

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

对于多分类问题，对于一个“negative class”，有可能会排除一些标签：

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

类似的，在数据集样本中没有出现的label不能用在macro-averaging中。

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

### 3.9 ROC ###

roc\_curve计算了ROC曲线。Wikipedia如下：

“A receiver operating characteristic (ROC), or simply ROC curve, is a graphical plot which illustrates the performance of a binary classifier system as its discrimination threshold is varied. It is created by plotting the fraction of true positives out of the positives (TPR = true positive rate) vs. the fraction of false positives out of the negatives (FPR = false positive rate), at various threshold settings. TPR is also known as sensitivity, and FPR is one minus the specificity or true negative rate.”

该函数需要二分类的真实值和预测值，它可以是正例的概率估计，置信值，或二分决策值。下例展示了如何使用：

>>> 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\_auc\_score函数计算了ROC曲线下面的面积，它也被称为AUC或AUROC。通过计算下面的面积，曲线信息被归一化到1内。

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

在多标签（multi-label）分类上，roc\_auc\_score通过对上面的label进行平均。

对比于其它metrics: accuracy、 Hamming loss、 F1-score, ROC不需要为每个label优化一个阀值。roc\_auc\_score函数也可以用于多分类（multi-class）问题上。如果预测的输出已经被二值化。

示例：

Receiver Operating Characteristic (ROC)
    Receiver Operating Characteristic (ROC) with cross validation
    Species distribution modeling

## 4. Multilabel的ranking metrics ##

在多标签学习上，每个样本都具有多个真实值label与它对应。它的目的是，为真实值label得到最高分或者最好的rank。

### 4.1 范围误差（Coverage error） ###

coverage\_error计算了那些必须在最终预测（所有真实的label都会被预测）中包含的labels的平均数目。如果你想知道有多少top高分labels（top-scored-labels）时它会很有用，你必须以平均的方式进行预测，不漏过任何一个真实label。该metrics的最优值是对真实label求平均。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 3]  
其中：$ \\text\{rank\}\{ij\} = \\left|\\left\{k: \\hat\{f\}\{ik\} \\geq \\hat\{f\}\_\{ij\} \\right\}\\right| $。给定rank定义，通过给出最大的rank，来打破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

### 4.2 Label ranking平均准确率 ###

label\_ranking\_average\_precision\_score函数实现了Label ranking平均准确率 ：LRAP（label ranking average precision）。该metric与average\_precision\_score有关联，但它基于label ranking的概念，而非 precision/recall 。

LRAP会对每个样本上分配的真实label进行求平均，真实值的比例 vs. 低分值labels的总数。如果你可以为每个样本相关的label给出更好的rank，该指标将产生更好的分值。得到的score通常都会比0大，最佳值为1。如果每个样本都只有一个相关联的label，那么LRAP就与平均倒数排名:mean reciprocal rank

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 4]

其中：

$ \\mathcal\{L\}\{ij\} = \\left\{k: y\{ik\} = 1, \\hat\{f\}\{ik\} \\geq \\hat\{f\}\{ij\} \\right\} $，  
$ \\text\{rank\}\{ij\} = \\left|\\left\{k: \\hat\{f\}\{ik\} \\geq \\hat\{f\}\_\{ij\} \\right\}\\right| $  
|⋅|是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...

## 5.回归metrics ##

sklearn.metrics 实现了许多种loss, score，untility函数来测评回归的性能。其中有一些可以作了增加用于处理多输出（multioutput）的情况：

mean_squared_error,
    mean_absolute_error
    explained_variance_score
    r2_score

这些函数具有一个multioutput关键参数，它指定了对于每一个单独的target是否需要对scores/loss进行平均。缺省值为’uniform\_average’，它会对结果进行均匀加权平均。如果输出的ndarray的shape为(n\_outputs,)，那么它们返回的entries为权重以及相应的平均权重。如果multioutput参数为’raw\_values’，那么所有的scores/losses都不改变，以raw的方式返回一个shape为(n\_outputs,)的数组。

r2\_score和explained\_variance\_score 对于multioutput参数还接受另一个额外的值：’variance\_weighted’。该选项将通过相应target变量的variance产生一个为每个单独的score加权的值。该设置将会对全局捕获的未归一化的variance进行量化。如果target的variance具有不同的规模（scale），那么该score将会把更多的重要性分配到那些更高的variance变量上。

对于r2\_score的缺省值为multioutput=’variance\_weighted’，向后兼容。后续版本会改成uniform\_average。

### 5.1 可释方差值（Explained variance score） ###

explained\_variance\_score解释了explained variance regression score

如果ˆy是估计的target输出，y为相应的真实(correct)target输出，Var为求方差（variance），即标准差的平方，那么可释方差（explained variance）的估计如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 5]

最好的可能值为1.0，越低表示越差。

示例如下：

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

### 5.2 平均绝对误差（Mean absolute error） ###

mean\_absolute\_error函数将会计算平均绝对误差，该指标对应于绝对误差loss（absolute error loss）或l1范式loss（l1-norm loss）的期望值。

示例：

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

### 5.3 均方误差（Mean squared error） ###

mean\_squared\_error用于计算平均平方误差，该指标对应于平方（二次方）误差loss（squared (quadratic) error loss）的期望值。

示例为：

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

示例：

*  [Gradient Boosting regression][]

### 5.4 中值绝对误差（Median absolute error） ###

median\_absolute\_error是很令人感兴趣的，它对异类（outliers）的情况是健壮的。该loss函数通过计算target和prediction间的绝对值，然后取中值得到。

MedAE的定义如下：  
![MedAE(y,ˆy)=median(∣y1−ˆy1∣,…,∣yn−ˆyn∣)][MedAE_y_y_median_y1_y1_yn_yn]

median\_absolute\_error不支持multioutput。

示例：

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

### 5.5 R方值，确定系数 ###

r2\_score函数用于计算R²（确定系数：coefficient of determination）。它用来度量未来的样本是否可能通过模型被很好地预测。分值为1表示最好，它可以是负数（因为模型可以很糟糕）。一个恒定的模型总是能预测y的期望值，忽略掉输入的feature，得到一个R^2为0的分值。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 6]

示例：

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

示例：

*  [Lasso and Elastic Net for Sparse Signals][]

## 6.聚类metrics ##

sklearn.metrics也提供了聚类的metrics。更多细节详见：

*  [Clustering performance evaluation][]
 *  [Biclustering evaluation][]

## 7. Dummy estimators ##

当进行监督学习时，一个简单明智的check包括：使用不同的规则比较一个estimator。DummyClassifier实现了三种简单的策略用于分类：

stratified：根据训练集的分布来生成随机预测
    most_frequent：在训练集中总是预测最频繁的label
    prior：总是预测分类最大化分类优先权（比如：most_frequent），predict_proba返回分类优化权
    uniform：以均匀方式随机生成预测
    constant：由用户指定，总是预测一个常量的label。该方法的一个最主要动机是：F1-scoring，其中正例是最主要的。

**注意，所有的这些策略中，predict方法会完成忽略输入数据**!

示例，我们首先创建一个imbalanced的数据集：

>>> from sklearn.datasets import load_iris
    >>> from sklearn.cross_validation 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)
    
    下一步，比较下SVC的accuary和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(constant=None, random_state=0, strategy='most_frequent')
    >>> clf.score(X_test, y_test)  
    0.57...

我们可以看到SVC并不比DummyClassifier好很多，接着，我们换下kernel：

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

我们可以看到，accuracy增强到了几乎100%。如果CPU开销不大，这里建议再做下cross-validation。如果你希望在参数空间进行优化，我们强烈推荐你使用GridSearchCV。

更一般的，分类器的accuracy太接近于随机，这可能意味着有可能会出问题：features没有用，超参数没有被正确设置，分类器所用的数据集imbalance，等等。。。

DummyRegressor也实现了4种简单的方法：

mean：通常预测训练target的均值。
    median：通常预测训练target的中值。
    quantile：预测由用户提供的训练target的分位数
    constant：常量

在上面的所有策略，predict完全忽略输入数据。

参考：

[http://scikit-learn.org/stable/modules/model\_evaluation.html][http_scikit-learn.org_stable_modules_model_evaluation.html]

转载于:https://www.cnblogs.com/JosonLee/p/10053713.html

[70]: /images/20210725/1552d190a20c4337903b589838c151a7.png
[Confusion matrix]: http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html#example-model-selection-plot-confusion-matrix-py
[Recognizing hand-written digits]: http://scikit-learn.org/stable/auto_examples/classification/plot_digits_classification.html#example-classification-plot-digits-classification-py
[Classification of text documents using sparse features]: http://scikit-learn.org/stable/auto_examples/text/document_classification_20newsgroups.html#example-text-document-classification-20newsgroups-py
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70]: /images/20210725/c214113e86aa41d199d1f5e2df3c40d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 1]: /images/20210725/c481df941e7643a09ae9767bd13d83d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 2]: /images/20210725/679c966391cf447e87676a301fad0841.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 3]: /images/20210725/623234294a57439c8f20101efbce0c3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 4]: /images/20210725/cce84433bfe440109a04f0969922d41d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 5]: /images/20210725/4863726bbb59429bb8ad8958e86b3e70.png
[Gradient Boosting regression]: http://scikit-learn.org/stable/auto_examples/ensemble/plot_gradient_boosting_regression.html#example-ensemble-plot-gradient-boosting-regression-py
[MedAE_y_y_median_y1_y1_yn_yn]: /images/20210725/7d6176be932947acae901efe0f7f991f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6dzIwMTY_size_27_color_FFFFFF_t_70 6]: /images/20210725/f613c79d3d3c4072bd2e2a38ad6b4f00.png
[Lasso and Elastic Net for Sparse Signals]: http://scikit-learn.org/stable/auto_examples/linear_model/plot_lasso_and_elasticnet.html#example-linear-model-plot-lasso-and-elasticnet-py
[Clustering performance evaluation]: http://scikit-learn.org/stable/modules/clustering.html#clustering-evaluation
[Biclustering evaluation]: http://scikit-learn.org/stable/modules/biclustering.html#biclustering-evaluation
[http_scikit-learn.org_stable_modules_model_evaluation.html]: http://scikit-learn.org/stable/modules/model_evaluation.html